bangonit 0.3.0 → 0.3.2

package/README.md

@@ -1,6 +1,35 @@
 # Bang On It!
 
-Bang On It! bangs on your apps so you don't have to. It's an AI-powered E2E testing tool that launches a real browser, reads your test plan, and executes it autonomously — clicking, typing, navigating, and verifying everything works.
+Bang On It! bangs on your apps so you don't have to.
+
+Bang On It! replaces annoying manual QA and flakey end-to-end tests with a CLI-friendly AI agent that launches a real browser, reads your test plan, and executes it autonomously — clicking, typing, navigating, and verifying everything works.
+
+## Quick Start
+
+```bash
+
+# Run a single test
+npx bangonit run \
+  --plan "Go to localhost:3000, login as test@test.com (password: 12345), \
+          and click all the buttons in the dashboard and make sure they work"
+
+# Run a suite of test plans
+npx bangonit run testplans/*.md --concurrency 3
+
+# Record a video of your test run in the recordings/ directory
+npx bangonit run testplans/*.md --record
+
+# Initialize your project with full CI integration and S3 video recording storage
+npx bangonit init
+```
+
+## Where it fits
+
+1. **Local development** — Replace the "click around and see if it works" step. Write a test plan once, run it every time you change something. Faster feedback than manual testing, and you don't forget to check the edge cases.
+
+2. **CI, instead of unit tests** — Run your test plans on every PR. Your actual app, in a real browser, doing real things. If the tests pass, it works. If they don't, it doesn't. That's the only thing that matters.
+
+3. **Staging gate before prod** — Point Bang On It! at your staging environment and run the full suite before promoting to production. Catch regressions where they matter: in an environment that looks like the real thing.
 
 ## Why This Matters
 
@@ -20,13 +49,84 @@ Bang On It! removes that bottleneck. You describe what to test in plain English.
 
 The loop is simple: agent writes code, agent tests code, human reviews the test plans. Bang On It! is the testing layer for that loop.
 
-### Where it fits
+## Bang On It vs...
 
-1. **Local development** — Replace the "click around and see if it works" step. Write a test plan once, run it every time you change something. Faster feedback than manual testing, and you don't forget to check the edge cases.
+### vs Claude Code with computer use / browser automation MCP
 
-2. **CI, instead of unit tests** — Run your test plans on every PR. Your actual app, in a real browser, doing real things. If the tests pass, it works. If they don't, it doesn't. That's the only thing that matters.
+Claude Code can drive a browser via Anthropic's computer use or third-party browser MCP servers. The approach is similar in spirit — an AI agent interacting with a real browser using natural language instructions. But Claude Code is a general-purpose coding agent, not a testing tool. It can _do_ browser testing, the same way Playwright can, but it wasn't built for it.
 
-3. **Staging gate before prod** — Point Bang On It! at your staging environment and run the full suite before promoting to production. Catch regressions where they matter: in an environment that looks like the real thing.
+**Key technical differences:**
+
+- **Purpose-built browser tooling.** Claude Code's computer use takes full-screen screenshots and uses pixel coordinates for every interaction — it's controlling a generic desktop, not a browser specifically. Bang On It! uses the browser's accessibility tree for element identification (fast, text-based, no image processing needed) and only falls back to screenshots when visual verification is required (charts, colors, layout). This hybrid approach is dramatically faster — a text snapshot is returned in milliseconds vs. capturing, transmitting, and processing a full screenshot on every single action.
+- **Batched actions.** Claude Code executes one browser action per tool call — click, wait for response, screenshot, next action. Bang On It! batches multiple actions into a single tool call (navigate + click + type + observe) and only captures page state at the end. Fewer round-trips to the model means faster test execution.
+- **Parallel test execution.** Claude Code runs one browser session at a time. Bang On It! runs N agents in parallel (`--concurrency N`), each with its own isolated browser partition — separate cookies, localStorage, and session state. A 10-test suite runs in the time of 2 tests, not 10.
+- **Session recordings.** Bang On It! records every test run as a self-contained HTML replay with a multi-agent timeline view — video clips, console logs, and tool invocations all synced together. Share a link, not a screenshot. Claude Code has no recording capability.
+- **Real-time UI.** Bang On It! includes a live observation UI where you can watch agents execute in real time — see the cursor move, watch pages load, monitor progress across parallel agents. Claude Code outputs text to a terminal.
+- **CI-native.** Bang On It! generates GitHub Actions workflows out of the box, handles headless execution, uploads results as artifacts, and optionally pushes recordings to S3. Wiring Claude Code into CI for browser testing is a DIY project.
+
+Claude Code is an excellent coding agent. But for the specific job of testing a web app in a browser — fast, in parallel, with recordings and a UI — Bang On It! is purpose-built for exactly that.
+
+### vs Selenium / Playwright
+
+Selenium and Playwright are powerful browser automation libraries — but they're _libraries_, not testing tools. You write code: selectors, page objects, explicit waits, retry logic, assertion helpers. When the UI changes, your selectors break and you're back in the maintenance treadmill.
+
+**Key technical differences:**
+
+- **No selectors.** Bang On It! uses the browser's accessibility tree to identify elements, the same way a screen reader does. There are no CSS selectors or XPath expressions to break when you rename a class or restructure your markup.
+- **No page objects.** The AI agent interprets the page semantically on every interaction. There's no abstraction layer to keep in sync with your UI.
+- **No explicit waits.** Bang On It! tracks real network activity via Chrome DevTools Protocol events. It knows when the page is idle — no `waitForSelector`, no `sleep(2000)`, no polling.
+- **No test code at all.** Test plans are plain English Markdown files. A non-engineer can write and review them.
+- **Self-correcting execution.** If a button moves, changes label, or is behind a modal, the agent adapts. A Playwright script just fails.
+
+Playwright and Selenium dispatch actions programmatically — they call `element.click()` directly in the DOM, bypassing the browser's input pipeline entirely. Bang On It! drives the browser through real OS-level input events via Chrome DevTools Protocol. Mouse movements follow eased curves with realistic interpolation. Keystrokes fire individual `keyDown`, `char`, and `keyUp` events with randomized inter-key delays (30–100ms). This matters because many modern apps have hover states, drag interactions, debounced inputs, and event listeners that only trigger on real input events — not synthetic DOM calls.
+
+Playwright and Selenium are great for building custom browser automation. But if the goal is _testing_, you're writing and maintaining a lot of infrastructure that Bang On It! eliminates entirely.
+
+### vs Cypress
+
+Cypress improved DX over Selenium with automatic waiting, time-travel debugging, and a built-in test runner. But it's still selector-based test code, and it runs in a synthetic environment — Cypress injects itself into the browser via an iframe, which means it can't test multi-tab flows, OAuth redirects, or cross-origin interactions natively.
+
+**Key technical differences:**
+
+- **Real browser, not an iframe.** Bang On It! launches actual Chromium via Electron. Multi-tab, cross-origin, OAuth popups, file downloads — all work naturally because it's a real browser session.
+- **No selector coupling.** Cypress tests break when `data-cy` attributes are removed or DOM structure changes. Bang On It! reads the page like a user does — through its semantic structure, not its implementation details.
+- **Parallel isolation.** Each Bang On It! agent runs in its own browser partition with fully isolated cookies, localStorage, and session state. Cypress parallelization requires Dashboard (paid) and splits at the file level.
+- **Minutes to write vs hours.** A Cypress test for a checkout flow is 50-100 lines of code. The equivalent Bang On It! test plan is 5 lines of English.
+- **Realistic input simulation.** Cypress uses `cy.click()` and `cy.type()` which dispatch synthetic jQuery-style events. Bang On It! sends real input events through Chrome DevTools Protocol — eased mouse curves, per-character keystroke events with natural timing — catching bugs that only surface with real user interaction patterns.
+
+### vs QA Wolf / Testim / Mabl (AI-assisted record-and-replay)
+
+These tools use AI to _help_ you create and maintain traditional selector-based tests — typically through record-and-replay with smart locators that auto-heal when elements move. They reduce maintenance, but the underlying model is still the same: a recorded script of UI interactions replayed deterministically.
+
+**Key technical differences:**
+
+- **Generative, not recorded.** Bang On It! doesn't record and replay a fixed script. The AI agent reads your test plan and _decides_ how to execute it on each run. If the UI changes, the agent figures out the new path — it doesn't try to heal a stale recording.
+- **No vendor lock-in.** Test plans are Markdown files in your repo. There's no proprietary test format, no cloud dashboard required, no per-seat pricing for test authoring. You own your tests.
+- **Runs locally and in CI.** These tools are typically cloud-hosted services. Bang On It! runs on your machine or in your own CI pipeline. Your app never leaves your network.
+- **Understands intent, not just actions.** A recorded test replays "click the third button in the sidebar." Bang On It! executes "verify the user can navigate to settings" — if the settings link moves from the sidebar to a top nav, the test still passes.
+
+### vs Manual QA
+
+Manual QA catches things automated tests miss — but it doesn't scale, it's slow, and humans get tired. The same tester clicking through the same flow for the 50th time will miss things.
+
+Bang On It! runs the same tests with the same thoroughness every time, in parallel, in seconds. Write the test plan once, run it on every PR. Keep manual QA for exploratory testing where human judgment matters — let Bang On It! handle the repetitive verification.
+
+### Performance and realistic simulation
+
+Two technical advantages that cut across all comparisons:
+
+**Batched actions with parallel agents.** Bang On It! executes multiple actions per tool call in a single batch — navigate, click, type, and observe in one round-trip instead of one-action-at-a-time. Combined with `--concurrency N` to run multiple agents in parallel (each with its own isolated browser session), a full test suite finishes in a fraction of the wall-clock time. A 10-test suite at `--concurrency 5` runs in roughly the time of 2 tests, not 10.
+
+**Real input events, not DOM hacks.** Most testing tools dispatch events synthetically — calling `element.click()` or `element.value = "text"` directly in the DOM. This skips the browser's actual input pipeline, which means hover states don't trigger, drag-and-drop doesn't work, debounced inputs behave differently, and event listeners attached to `mousedown`/`mousemove`/`mouseup` never fire.
+
+Bang On It! drives the browser through CDP `Input.dispatchMouseEvent` and Electron `sendInputEvent`:
+
+- **Mouse movement** follows eased Bézier-style curves with distance-proportional speed, triggering every `mousemove`, `mouseenter`, and `mouseover` handler along the path.
+- **Clicks** fire the full `mousedown` → `mouseup` → `click` sequence at real coordinates, with proper `clickCount` for double-clicks.
+- **Typing** sends individual `keyDown` → `char` → `keyUp` events per character with randomized 30–100ms delays between keystrokes, triggering `input`, `change`, and `keypress` handlers exactly as a human typist would.
+- **Scrolling** dispatches real `mouseWheel` events instead of calling `scrollTo`.
+
+This catches an entire class of bugs that synthetic-event tools miss: broken drag-and-drop, hover menus that don't open, inputs that don't validate on blur, custom components that listen for native events.
 
 ## Install
 
@@ -36,7 +136,7 @@ npm install -g bangonit
 
 The package provides three aliases: `bangonit`, `bang-on-it`, and `boi`.
 
-## Quick Start
+## Getting started
 
 ```bash
 # Launch the interactive UI
@@ -47,20 +147,20 @@ boi run testplans/checkout-flow.md
 
 # Run an inline test
 boi run --plan "Go to my-app.com, sign up with a test account, and verify the dashboard loads"
-
-# Auto-generate tests from your git changes
-boi run --auto
 ```
 
-### With a config file
+### Set up a project
 
 ```bash
-# Create a .bangonit/config.toml config file
+# Creates config, test plan directories, and optionally GitHub Actions CI
 boi init
 
-# Run all test plans in the configured directory
+# Run all test plans
 boi run
 
+# Run just the smoke tests
+boi run testplans/smoke/
+
 # Filter test plans by name
 boi run -t checkout
 ```
@@ -106,7 +206,25 @@ No selectors. No page objects. No flaky waits. Just describe what to test and le
 
 ## Test Plans
 
-Test plans are Markdown files. Put them in your `testplans/` directory (or wherever `.bangonit/config.toml` points).
+Test plans are Markdown files. `boi init` creates a recommended two-tier structure:
+
+```
+testplans/
+  smoke/          # is the app alive? — run on every push/PR
+    homepage.md
+    login.md
+  acceptance/     # does the app do what it should? — core user journeys
+    checkout.md
+    onboarding.md
+  regression/     # did we break something? — bug fixes, edge cases
+    issue-123.md
+```
+
+- **Smoke** tests should be quick and focused — verify critical paths still work.
+- **Acceptance** tests cover core user journeys and happy paths.
+- **Regression** tests lock down bug fixes and edge cases so they don't recur.
+
+Smoke tests run on every commit. The daily full run discovers everything recursively (smoke + acceptance + regression). Run `boi run testplans/smoke/` to run just the smoke tests.
 
 ```markdown
 ---
@@ -114,17 +232,15 @@ name: Add Todos
 retries: 1
 ---
 
-## Setup
-Navigate to http://localhost:3000
-
-## Test Steps
-1. Verify the page loads with a heading and input field
-2. Type "Buy groceries" and press Enter
-3. Verify the todo appears in the list
-4. Verify the footer shows "1 item left"
+## Steps
+1. Navigate to http://localhost:3000
+2. Verify the page loads with a heading and input field
+3. Type "Buy groceries" and press Enter
+4. Verify the todo appears in the list
+5. Verify the footer shows "1 item left"
 ```
 
-The `---` frontmatter is optional. `name` sets the display name, `retries` enables auto-retry on failure.
+The `---` frontmatter is optional. `name` sets the display name, `retries` enables auto-retry on failure. You can also set retries for all tests via `--retries N` on the CLI (frontmatter takes precedence).
 
 ## Filtering Tests
 
@@ -142,6 +258,13 @@ boi run --filter checkout
 
 You can customize the AI agent's behavior per-project by creating a `.bangonit/system_prompt.md` file in your project root. This content is prepended to the agent's system prompt for all test runs in that directory.
 
+## Claude Code Skills
+
+`boi init` installs two [Claude Code](https://claude.com/claude-code) skills into your project:
+
+- **`/test`** — Run tests locally. Pass file paths, directories, or a filter (e.g. `/test testplans/smoke/`, `/test -t login`).
+- **`/create-test`** — Generate a new test plan from a description (e.g. `/create-test user can reset their password`). Reads your codebase to write accurate steps and places the file in the right directory.
+
 ## Session Recordings
 
 Record test runs with `--record`. Each recording produces a self-contained HTML replay viewer. Configure where they're saved with `recordings_dir` in your config, and optionally upload to S3 via the `[s3]` config section.
@@ -153,16 +276,16 @@ Usage: boi <command> [options]
 
 Commands:
   run [files...] [options]   Run test plans (or launch interactive UI)
-  init                       Create a .bangonit/config.toml config file
-  init-ci                    Generate a GitHub Actions workflow
+  init                       Set up config, test plans, and optionally CI
 
 Run options:
   -t, --filter <text>        Filter test plans by name substring
   --config <path>            Path to config file (default: .bangonit/config.toml)
   --plan <text>              Inline test plan (instead of file)
-  --auto                     Auto-generate test plan from git state
+
   --prompt <text>            Additional instructions appended to test plan
   --record                   Record session replay
+  --retries <n>              Retry failed tests N times
   --headless                 Run without showing the browser window
   --exit                     Exit immediately after tests complete
   --json                     Stream NDJSON events to stdout
@@ -177,24 +300,12 @@ In CI environments, `--headless` and `--exit` default to `true` automatically.
 
 ## CI Usage
 
-Generate a GitHub Actions workflow:
-
-```bash
-boi init-ci
-```
-
-Or run manually in CI:
-
-```bash
-# JSON output for parsing
-boi run --json
+`boi init` optionally generates two GitHub Actions workflows:
 
-# Record for artifacts
-boi run --record
+- **Smoke tests** (`bangonit-smoke.yml`) — runs `testplans/smoke/` on every push and PR
+- **Full tests** (`bangonit-full.yml`) — runs all test plans daily at 6pm local time
 
-# With timeout
-boi run --timeout 120
-```
+In CI, `--headless` and `--exit` are enabled automatically.
 
 ## Multiple Tests
 

package/app/desktopapp/dist/main/index.js

@@ -43,154 +43,16 @@ const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
 const ipc_1 = require("./ipc");
 const tabs_1 = require("./tabs");
+const args_1 = require("../shared/args");
 let mainWindow = null;
+// --- Parse args from env (set by CLI) ---
 function parseArgs() {
-    const args = process.argv.slice(2).filter((a) => !a.startsWith("--remote-debugging-port"));
-    const result = {
-        testPlanFiles: [],
-        headless: false,
-        exit: false,
-        json: false,
-        console: false,
-        record: false,
-        auto: false,
-        output: null,
-        plan: null,
-        prompt: null,
-        concurrency: 1,
-        timeout: 0,
-        cwd: process.cwd(),
-    };
-    if (args.includes("--help") || args.includes("-h")) {
-        console.log(`Usage: boi run [test-plan-files...] [options]
-
-Options:
-  --plan <text>         Inline test plan (instead of file)
-  --auto                Auto-generate test plan from git state
-  --prompt <text>       Additional instructions appended to test plan
-  --record              Record session replay to recordings/ directory
-  --headless            Run without showing the browser window
-  --exit                Exit immediately after tests complete (for CI)
-  --json                Stream NDJSON events to stdout
-  --console             Forward browser console logs to stdout
-  --output <file>       Write JSON results to file
-  --concurrency <n>     Number of parallel agents (default: 1)
-  --timeout <seconds>   Test timeout in seconds (0 = none)
-  --cwd <dir>           Working directory (default: current)
-  --help                Show this help message`);
-        process.exit(0);
-    }
-    let i = 0;
-    // Skip "run" subcommand if present
-    if (args[i] === "run")
-        i++;
-    while (i < args.length) {
-        const arg = args[i];
-        if (arg === "--headless") {
-            result.headless = true;
-        }
-        else if (arg === "--exit") {
-            result.exit = true;
-        }
-        else if (arg === "--json") {
-            result.json = true;
-        }
-        else if (arg === "--console") {
-            result.console = true;
-        }
-        else if (arg === "--record") {
-            result.record = true;
-        }
-        else if (arg === "--auto") {
-            result.auto = true;
-        }
-        else if (arg === "--output" && i + 1 < args.length) {
-            result.output = args[++i];
-        }
-        else if (arg === "--plan" && i + 1 < args.length) {
-            result.plan = args[++i];
-        }
-        else if (arg === "--prompt" && i + 1 < args.length) {
-            result.prompt = args[++i];
-        }
-        else if (arg === "--concurrency" && i + 1 < args.length) {
-            result.concurrency = Math.max(1, parseInt(args[++i], 10) || 1);
-        }
-        else if (arg === "--timeout" && i + 1 < args.length) {
-            result.timeout = Math.max(0, parseInt(args[++i], 10) || 0);
-        }
-        else if (arg === "--cwd" && i + 1 < args.length) {
-            result.cwd = args[++i];
-        }
-        else if (!arg.startsWith("-")) {
-            result.testPlanFiles.push(arg);
-        }
-        i++;
+    const raw = process.env[args_1.ELECTRON_ARGS_ENV];
+    if (!raw) {
+        console.error("Error: BANGONIT_ARGS environment variable not set. Run via the boi CLI.");
+        process.exit(1);
     }
-    return result;
-}
-// --- Auto-generate test plan from git state ---
-async function generateTestPlan(cwd) {
-    const { execSync } = require("child_process");
-    const exec = (cmd) => {
-        try {
-            return execSync(cmd, { cwd, encoding: "utf-8", timeout: 10000 }).trim();
-        }
-        catch {
-            return "";
-        }
-    };
-    const diff = exec("git diff") + "\n" + exec("git diff --cached");
-    const status = exec("git status --short");
-    if (diff.trim() || status.trim()) {
-        return `## Auto-generated test plan from uncommitted changes
-
-Analyze the following git changes and generate a comprehensive test plan. Then execute each test step.
-
-### Git Status
-\`\`\`
-${status}
-\`\`\`
-
-### Git Diff
-\`\`\`
-${diff.slice(0, 8000)}
-\`\`\`
-
-Generate test steps that verify the changes work correctly, then execute them.`;
-    }
-    const logDiff = exec("git log master..HEAD --oneline");
-    const codeDiff = exec("git diff master...HEAD");
-    if (logDiff || codeDiff) {
-        return `## Auto-generated test plan from branch divergence
-
-Analyze the following commits diverging from master and generate a comprehensive test plan. Then execute each test step.
-
-### Commits
-\`\`\`
-${logDiff}
-\`\`\`
-
-### Diff from master
-\`\`\`
-${codeDiff.slice(0, 8000)}
-\`\`\`
-
-Generate test steps that verify these changes work correctly, then execute them.`;
-    }
-    const lastCommit = exec("git log -1 --format='%H %s'");
-    const lastDiff = exec("git show HEAD --stat");
-    return `## Auto-generated test plan from latest commit
-
-No test plan provided and no changes unmerged to master. Generating test plan from latest commit.
-
-### Latest Commit
-\`\`\`
-${lastCommit}
-${lastDiff}
-\`\`\`
-
-Generate test steps that verify this commit works correctly, then execute them.`;
+    return args_1.electronArgsSchema.parse(JSON.parse(raw));
 }
 const cliArgs = parseArgs();
 function parseFrontmatter(content) {
@@ -321,7 +183,8 @@ async function createWindow() {
     // Create recordings directory if --record
     if (cliArgs.record) {
         const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-        const recordDir = path.join(cliArgs.cwd, "recordings", timestamp);
+        const baseDir = cliArgs.recordingsDir || path.join(cliArgs.cwd, "recordings");
+        const recordDir = path.join(baseDir, timestamp);
         fs.mkdirSync(recordDir, { recursive: true });
         (0, ipc_1.setRunDir)(recordDir);
         if (!cliArgs.json)
@@ -361,26 +224,12 @@ async function createWindow() {
                     agentIndex: i,
                     testPlan: parsed[i].body,
                     name: parsed[i].frontmatter.name || names[i],
-                    retries: parsed[i].frontmatter.retries || 0,
+                    retries: parsed[i].frontmatter.retries ?? cliArgs.retries,
                     extraPrompt: cliArgs.prompt || undefined,
                     record: cliArgs.record || undefined,
                 });
             }
         }
-        else if (cliArgs.auto) {
-            // Auto-generate from git state
-            const generated = await generateTestPlan(cliArgs.cwd);
-            const fullPlan = cliArgs.prompt
-                ? `${generated}\n\n## Additional Instructions\n${cliArgs.prompt}`
-                : generated;
-            expectedResults = 1;
-            mainWindow.webContents.send("test-plan", {
-                agentIndex: 0,
-                testPlan: fullPlan,
-                name: "auto-generated",
-                record: cliArgs.record || undefined,
-            });
-        }
         // No test plans provided — interactive UI will show the prompt screen
         // Start timeout if specified
         if (cliArgs.timeout > 0) {

package/app/desktopapp/dist/main/ipc.js

@@ -206,26 +206,6 @@ function registerIpcHandlers() {
         store.delete(`agentSessions.${agentId}`);
         (0, tabs_1.destroyContext)(agentId);
     });
-    // --- Bash (per-agent) ---
-    electron_1.ipcMain.handle("bash-exec", async (_, { agentId, command }) => {
-        const ctx = (0, tabs_1.getOrCreateContext)(agentId);
-        if (!ctx.bashInstance) {
-            const { Bash, OverlayFs } = await Promise.resolve().then(() => __importStar(require("just-bash")));
-            const overlay = new OverlayFs({ root: bangerCwd });
-            const cwd = overlay.getMountPoint();
-            ctx.bashInstance = new Bash({ fs: overlay, cwd });
-            try {
-                ctx.bashInstance.fs.mkdirSync("/home/user/downloads");
-            }
-            catch { }
-            ctx.bashFs = ctx.bashInstance.fs;
-            ctx.bashCwd = cwd;
-        }
-        const result = await ctx.bashInstance.exec(command, { cwd: ctx.bashCwd });
-        return [result.stdout, result.stderr ? `stderr: ${result.stderr}` : "", `exit code: ${result.exitCode}`]
-            .filter(Boolean)
-            .join("\n");
-    });
     electron_1.ipcMain.handle("clear-partition", async (_, agentId) => {
         const partitionName = `persist:agent-${agentId}`;
         const ses = electron_1.session.fromPartition(partitionName);

package/app/desktopapp/dist/main/preload.js

@@ -14,8 +14,6 @@ contextBridge.exposeInMainWorld("bangonit", {
     getAgentSession: (agentId) => ipcRenderer.invoke("get-agent-session", agentId),
     setAgentSession: (agentId, session) => ipcRenderer.invoke("set-agent-session", { agentId, session }),
     deleteAgentSession: (agentId) => ipcRenderer.invoke("delete-agent-session", agentId),
-    // Bash (per-agent)
-    bashExec: (agentId, command) => ipcRenderer.invoke("bash-exec", { agentId, command }),
     // --- Low-level browser primitives ---
     // CDP: send a raw CDP command to the active tab
     cdpSend: (agentId, method, params) => ipcRenderer.invoke("cdp-send", { agentId, method, params }),

package/app/desktopapp/dist/main/tabs.js

@@ -53,12 +53,9 @@ function getOrCreateContext(agentId) {
     const ctx = {
         tabs: new Map(),
         activeTabId: null,
-        bashInstance: null,
-        bashCwd: null,
         nextPopupId: 10000,
         downloadsDir: null,
         downloadSessionsSetup: new WeakSet(),
-        bashFs: null,
     };
     agentContexts.set(agentId, ctx);
     return ctx;
@@ -126,13 +123,6 @@ function setupDownloads(ctx, wc) {
         item.on("done", (_, state) => {
             entry.bytes = item.getReceivedBytes();
             entry.state = state === "completed" ? "completed" : "failed";
-            if (state === "completed" && ctx.bashFs) {
-                try {
-                    const data = fs.readFileSync(savePath);
-                    ctx.bashFs.writeFileSync(`/home/user/downloads/${filename}`, data);
-                }
-                catch { }
-            }
         });
     });
 }

package/app/desktopapp/dist/shared/args.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ELECTRON_ARGS_ENV = exports.electronArgsSchema = void 0;
+const zod_1 = require("zod");
+exports.electronArgsSchema = zod_1.z.object({
+    testPlanFiles: zod_1.z.array(zod_1.z.string()),
+    headless: zod_1.z.boolean(),
+    exit: zod_1.z.boolean(),
+    json: zod_1.z.boolean(),
+    console: zod_1.z.boolean(),
+    record: zod_1.z.boolean(),
+    retries: zod_1.z.number(),
+    output: zod_1.z.string().nullable(),
+    plan: zod_1.z.string().nullable(),
+    prompt: zod_1.z.string().nullable(),
+    concurrency: zod_1.z.number(),
+    timeout: zod_1.z.number(),
+    cwd: zod_1.z.string(),
+    recordingsDir: zod_1.z.string().nullable(),
+});
+exports.ELECTRON_ARGS_ENV = "BANGONIT_ARGS";

package/app/desktopapp/package.json

@@ -13,7 +13,7 @@
   },
   "dependencies": {
     "electron-store": "^8.1.0",
-    "just-bash": "^2.13.1"
+    "zod": "^3.25.0"
   },
   "devDependencies": {
     "@types/node": "^20.0.0",