CLI and terminal browser testing

Browser testing you run from the terminal one binary, laptop to CI

Kane CLI runs browser tests entirely from the command line. Write the objective in plain English, drive real Chrome, and get a verified pass or fail. Interactive TUI for humans, headless and agent mode for CI. Free to install.

npm install -g @testmuai/kane-cli

or read the documentation

Why test browsers from the CLI

CLI browser testing keeps verification where developers already work: the terminal. No GUI recorder, no IDE plugin, no selector scripting. You describe the outcome in plain English and Kane CLI drives a real Chrome browser.

One binary covers three modes. An interactive TUI for humans debugging a flow, headless CLI for shell scripts and cron, and agent mode that streams NDJSON for AI agents and pipelines. Same objective syntax everywhere.

It is built to script. Pass --headless and no display server is needed, gate on POSIX exit codes 0, 1, 2, and 3, and read evidence synced to TestMu AI Test Manager. Run it on your laptop, in CI, or inside a coding agent.

Kane CLI running a terminal browser test and returning a verified result

Built for terminal-native browser testing

Plain-English objectives, real Chrome, and POSIX exit codes that wire straight into CI.

Three terminal modes, one binary

An interactive TUI for debugging a flow at your prompt, a headless CLI for shell scripts and cron, and agent mode that streams NDJSON for AI agents and pipelines. One install, the same objective syntax, nothing extra to learn.

Plain-English objectives, no selectors

Type what should happen at the command line: open a URL, fill a field, assert the page shows a value, store a result. No XPath, no Page Object Models, no framework boilerplate. Kane CLI resolves the path in real Chrome.

POSIX exit codes for CI

Every terminal run ends in a code your pipeline already reads: 0 on pass, 1 on a failed assertion, 2 on an error, 3 on timeout. Branch the build on the number directly, no custom wrapper around the CLI.

Headless with no display server

Add --headless and run browser tests in any terminal, container, or locked-down CI runner without a GUI. Bound each run with --timeout and --max-steps so a hung flow never stalls the command or the pipeline.

Drive a remote browser from the CLI

When the runner has no local Chrome, point the same terminal command at a remote browser with --ws-endpoint or --cdp-endpoint. The objective string is unchanged, ideal for minimal CI images and geographic coverage.

Evidence piped to Test Manager

Each terminal run captures screenshots, a step trace, and a shareable replay link synced to TestMu AI Test Manager, with the URL in the result output. Export any run to native Playwright code when you want a committed script.

Run the same test from laptop to CI to agent

Start in your terminal

Validate on the cloud

Release with confidence

Terminal-native by design

Kane CLI and KaneAI share the same automation engine and dashboard.

Lives inside your shell

The whole test loop stays in the terminal: type an objective, watch the live step tree in the interactive TUI, then pipe the same command into a script. No window to switch to, no recorder to launch, nothing to babysit.

Three doors into one runner

Interactive TUI, headless CLI, and agent mode are the same binary and the same objective string. Debug a flow headed at your prompt, then run it byte-for-byte in CI or hand it to a coding agent with no rewrite.

An exit code is the contract

Kane CLI speaks the language every shell already reads. Pass means 0, a failed assertion means 1, an error means 2, a timeout means 3. Your pipeline branches on the number, and the full trace is one Test Manager link away.

Run a terminal browser test in three steps

Install the binary and sign in

Run npm install -g @testmuai/kane-cli, then authenticate with your TestMu AI username and access key. The one binary gives you the interactive TUI, headless runs, and agent mode from the same prompt.

Type the objective at your prompt

Open the interactive TUI to watch a headed browser and a live step tree, or run kane-cli run with a plain-English objective. Add --headless for containers and --agent to stream NDJSON for a coding agent.

Branch your pipeline on the exit code

Each step is checked in real Chrome, and the process exits 0 for pass, 1 for a failed assertion, 2 for an error, 3 for timeout. Read the stdout JSON or per-line NDJSON and let the code gate the build.

Get Started With Kane CLI

🎉 Launch offer: Bonus credits for the first 3 months on paid plans

Choose the right plan for you

Local test authoring via CLI

Auto-heal & vision

View test cases on UI

Test Manager

Free

/month

200 Credits

Resets in every

30 days

Free tier

Starter

$19

/month

2000 Credits

Launch: 4,000 Credits (+100%)

Bonus for first 3 months

Free tier

Get the technical rundown

Blog

A look at Kane CLI. What we built, what it does, and where it is headed.

Read the blog

Documentation

Everything you need to install, configure, and run Kane CLI in under 2 minutes.

View documentation

GitHub

Browse the source, file issues, and follow the roadmap on GitHub.

Open GitHub

Frequently asked questions

CLI browser testing means driving a real browser and verifying the result entirely from the terminal, with no IDE, no GUI test recorder, and no selector scripting. With Kane CLI you write the objective in plain English, for example "open the login page, sign in, and confirm the dashboard loads," and the command drives a real Chrome browser, checks each step, and returns a verified pass or fail. It runs the same way on your laptop, in a remote SSH session, and inside a CI runner.

Three modes, one binary, the same objective syntax. Interactive TUI mode (kane-cli) gives humans a full terminal interface with a live step tree and a headed browser for debugging. Headless CLI mode (kane-cli run "objective" --headless) prints a single JSON result to stdout for shell scripts and cron jobs. Agent mode (kane-cli run "objective" --agent --headless) streams typed NDJSON, one event per line, for AI coding agents and pipelines that parse output programmatically.

Because the CLI ends every run in a standard POSIX exit code, your CI config gates on it with no custom scripting: 0 means the test passed and the build continues, 1 means an assertion failed, 2 means an error such as an auth failure or a Chrome crash, and 3 means timeout or cancellation. Put your TestMu AI username and access key in CI secrets, run the objective with --headless and --timeout, and branch on the code. No display server is required, so it runs on any runner image.

Yes, that is what agent mode is for. Run the objective with --agent and the CLI streams typed NDJSON, one event per line, ending in a run_end event that carries the full result: status, summary, extracted values, and the Test Manager URL. Install the Kane CLI skill and a coding agent like Cursor, Claude Code, or Codex will assemble the command, run it with --agent --headless, parse the structured output, and fix the failing flow before you see it. Point your agent at testmuai.com/kane-cli/agents.md to start.

Yes. Pass --headless and Kane CLI needs no display server, so it runs in any terminal or container. When the runner has no local Chrome, point it at a remote browser with --ws-endpoint for a WebSocket URL or --cdp-endpoint for a Chrome DevTools Protocol URL. The objective syntax is identical; only the runtime changes. Useful for minimal CI images, geographic testing, and OS coverage you cannot reproduce locally.

Yes, installing the CLI and running it from your terminal costs nothing. Local runs are free to execute; only cloud runs on the TestMu AI grid are billed against your plan. Start on the free tier and run terminal browser tests end to end, no credit card needed.

Teach your agent to test from the terminal

Point your coding agent at the Kane CLI guide and it will install, authenticate, and run browser tests in agent mode, parsing the NDJSON result and fixing failures in a real browser on its own.

Point your agent to: testmuai.com/kane-cli/agents.md