e2e: drop the cli browser tool; develop with Playwright directly

Developing against the UI is just running Playwright, which is already in-repo
and is the same thing a scenario() runs, so no bespoke browser command or daemon
is needed. Use `cli up` for an instance and `cli identity` for a logged-in
context, then write and run Playwright. Removes src/devbrowser.ts and the
`cli browser` command.

Author: RhysSullivan

e2e/AGENTS.md

@@ -130,33 +130,6 @@ When handing results to the user, follow the evidence contract in the root
 [AGENTS.md](../AGENTS.md) (direct run links + a live instance + what to try);
 [RUNNING.md](../RUNNING.md) has the current sharing/demo mechanics.
 
-## Driving the app while developing (`cli browser`)
-
-The dev CLI can spin up a real browser pointed at a running instance and already
-signed in, so you can develop against the UI the way a test does. It is the SAME
-browser the `Browser` test surface uses (Chromium, dark mode, 1280x800, the
-identity's cookies), so developing with it and writing a `scenario()` are the
-same primitive: you drive it to figure the flow out, then write the scenario with
-those surfaces. There is no recording or codegen between the two.
-
-```sh
-cd e2e
-bun run cli up cloud                       # a live instance
-bun run cli browser cloud up               # logged-in browser, prints a CDP endpoint + page controls
-bun run cli browser cloud goto /policies   # drive it; each verb prints the page's controls + a screenshot
-bun run cli browser cloud click "Add policy"
-bun run cli browser cloud look             # re-read the page (url, title, controls)
-bun run cli browser cloud down             # stop it
-```
-
-Verbs: `goto <path>`, `click <text>` (matches a link/button by name, else any
-text), `fill <field> <value>`, `type <text>`, `press <key>`, `eval <js>`, `look`.
-`up --headed` shows a real window (for a human to watch); `up --no-org` signs in
-without an active org. The browser is a detached process that persists across
-calls; its state lives in `.dev/<target>.browser.json` (gitignored). Because it
-exposes CDP, you can also point any CDP-speaking tool (Playwright `connectOverCDP`,
-devtools, an agent's own browser automation) at the printed endpoint.
-
 ## Desktop targets (the app on real OSes, filmed)
 
 The packaged desktop app runs as its own targets, each landing in its own

e2e/scripts/cli.ts

@@ -7,15 +7,14 @@
 //   bun scripts/cli.ts api <target> <group.endpoint> [json]
 //   bun scripts/cli.ts mcp <target> tools | call <tool> [json]
 //   bun scripts/cli.ts ledger <target> [workos|autumn]
-//   bun scripts/cli.ts browser <target> up|goto|click|fill|press|eval|look|down
 //   bun scripts/cli.ts logs <target>
 //   bun scripts/cli.ts down <target>
 //
-// Develop against a live instance with the exact machinery the tests use (same
-// boot recipe, same Target/identity/surfaces), then write scenarios with those
-// same surfaces. `up` leaves the instance running until `down` — it IS the
-// handoff demo (AGENTS.md: evidence, not assertions). `--share` makes it
-// reachable over the user's tailnet.
+// Develop against a live instance with the exact machinery the tests use
+// (same boot recipe, same Target/identity/surfaces), then crystallize the
+// journey into a scenario. `up` leaves the instance running until `down` —
+// it IS the handoff demo (AGENTS.md: evidence, not assertions). `--share`
+// makes it reachable over the user's tailnet.
 //
 // Instances are tracked in .dev/<target>.json: a state file marks a
 // DELIBERATE long-lived instance (not a leak). Cloud's WorkOS/Autumn
@@ -444,59 +443,6 @@ const ledger = async (targetName: string, service = "workos") => {
   console.log(JSON.stringify(entries, null, 2));
 };
 
-// --- browser (drive the live app while developing) -------------------------
-// Spin up a real, logged-in browser pointed at the running instance and target
-// it: drive it with the verbs here, or connect anything that speaks CDP to the
-// printed endpoint. The same browser the Browser test surface uses, so this and
-// a scenario() are the same primitive — no recording, no codegen.
-
-const printObservation = (obs: import("../src/devbrowser").Observation) => {
-  console.log(`→ ${obs.url}  ${JSON.stringify(obs.title)}`);
-  if (obs.cdpUrl) console.log(`  cdp: ${obs.cdpUrl}  (point any CDP browser tool here)`);
-  console.log(`  screenshot: ${obs.screenshot}`);
-  if (obs.evalResult !== undefined) console.log(`  eval: ${obs.evalResult}`);
-  if (obs.controls.length > 0) {
-    console.log("controls (role · name):");
-    for (const control of obs.controls.slice(0, 40)) {
-      console.log(`  ${control.role.padEnd(9)} ${control.name}`);
-    }
-    if (obs.controls.length > 40) console.log(`  … ${obs.controls.length - 40} more`);
-  }
-};
-
-const browser = async (raw: ReadonlyArray<string>) => {
-  const target = raw[0];
-  const verb = raw[1];
-  if (!target || !verb) {
-    throw new Error(
-      "usage: browser <target> up [--headed] [--no-org] | goto <path> | click <text> | " +
-        "fill <field> <value> | type <text> | press <key> | eval <js> | look | down",
-    );
-  }
-  const { spinUp, drive, shut } = await import("../src/devbrowser");
-
-  if (verb === "down") {
-    await shut(devDir, target);
-    return console.log(`${target}: browser down`);
-  }
-  if (verb === "up") {
-    const { target: resolved } = await loadTarget(target);
-    const identity = await runEffect<import("../src/target").Identity>(
-      resolved.newIdentity(raw.includes("--no-org") ? { org: false } : undefined),
-    );
-    const obs = await spinUp(devDir, target, resolved.baseUrl, identity, raw.includes("--headed"));
-    return printObservation(obs);
-  }
-  // a drive verb against the already-running browser
-  const obs = await drive(
-    devDir,
-    target,
-    verb,
-    raw.slice(2).filter((a) => !a.startsWith("--")),
-  );
-  printObservation(obs);
-};
-
 // --- lifecycle commands ----------------------------------------------------
 
 const status = () => {
@@ -562,18 +508,9 @@ const HELP = `e2e dev CLI — the scenario primitives, interactive (see e2e/AGEN
   api <target> <group.endpoint> [json]   typed API call as a fresh identity
   mcp <target> tools | call <tool> [json]   MCP session call
   ledger <target> [workos|autumn]   the emulator's request ledger (cloud)
-  browser <target> up [--headed] [--no-org]   spin up a logged-in browser on the
-                             running app and leave it running; prints a CDP
-                             endpoint you can target with any browser tool
-  browser <target> <verb>    drive it: goto <path> | click <text> | fill <field>
-                             <value> | type <text> | press <key> | eval <js> |
-                             look | down. Each prints the page's controls + a shot
   logs <target>              dump the instance's dev-server log
   down <target>              tear down (kills servers, removes tailscale serves)
 
-The browser is the same one the Browser test surface uses, so developing with it
-and writing a scenario() are the same primitive (no recording, no codegen).
-
 Instances live in e2e/.dev/<target>.json — a state file marks a DELIBERATE
 long-lived instance. Use the booted instance for e2e too:
   E2E_SELFHOST_URL=<app url> vitest run --project selfhost <file>`;
@@ -597,8 +534,6 @@ const main = async () => {
       return mcpCall(args[0] ?? "", args[1], args.slice(2));
     case "ledger":
       return ledger(args[0] ?? "", args[1]);
-    case "browser":
-      return browser(rest);
     case "logs":
       return logs(args[0] ?? "");
     case "down":