# Kusho CLI

KushoAI CLI takes your recorded user flows and generates exhaustive test variations. Record your user flow once, and KushoAI creates multiple test cases with different inputs, edge cases, and scenarios to provide thorough test coverage. The tool transforms manual testing into intelligent, automated test scenarios with minimal effort.

Install Node.js using nvm (Node Version Manager):

# Install nvm (if not already installed)
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.0/install.sh | bash

# Restart your terminal or run:
source ~/.bashrc

# Install and use Node.js 18 or later
nvm install 18
nvm use 18

# Verify installation
node --version
npm --version

Please note that these instructions are for bash. The setup may differ slightly for other terminals.

Alternatively, you can download the binaries from here and install them.

Make sure Git is installed on your system. Git is essential for version control and helps in managing your project setup seamlessly. You can download it for free from the official Git website.

A terminal editor is essential for editing test scripts during the generation process. Install one of the following:

# Install Vim
winget install vim.vim

# might need adding the vim program files to the path and a terminal restart before it starts working

# Install Vim
brew install vim

# Check if nano is available (often pre-installed)
which nano

# Install Vim
sudo apt-get install vim

# Or install Nano
sudo apt-get install nano

• Vim for Windows
• Nano for Windows
• Git for Windows

vim --version
# Or try: nano --version, vi --version

git clone https://github.com/kusho-co/kusho-cli.git
cd kusho-cli

npm install

npx playwright install  # this will install the browser binaries

# Link the package globally to use the 'kusho' command
npm link

After linking, you can use the kusho command syntax throughout your terminal.

Before recording, configure your authentication:

kusho credentials

You'll be prompted to enter:

• Your email address
• Authentication token (get this from the Kusho webapp UI Testing section)

This step is required for CLI authentication and must be completed before proceeding with the recording.

What happens during recording:

1. Browser Opens: The command launches a browser window for interaction.
2. Record Your Flow: Navigate, click, fill forms, and perform any actions you want to test.
3. Close Browser: Close the browser when finished to complete recording.
4. View Script: You'll see the generated Playwright script that captured your actions.
5. Edit Script: The script opens in your terminal editor for review and modifications.
6. Save to Continue: Save the file to proceed to the next step.

Start recording UI interactions:

kusho record

# Record from specific URL
kusho record https://example.com

# Record with device emulation
kusho record --device "iPhone 13" https://example.com

# Record with custom viewport
kusho record --viewport "1280,720" https://example.com

Try the recorder with Playwright's demo site:

kusho demo

After recording, Kusho AI generates comprehensive test scenarios that open in your terminal editor:

What you can do:

• Review Generated Tests: See all test variations created from your recording.
• Edit Existing Tests: Modify selectors, assertions, or test logic as needed.
• Add New Tests: Create additional test scenarios for edge cases.
• Remove Unwanted Tests: Delete any test scenarios you don't need.

Editor Quick Commands:

• Vim: Press i to edit, Esc then :wq to save and exit
• Nano: Edit normally, Ctrl+X then Y then Enter to save
• Vi: Press i to edit, Esc then :wq to save and exit

Save the file to proceed to test generation.

Kusho combines your recording and customized tests to create a comprehensive, executable test script. This process:

• Merges your original recording with customized test scenarios.
• Creates multiple test variations and edge cases.
• Converts everything into optimized Playwright code.
• Generates a comprehensive test script ready for execution.

For advanced users, extend an existing test file with KushoAI variations:

kusho extend path/to/your/test.js

kusho extend latest  # to extend the latest recording

Execute your generated test suite and get comprehensive reports:

# Interactive test selection (recommended)
kusho run

# Run latest test
kusho run latest

# Run specific test
kusho run your-test-name

# Run with additional options
kusho run your-test-name --headed --record

Run Options:

• --headed: Run tests in a visible browser (great for debugging).
• --record: Record videos and screenshots during test execution.
• --device: Test on specific device emulations.

Test Reports: After running tests, you'll get comprehensive reports with:

• Detailed test execution results and pass/fail status.
• Screenshots and videos of test runs (if --record flag used).
• Performance metrics and timing information.
• Error details and debugging information.
• HTML report accessible via browser.

Update your KushoAI credentials anytime:

kusho credentials

Run tests from the extended-tests folder:

# Choose from an interactive list
kusho run

# Run specific test
kusho run login-test

# Run latest test
kusho run latest

# Run with options
kusho run login-test --headed --record

Run a test from the recordings folder:

# Choose from an interactive list
kusho run-recording

# Run specific recording
kusho run-recording login-test

# Run latest recording
kusho run-recording latest

# Run with options
kusho run-recording login-test --headed

• -d, --device <device> - Device to emulate (e.g., "iPhone 13").
• -v, --viewport <size> - Viewport size (e.g., "1280,720").
• -t, --target <lang> - Target language (JavaScript, Python, etc.).
• -o, --output <filename> - Output filename for generated code.
• --no-wait-enhancement - Disable intelligent wait enhancement.

The recorder creates a kusho-tests/ folder structure:

• kusho-tests/recordings/ - Original recorded tests
• kusho-tests/extended-tests/ - AI-enhanced test suites

Generated code is displayed in real-time in the terminal as you perform UI interactions.