bangonit 0.5.7 → 0.5.9

package/bin/src/cli/bangonit.js

@@ -1,1035 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-// Bang On It! CLI — starts the webapp and Electron app, forwards all args.
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const child_process_1 = require("child_process");
-const path = __importStar(require("path"));
-const fs = __importStar(require("fs"));
-const net = __importStar(require("net"));
-const readline = __importStar(require("readline"));
-const TOML = __importStar(require("@iarna/toml"));
-const Minio = __importStar(require("minio"));
-const yargs_1 = __importDefault(require("yargs"));
-const helpers_1 = require("yargs/helpers");
-const is_ci_1 = __importDefault(require("is-ci"));
-const dotenv = __importStar(require("dotenv"));
-const args_1 = require("../../app/desktopapp/src/shared/args");
-const ROOT = path.resolve(__dirname, "..", "..", "..");
-const WEBAPP_DIR = path.join(ROOT, "app", "webapp");
-const DESKTOP_DIR = path.join(ROOT, "app", "desktopapp");
-const LOGS_DIR = path.join(process.cwd(), "logs");
-// Colors
-const c = {
-    reset: "\x1b[0m",
-    bold: "\x1b[1m",
-    dim: "\x1b[2m",
-    red: "\x1b[31m",
-    green: "\x1b[32m",
-    yellow: "\x1b[33m",
-    blue: "\x1b[34m",
-    magenta: "\x1b[35m",
-    cyan: "\x1b[36m",
-};
-function die(msg) {
-    console.error(`${c.red}${msg}${c.reset}`);
-    process.exit(1);
-}
-function getFreePort() {
-    return new Promise((resolve, reject) => {
-        const server = net.createServer();
-        server.once("error", reject);
-        server.listen(0, () => {
-            const port = server.address().port;
-            server.close(() => resolve(port));
-        });
-    });
-}
-function isPortInUse(port) {
-    return new Promise((resolve) => {
-        const client = net.connect({ port, host: "127.0.0.1" }, () => {
-            client.destroy();
-            resolve(true);
-        });
-        client.on("error", () => resolve(false));
-    });
-}
-async function waitForPort(port, timeoutMs = 30000) {
-    const start = Date.now();
-    while (Date.now() - start < timeoutMs) {
-        const inUse = await isPortInUse(port);
-        if (inUse)
-            return;
-        await new Promise((r) => setTimeout(r, 500));
-    }
-    die(`Timed out waiting for port ${port}`);
-}
-function loadEnv() {
-    dotenv.config({ quiet: true });
-}
-// Interpolate ${ENV_VAR} references in string values throughout an object
-function interpolateEnv(obj) {
-    if (typeof obj === "string") {
-        return obj.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_, name) => {
-            return process.env[name] || "";
-        });
-    }
-    if (Array.isArray(obj))
-        return obj.map(interpolateEnv);
-    if (obj && typeof obj === "object") {
-        const result = {};
-        for (const [k, v] of Object.entries(obj)) {
-            result[k] = interpolateEnv(v);
-        }
-        return result;
-    }
-    return obj;
-}
-// Walk up from cwd to find .bangonit/ directory, stopping at .git or filesystem root
-function findProjectDir() {
-    let dir = process.cwd();
-    while (true) {
-        if (fs.existsSync(path.join(dir, ".bangonit")))
-            return dir;
-        if (fs.existsSync(path.join(dir, ".git")))
-            return null;
-        const parent = path.dirname(dir);
-        if (parent === dir)
-            return null; // filesystem root
-        dir = parent;
-    }
-}
-function loadConfig(configPath) {
-    if (configPath) {
-        if (!fs.existsSync(configPath))
-            die(`Config file not found: ${configPath}`);
-        try {
-            const raw = TOML.parse(fs.readFileSync(configPath, "utf-8"));
-            return interpolateEnv(raw);
-        }
-        catch (err) {
-            die(`Error reading config ${configPath}: ${err.message}`);
-        }
-    }
-    const projectDir = findProjectDir();
-    if (!projectDir)
-        return {};
-    const filePath = path.join(projectDir, ".bangonit", "config.toml");
-    if (!fs.existsSync(filePath))
-        return {};
-    try {
-        const raw = TOML.parse(fs.readFileSync(filePath, "utf-8"));
-        return interpolateEnv(raw);
-    }
-    catch (err) {
-        die(`Error reading config ${filePath}: ${err.message}`);
-    }
-}
-// --- Test plan discovery ---
-function findTestPlans(dir, filter) {
-    const results = [];
-    if (!fs.existsSync(dir))
-        return results;
-    function walk(d) {
-        for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
-            const full = path.join(d, entry.name);
-            if (entry.isDirectory()) {
-                walk(full);
-            }
-            else if (entry.name.endsWith(".md")) {
-                results.push(full);
-            }
-        }
-    }
-    walk(dir);
-    if (filter) {
-        const lower = filter.toLowerCase();
-        return results.filter((f) => path.basename(f).toLowerCase().includes(lower));
-    }
-    return results;
-}
-function createPrompter() {
-    let closed = false;
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    rl.on("close", () => {
-        closed = true;
-    });
-    return {
-        ask(question, defaultVal) {
-            if (closed)
-                return Promise.resolve(defaultVal || "");
-            return new Promise((resolve) => {
-                const defStr = defaultVal ? `${c.dim} [${defaultVal}]${c.reset}` : "";
-                rl.question(`  ${c.cyan}?${c.reset} ${question}${defStr} `, (answer) => {
-                    resolve(answer.trim() || defaultVal || "");
-                });
-            });
-        },
-        askChoice(question, choices, defaultVal) {
-            if (closed)
-                return Promise.resolve(defaultVal);
-            const choiceStr = choices.map((ch) => (ch === defaultVal ? `${c.bold}${ch}${c.reset}${c.dim}` : ch)).join("/");
-            return new Promise((resolve) => {
-                rl.question(`  ${c.cyan}?${c.reset} ${question} ${c.dim}(${choiceStr})${c.reset} `, (answer) => {
-                    const val = answer.trim().toLowerCase() || defaultVal;
-                    resolve(choices.includes(val) ? val : defaultVal);
-                });
-            });
-        },
-        close() {
-            rl.close();
-        },
-    };
-}
-// --- init command ---
-async function initProject() {
-    const p = createPrompter();
-    console.log(`\n  ${c.bold}${c.magenta}Bang On It! init${c.reset}\n`);
-    const testplans = await p.ask("Test plans directory", "testplans");
-    const recordingsDir = await p.ask("Recordings directory", "recordings");
-    // --- Config file ---
-    const toml = `# Bang On It! configuration
-# Docs: https://bangonit.dev/docs/config
-
-testplans = "${testplans}"
-recordings_dir = "${recordingsDir}"
-
-# EDIT: Uncomment and set your Anthropic API key, or set ANTHROPIC_API_KEY env var
-# anthropic_api_key = "sk-ant-..."
-`;
-    const bangDir = path.join(process.cwd(), ".bangonit");
-    fs.mkdirSync(bangDir, { recursive: true });
-    const configOutPath = path.join(bangDir, "config.toml");
-    fs.writeFileSync(configOutPath, toml);
-    console.log(`\n  ${c.green}Created${c.reset} .bangonit/config.toml`);
-    // --- System prompt script ---
-    const systemPromptPath = path.join(bangDir, "system_prompt.sh");
-    if (!fs.existsSync(systemPromptPath)) {
-        fs.writeFileSync(systemPromptPath, `#!/bin/bash
-# This script is executed before each test run.
-# Its stdout becomes the project-level system prompt.
-# Environment variables are available for interpolation.
-
-# Example:
-# echo "The app is running on http://localhost:\${DEV_SERVER_PORT}"
-`);
-        fs.chmodSync(systemPromptPath, 0o755);
-        console.log(`  ${c.green}Created${c.reset} .bangonit/system_prompt.sh`);
-    }
-    // --- Test plan directories ---
-    const testplanBase = path.join(process.cwd(), testplans);
-    const dirs = ["smoke", "acceptance", "regression"];
-    for (const dir of dirs) {
-        const dirPath = path.join(testplanBase, dir);
-        fs.mkdirSync(dirPath, { recursive: true });
-        const gitkeep = path.join(dirPath, ".gitkeep");
-        if (!fs.existsSync(gitkeep))
-            fs.writeFileSync(gitkeep, "");
-        console.log(`  ${c.green}Created${c.reset} ${testplans}/${dir}/`);
-    }
-    // --- Claude Code skills ---
-    const claudeSkillsDir = path.join(process.cwd(), ".claude", "skills");
-    const testSkillDir = path.join(claudeSkillsDir, "boi-test");
-    fs.mkdirSync(testSkillDir, { recursive: true });
-    fs.writeFileSync(path.join(testSkillDir, "SKILL.md"), `---
-name: boi-test
-description: Run Bang On It! E2E tests locally. Pass test plan files or a filter as $ARGUMENTS (e.g. "testplans/smoke/" or "-t login"). With no arguments, runs all test plans.
-tools: Bash, Read
----
-
-# Run E2E Tests
-
-Run Bang On It! end-to-end tests locally.
-
-**Arguments:** $ARGUMENTS
-
-## Instructions
-
-1. If $ARGUMENTS is empty, run all test plans:
-   \`\`\`bash
-   boi run --record
-   \`\`\`
-
-2. If $ARGUMENTS contains file paths or directories, run those:
-   \`\`\`bash
-   boi run $ARGUMENTS --record
-   \`\`\`
-
-3. If $ARGUMENTS contains a filter (e.g. "login", "checkout"), run with filter:
-   \`\`\`bash
-   boi run -t $ARGUMENTS --record
-   \`\`\`
-
-4. Wait for tests to complete. Report results and recording paths.
-
-5. If tests fail, read the test plan file and the output to diagnose the failure. Suggest whether the test plan needs updating or there's a real bug.
-`);
-    console.log(`  ${c.green}Created${c.reset} .claude/skills/boi-test/SKILL.md`);
-    const createTestSkillDir = path.join(claudeSkillsDir, "boi-create-test");
-    fs.mkdirSync(createTestSkillDir, { recursive: true });
-    fs.writeFileSync(path.join(createTestSkillDir, "SKILL.md"), `---
-name: boi-create-test
-description: Create new Bang On It! test plan(s). Pass a description of what to test as $ARGUMENTS, or omit to auto-generate from git changes.
-tools: Bash, Read, Write, Glob, Grep
----
-
-# Create Test Plan
-
-Create new Bang On It! test plan files.
-
-**What to test:** $ARGUMENTS
-
-## Instructions
-
-### Step 0: Determine what to test
-
-- If $ARGUMENTS is provided, use it as the description of what to test.
-- If $ARGUMENTS is empty, auto-discover from git changes:
-  1. Run \`git log master..HEAD --oneline\` and \`git diff master...HEAD --stat\` to see what changed on this branch.
-  2. If no branch divergence, run \`git diff HEAD --stat\` and \`git diff HEAD\` for uncommitted changes.
-  3. If still nothing, run \`git log -1 --format="%H %s"\` and \`git show HEAD --stat\` for the latest commit.
-  4. Analyze the changes and create test plan(s) covering them. Bug fixes get regression tests, new features get acceptance tests.
-  5. Skip changes that are already covered by existing test plans, pure refactors, docs, CI, or dependency updates.
-
-### Step 1: Determine which directory the test belongs in
-   - \`${testplans}/smoke/\` — Quick sanity checks (app loads, critical path works). Keep smoke tests minimal — they run on every commit so they must be fast. Only add here if it tests truly fundamental functionality. Prefer acceptance/ for most tests.
-   - \`${testplans}/acceptance/\` — Core user journeys and happy paths. This is the default for most new tests.
-   - \`${testplans}/regression/\` — Bug fixes and edge cases. Use when the description references a bug or issue.
-
-2. Read existing test plans in that directory to understand conventions:
-   \`\`\`bash
-   ls ${testplans}/smoke/ ${testplans}/acceptance/ ${testplans}/regression/
-   \`\`\`
-
-3. Read the codebase to understand what UI elements and flows are involved. Look at routes, components, and pages relevant to the test.
-
-4. Create the test plan file:
-   - Filename: kebab-case, e.g. \`password-reset.md\`
-   - Use this format:
-
-   \`\`\`markdown
-   ---
-   name: Descriptive test name
-   retries: 1
-   ---
-
-   ## Steps
-   1. Navigate to the relevant page
-   2. Perform the action being tested
-   3. Verify the expected outcome
-   \`\`\`
-
-5. Keep steps concise and actionable. Write from the user's perspective — describe what to click, type, and verify. Don't reference CSS selectors or implementation details.
-
-6. Output the path to the created file.
-`);
-    console.log(`  ${c.green}Created${c.reset} .claude/skills/boi-create-test/SKILL.md`);
-    // --- CI setup ---
-    console.log("");
-    const setupCi = await p.askChoice("Set up GitHub Actions?", ["y", "n"], "y");
-    if (setupCi === "y") {
-        const smokeWorkflow = `# Bang On It! — Smoke Tests
-# Runs on every push to main/master and on pull requests.
-#
-# EDIT: Review the steps below and adjust for your project:
-#   - node-version: set to your project's Node.js version
-#   - "Setup project": your install/build commands
-#   - "Start server": command to start your app in the background
-#   - "Wait for server": URL your app serves on
-#   - "Run smoke tests": timeout and test plan path
-#
-# REQUIRED SECRET:
-#   ANTHROPIC_API_KEY — your Anthropic API key
-#     Set at: https://github.com/<owner>/<repo>/settings/secrets/actions
-#
-# OPTIONAL — to upload recordings to S3 and link them in PR comments:
-#   1. Add secrets: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY
-#   2. Uncomment the "Upload recordings to S3" step below
-#   3. Set BANGONIT_S3_BASE_URL in the env section
-
-name: "Bang On It! Smoke Tests"
-
-on:
-  push:
-    branches: [main, master]
-  pull_request:
-
-permissions:
-  contents: write
-  pull-requests: write
-
-jobs:
-  smoke:
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    env:
-      ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
-      # EDIT: Uncomment for S3 recording uploads
-      # AWS_ACCESS_KEY_ID: \${{ secrets.AWS_ACCESS_KEY_ID }}
-      # AWS_SECRET_ACCESS_KEY: \${{ secrets.AWS_SECRET_ACCESS_KEY }}
-      # BANGONIT_S3_BASE_URL: "https://my-bucket.s3.amazonaws.com/bangonit"
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '24'  # EDIT: your Node.js version
-
-      - name: Install system dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y xvfb libnss3 libatk1.0-0 libatk-bridge2.0-0 libcups2 libdrm2 libxkbcommon0 libxcomposite1 libxdamage1 libxrandr2 libgbm1 libpango-1.0-0 libcairo2 libasound2t64
-
-      - name: Setup project
-        run: npm install && npm run build  # EDIT: your install/build commands
-
-      - name: Start server
-        run: npm start &  # EDIT: command to start your web server
-
-      - name: Wait for server
-        run: npx wait-on http://localhost:3000 --timeout 30000  # EDIT: your app's URL
-
-      - name: Install bangonit
-        run: npm install -g bangonit
-
-      - name: Comment test starting
-        id: start-comment
-        if: github.event_name == 'pull_request'
-        run: boi ci comment-starting --repo \${{ github.repository }} --pr \${{ github.event.pull_request.number }} >> "$GITHUB_OUTPUT"
-        env:
-          GH_TOKEN: \${{ github.token }}
-
-      - name: Run smoke tests
-        run: |
-          xvfb-run --auto-servernum boi run ${testplans}/smoke/*.md \\
-            --timeout 300 \\
-            --output \${{ github.workspace }}/bangonit-output.json --record
-
-      # EDIT: Uncomment to upload recordings to S3-compatible storage.
-      # Requires AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY secrets.
-      # - name: Upload recordings to S3
-      #   if: always()
-      #   run: >-
-      #     boi ci upload-recordings
-      #     --bucket MY-BUCKET --prefix bangonit
-      #     --endpoint-url https://s3.us-east-1.amazonaws.com
-
-      - name: Comment test results
-        if: always()
-        run: |
-          ARGS="--repo \${{ github.repository }}"
-          ARGS="$ARGS --output \${{ github.workspace }}/bangonit-output.json"
-          ARGS="$ARGS --workflow-name \\"\${{ github.workflow }}\\""
-          ARGS="$ARGS --sha \${{ github.sha }}"
-          ARGS="$ARGS --run-url \\"\${{ github.server_url }}/\${{ github.repository }}/actions/runs/\${{ github.run_id }}\\""
-          if [ -n "\${{ github.event.pull_request.number }}" ]; then
-            ARGS="$ARGS --pr \${{ github.event.pull_request.number }}"
-          fi
-          if [ -n "\${{ steps.start-comment.outputs.comment_id }}" ]; then
-            ARGS="$ARGS --comment-id \${{ steps.start-comment.outputs.comment_id }}"
-          fi
-          eval "boi ci comment-results $ARGS"
-        env:
-          GH_TOKEN: \${{ github.token }}
-
-      - name: Upload test results
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: bangonit-smoke-results
-          path: |
-            \${{ github.workspace }}/bangonit-output.json
-            recordings/
-          if-no-files-found: ignore
-`;
-        const fullWorkflow = `# Bang On It! — Full Tests
-# Runs all test plans daily at 6 PM US/Eastern (23:00 UTC) and on manual trigger.
-# Edit the cron schedule below to change the time or timezone.
-#
-# Same setup as smoke tests — see bangonit-smoke.yml for EDIT instructions.
-
-name: "Bang On It! Full Tests"
-
-on:
-  schedule:
-    - cron: '0 23 * * *'  # EDIT: daily at 6 PM US/Eastern (23:00 UTC)
-  workflow_dispatch:
-
-permissions:
-  contents: write
-
-jobs:
-  full:
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    env:
-      ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
-      # EDIT: Uncomment for S3 recording uploads (see bangonit-smoke.yml)
-      # AWS_ACCESS_KEY_ID: \${{ secrets.AWS_ACCESS_KEY_ID }}
-      # AWS_SECRET_ACCESS_KEY: \${{ secrets.AWS_SECRET_ACCESS_KEY }}
-      # BANGONIT_S3_BASE_URL: "https://my-bucket.s3.amazonaws.com/bangonit"
-
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: '24'  # EDIT: your Node.js version
-
-      - name: Install system dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y xvfb libnss3 libatk1.0-0 libatk-bridge2.0-0 libcups2 libdrm2 libxkbcommon0 libxcomposite1 libxdamage1 libxrandr2 libgbm1 libpango-1.0-0 libcairo2 libasound2t64
-
-      - name: Setup project
-        run: npm install && npm run build  # EDIT: your install/build commands
-
-      - name: Start server
-        run: npm start &  # EDIT: command to start your web server
-
-      - name: Wait for server
-        run: npx wait-on http://localhost:3000 --timeout 30000  # EDIT: your app's URL
-
-      - name: Install bangonit
-        run: npm install -g bangonit
-
-      - name: Run all tests
-        run: |
-          xvfb-run --auto-servernum boi run \\
-            --timeout 300 \\
-            --output \${{ github.workspace }}/bangonit-output.json --record
-
-      # EDIT: Uncomment to upload recordings to S3 (see bangonit-smoke.yml for full example)
-      # - name: Upload recordings to S3
-      #   if: always()
-      #   run: >-
-      #     boi ci upload-recordings
-      #     --bucket MY-BUCKET --prefix bangonit
-      #     --endpoint-url https://s3.us-east-1.amazonaws.com
-
-      - name: Comment test results on commit
-        if: always()
-        run: >-
-          boi ci comment-results
-          --repo \${{ github.repository }}
-          --output \${{ github.workspace }}/bangonit-output.json
-          --workflow-name "\${{ github.workflow }}"
-          --sha \${{ github.sha }}
-          --run-url "\${{ github.server_url }}/\${{ github.repository }}/actions/runs/\${{ github.run_id }}"
-        env:
-          GH_TOKEN: \${{ github.token }}
-
-      - name: Upload test results
-        if: always()
-        uses: actions/upload-artifact@v4
-        with:
-          name: bangonit-full-results
-          path: |
-            \${{ github.workspace }}/bangonit-output.json
-            recordings/
-          if-no-files-found: ignore
-`;
-        const outDir = path.join(process.cwd(), ".github", "workflows");
-        fs.mkdirSync(outDir, { recursive: true });
-        const smokePath = path.join(outDir, "bangonit-smoke.yml");
-        fs.writeFileSync(smokePath, smokeWorkflow);
-        console.log(`\n  ${c.green}Created${c.reset} ${path.relative(process.cwd(), smokePath)}`);
-        const fullPath = path.join(outDir, "bangonit-full.yml");
-        fs.writeFileSync(fullPath, fullWorkflow);
-        console.log(`  ${c.green}Created${c.reset} ${path.relative(process.cwd(), fullPath)}`);
-        console.log(`\n  ${c.yellow}Next steps:${c.reset}`);
-        console.log(`    1. Edit the workflow files — look for ${c.bold}EDIT${c.reset} comments`);
-        console.log(`    2. Add your ${c.bold}ANTHROPIC_API_KEY${c.reset} secret to GitHub`);
-        console.log(`       ${c.dim}https://github.com/<owner>/<repo>/settings/secrets/actions${c.reset}`);
-        console.log(`    3. Commit and push to trigger your first run`);
-    }
-    p.close();
-    console.log("");
-}
-async function run(argv, config) {
-    loadEnv();
-    // Config can provide the API key (supports ${ENV_VAR} interpolation)
-    if (config.anthropic_api_key && !process.env.ANTHROPIC_API_KEY) {
-        process.env.ANTHROPIC_API_KEY = config.anthropic_api_key;
-    }
-    if (!process.env.ANTHROPIC_API_KEY) {
-        die("Error: ANTHROPIC_API_KEY is not set.\nSet it in your environment, .env file, or .bangonit/config.toml.");
-    }
-    const recordingsDir = config.recordings_dir
-        ? path.resolve(process.cwd(), config.recordings_dir)
-        : path.join(process.cwd(), "recordings");
-    // Validate test plan files exist and expand directories
-    const expandedFiles = [];
-    for (const file of argv.files) {
-        const absPath = path.isAbsolute(file) ? file : path.join(process.cwd(), file);
-        if (!fs.existsSync(absPath)) {
-            die(`Test plan file not found: ${file}`);
-        }
-        if (fs.statSync(absPath).isDirectory()) {
-            expandedFiles.push(...findTestPlans(absPath, argv.filter));
-        }
-        else {
-            expandedFiles.push(file);
-        }
-    }
-    // Discover test plans if no files/plan specified
-    const files = [...expandedFiles];
-    if (files.length === 0 && !argv.plan && config.testplans) {
-        const testDirPath = path.resolve(process.cwd(), config.testplans);
-        const plans = findTestPlans(testDirPath, argv.filter);
-        if (plans.length > 0) {
-            files.push(...plans);
-        }
-        else if (argv.filter) {
-            die(`No test plans matching "${argv.filter}" found in ${config.testplans}/`);
-        }
-    }
-    else if (files.length === 0 && !argv.plan && argv.filter) {
-        die(`--filter requires a testplans directory configured in .bangonit/config.toml`);
-    }
-    // Hint when launching interactive UI with no config
-    if (files.length === 0 && !argv.plan) {
-        if (!config.testplans) {
-            console.log(`${c.dim}No test plans specified. Launching interactive UI.${c.reset}`);
-            console.log(`${c.dim}Tip: Run ${c.reset}boi init${c.dim} to set up a config file, or pass test plan files directly.${c.reset}\n`);
-        }
-    }
-    // Build structured args for Electron (passed via BANGONIT_ARGS env var)
-    const electronArgs = args_1.electronArgsSchema.parse({
-        testPlanFiles: files,
-        headless: argv.headless,
-        exit: argv.exit,
-        keepOpen: argv.keepOpen,
-        json: argv.json,
-        console: argv.console,
-        record: argv.record,
-        retries: argv.retries ?? 0,
-        output: argv.output ? path.resolve(process.cwd(), argv.output) : null,
-        plan: argv.plan || null,
-        prompt: argv.additionalSystemPrompt || null,
-        concurrency: argv.concurrency ?? 1,
-        timeout: argv.timeout ?? 0,
-        cwd: process.cwd(),
-        recordingsDir: argv.record ? recordingsDir : null,
-    });
-    const PORT = await getFreePort();
-    fs.mkdirSync(LOGS_DIR, { recursive: true });
-    const standaloneServer = path.join(WEBAPP_DIR, ".next", "standalone", "app", "webapp", "server.js");
-    const nextDir = path.join(WEBAPP_DIR, ".next");
-    const isBuilt = fs.existsSync(nextDir);
-    let webappProc;
-    if (fs.existsSync(standaloneServer)) {
-        webappProc = (0, child_process_1.spawn)("node", [standaloneServer], {
-            cwd: path.dirname(standaloneServer),
-            env: { ...process.env, NODE_ENV: "production", PORT: String(PORT), HOSTNAME: "0.0.0.0" },
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-    }
-    else if (isBuilt) {
-        webappProc = (0, child_process_1.spawn)("npx", ["next", "start", "-p", String(PORT)], {
-            cwd: WEBAPP_DIR,
-            env: { ...process.env, NODE_ENV: "production" },
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-    }
-    else {
-        webappProc = (0, child_process_1.spawn)("npx", ["next", "dev", "-p", String(PORT)], {
-            cwd: WEBAPP_DIR,
-            env: { ...process.env },
-            stdio: ["ignore", "pipe", "pipe"],
-        });
-    }
-    const webappLog = fs.createWriteStream(path.join(LOGS_DIR, "webapp.log"));
-    webappProc.stdout.pipe(webappLog);
-    webappProc.stderr.pipe(webappLog);
-    let webappCrashed = false;
-    webappProc.on("exit", (code) => {
-        if (!webappCrashed && code !== null && code !== 0) {
-            webappCrashed = true;
-            die(`Webapp server crashed (exit code ${code}). Check logs/webapp.log for details.`);
-        }
-    });
-    // Save terminal state before Electron (which inherits stdin) can modify it.
-    // stty is not available on Windows.
-    let savedTtyState = null;
-    if (process.platform !== "win32" && process.stdin.isTTY) {
-        try {
-            savedTtyState = (0, child_process_1.execSync)("stty -g", { stdio: ["inherit", "pipe", "ignore"] })
-                .toString()
-                .trim();
-        }
-        catch (e) {
-            console.error("[cli] stty save failed:", e.message);
-        }
-    }
-    let electronProc = null;
-    const cleanup = () => {
-        webappCrashed = true; // suppress crash message during normal shutdown
-        try {
-            electronProc?.kill();
-        }
-        catch (e) {
-            console.error("[cli] electronProc.kill failed:", e.message);
-        }
-        try {
-            webappProc.kill();
-        }
-        catch (e) {
-            console.error("[cli] webappProc.kill failed:", e.message);
-        }
-        // Restore terminal state — Electron may have changed raw mode, echo, etc.
-        if (savedTtyState) {
-            try {
-                (0, child_process_1.execSync)(`stty ${savedTtyState}`, { stdio: ["inherit", "ignore", "ignore"] });
-            }
-            catch (e) {
-                console.error("[cli] stty restore failed:", e.message);
-            }
-        }
-    };
-    process.on("exit", cleanup);
-    process.on("SIGINT", () => {
-        cleanup();
-        process.exit(1);
-    });
-    process.on("SIGTERM", () => {
-        cleanup();
-        process.exit(1);
-    });
-    await waitForPort(PORT);
-    const electronMain = path.join(DESKTOP_DIR, "dist", "main", "index.js");
-    if (!fs.existsSync(electronMain)) {
-        try {
-            (0, child_process_1.execSync)("npx tsc", { cwd: DESKTOP_DIR, stdio: "inherit" });
-        }
-        catch {
-            cleanup();
-            die("Failed to compile Electron app");
-        }
-    }
-    let electronPath;
-    try {
-        electronPath = require(path.join(DESKTOP_DIR, "node_modules", "electron"));
-    }
-    catch {
-        try {
-            electronPath = require("electron");
-        }
-        catch {
-            cleanup();
-            die("Error: electron not found. Run `npm install` in app/desktopapp.");
-        }
-    }
-    const electronExtraArgs = process.env.CI ? ["--no-sandbox", "--disable-gpu"] : [];
-    electronProc = (0, child_process_1.spawn)(electronPath, [".", ...electronExtraArgs], {
-        cwd: DESKTOP_DIR,
-        env: {
-            ...process.env,
-            [args_1.ELECTRON_ARGS_ENV]: JSON.stringify(electronArgs),
-            WEBAPP_URL: `http://localhost:${PORT}/app`,
-            NODE_ENV: process.env.NODE_ENV || "production",
-        },
-        stdio: ["inherit", "inherit", "pipe"],
-    });
-    const electronLog = fs.createWriteStream(path.join(LOGS_DIR, "electron.log"));
-    electronProc.stderr.pipe(electronLog);
-    electronProc.stderr.pipe(process.stderr, { end: false });
-    electronProc.on("exit", (code) => {
-        cleanup();
-        process.exit(code ?? 1);
-    });
-}
-// --- ci commands ---
-function ghExec(args) {
-    try {
-        return (0, child_process_1.execSync)(`gh ${args}`, { stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
-    }
-    catch (err) {
-        const stderr = err.stderr?.toString().trim() || err.message;
-        die(`gh command failed: ${stderr}`);
-    }
-}
-function ciCommentStarting(argv) {
-    const commentId = ghExec(`api repos/${argv.repo}/issues/${argv.pr}/comments --method POST --field "body=🧪 **Bang On It!** tests starting..." --jq '.id'`);
-    // Output in GitHub Actions format so the workflow can capture it
-    process.stdout.write(`comment_id=${commentId}\n`);
-}
-function ciCommentResults(argv) {
-    let body;
-    if (!fs.existsSync(argv.output)) {
-        const logsLink = argv.runUrl ? ` Check the [workflow logs](${argv.runUrl}).` : "";
-        body = `## ${argv.workflowName} — ❌ Failed\n\nNo test output was produced.${logsLink}`;
-    }
-    else {
-        const data = JSON.parse(fs.readFileSync(argv.output, "utf-8"));
-        const passed = data.status === "pass";
-        const header = `## ${argv.workflowName} — ${passed ? "✅ Passed" : "❌ Failed"}`;
-        const rows = [];
-        for (const test of data.tests || []) {
-            const emoji = test.status === "pass" ? "✅" : "❌";
-            const duration = (test.duration / 1000).toFixed(1);
-            let recording = "";
-            // Check output JSON for recording URLs first
-            const rec = (data.recordings || []).find((r) => r.name && test.name && r.name.includes(test.name));
-            if (rec?.url) {
-                recording = `[View recording](${rec.url})`;
-            }
-            else if (argv.s3BaseUrl && fs.existsSync(argv.recordingsDir)) {
-                // Fall back to constructing URL from local recording dirs
-                try {
-                    const dirs = fs
-                        .readdirSync(argv.recordingsDir)
-                        .filter((d) => fs.existsSync(path.join(argv.recordingsDir, d, "index.html")));
-                    if (dirs.length > 0) {
-                        recording = `[View recording](${argv.s3BaseUrl}/${dirs[0]}/index.html)`;
-                    }
-                }
-                catch {
-                    // ignore
-                }
-            }
-            rows.push(`| ${test.name} | ${emoji} ${test.status} | ${duration}s | ${recording} |`);
-        }
-        const table = `| Test | Status | Duration | Recording |\n|------|--------|----------|-----------|${rows.length > 0 ? "\n" + rows.join("\n") : ""}`;
-        body = `${header}\n\n${table}`;
-    }
-    // Post the comment via gh, passing body on stdin to avoid shell escaping issues
-    if (argv.pr && argv.commentId) {
-        (0, child_process_1.execSync)(`gh api repos/${argv.repo}/issues/comments/${argv.commentId} --method PATCH --field "body=@-"`, {
-            input: body,
-            stdio: ["pipe", "inherit", "inherit"],
-        });
-    }
-    else if (argv.pr) {
-        (0, child_process_1.execSync)(`gh api repos/${argv.repo}/issues/${argv.pr}/comments --method POST --field "body=@-"`, {
-            input: body,
-            stdio: ["pipe", "inherit", "inherit"],
-        });
-    }
-    else if (argv.sha) {
-        (0, child_process_1.execSync)(`gh api repos/${argv.repo}/commits/${argv.sha}/comments --method POST --field "body=@-"`, {
-            input: body,
-            stdio: ["pipe", "inherit", "inherit"],
-        });
-    }
-    else {
-        // No target — print to stdout
-        console.log(body);
-    }
-}
-async function uploadDirToS3(client, localDir, bucket, prefix) {
-    const uploaded = [];
-    const entries = fs.readdirSync(localDir, { withFileTypes: true });
-    for (const entry of entries) {
-        const fullPath = path.join(localDir, entry.name);
-        const objectName = `${prefix}/${entry.name}`;
-        if (entry.isDirectory()) {
-            uploaded.push(...(await uploadDirToS3(client, fullPath, bucket, objectName)));
-        }
-        else {
-            await client.fPutObject(bucket, objectName, fullPath, {});
-            uploaded.push(objectName);
-        }
-    }
-    return uploaded;
-}
-async function setObjectPublicRead(client, bucket, objectName) {
-    const c = client;
-    await new Promise((resolve, reject) => {
-        c.makeRequest({
-            method: "PUT",
-            bucketName: bucket,
-            objectName,
-            query: "acl",
-            headers: { "x-amz-acl": "public-read" },
-        }, "", [200], "", true, (err) => {
-            if (err)
-                reject(err);
-            else
-                resolve();
-        });
-    });
-}
-async function ciUploadRecordings(argv) {
-    if (!fs.existsSync(argv.recordingsDir)) {
-        console.log("No recordings directory found, skipping upload.");
-        return;
-    }
-    const dirs = fs.readdirSync(argv.recordingsDir).filter((d) => {
-        const full = path.join(argv.recordingsDir, d);
-        return fs.statSync(full).isDirectory();
-    });
-    if (dirs.length === 0) {
-        console.log("No recording directories found, skipping upload.");
-        return;
-    }
-    const accessKey = argv.accessKey || process.env.AWS_ACCESS_KEY_ID || "";
-    const secretKey = argv.secretKey || process.env.AWS_SECRET_ACCESS_KEY || "";
-    const region = argv.region || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || "us-east-1";
-    let client;
-    if (argv.endpointUrl) {
-        const useSSL = !argv.endpointUrl.startsWith("http://");
-        const endPoint = argv.endpointUrl.replace(/^https?:\/\//, "");
-        client = new Minio.Client({ endPoint, useSSL, accessKey, secretKey, region });
-    }
-    else {
-        client = new Minio.Client({ endPoint: "s3.amazonaws.com", useSSL: true, accessKey, secretKey, region });
-    }
-    for (const dir of dirs) {
-        const localPath = path.join(argv.recordingsDir, dir);
-        console.log(`Uploading ${dir}...`);
-        const uploaded = await uploadDirToS3(client, localPath, argv.bucket, `${argv.prefix}/${dir}`);
-        for (const key of uploaded) {
-            await setObjectPublicRead(client, argv.bucket, key);
-        }
-    }
-    console.log(`Uploaded ${dirs.length} recording(s).`);
-    process.exit(0);
-}
-// --- main ---
-const ciDefaults = is_ci_1.default ? { headless: true, exit: true } : {};
-(0, yargs_1.default)((0, helpers_1.hideBin)(process.argv))
-    .scriptName("boi")
-    .usage("Usage: $0 <command> [options]")
-    .command("init", "Set up Bang On It! (config, test plans, and optionally CI)", {}, () => {
-    initProject();
-})
-    .command(["run [files..]", "$0"], "Run test plans (or launch interactive UI)", (y) => y
-    .positional("files", { type: "string", array: true, default: [], describe: "Test plan files" })
-    .option("filter", { alias: "t", type: "string", describe: "Filter test plans by name substring" })
-    .option("config", { type: "string", describe: "Path to config file (default: .bangonit/config.toml)" })
-    .option("plan", { type: "string", describe: "Inline test plan (instead of file)" })
-    .option("additional-system-prompt", {
-    type: "string",
-    describe: "Additional system prompt text appended to test plan",
-})
-    .option("record", { type: "boolean", default: false, describe: "Record session replay" })
-    .option("retries", { type: "number", describe: "Retry failed tests N times (overrides test plan frontmatter)" })
-    .option("headless", {
-    type: "boolean",
-    default: ciDefaults.headless ?? false,
-    describe: "Run without showing the browser window",
-})
-    .option("exit", {
-    type: "boolean",
-    default: ciDefaults.exit ?? false,
-    describe: "Exit immediately after tests complete",
-})
-    .option("keep-open", {
-    type: "boolean",
-    default: false,
-    describe: "Keep the browser window open after tests pass (for inspection)",
-})
-    .option("json", { type: "boolean", default: false, describe: "Stream NDJSON events to stdout" })
-    .option("console", { type: "boolean", default: false, describe: "Forward browser console logs to stdout" })
-    .option("output", { type: "string", describe: "Write JSON results to file" })
-    .option("concurrency", { type: "number", describe: "Number of parallel agents (default: 1)" })
-    .option("timeout", { type: "number", describe: "Test timeout in seconds (0 = none)" }), (argv) => {
-    const config = loadConfig(argv.config);
-    run({
-        files: argv.files,
-        filter: argv.filter,
-        plan: argv.plan,
-        additionalSystemPrompt: argv.additionalSystemPrompt,
-        record: argv.record,
-        retries: argv.retries,
-        headless: argv.headless,
-        exit: argv.exit,
-        keepOpen: argv.keepOpen,
-        json: argv.json,
-        console: argv.console,
-        output: argv.output,
-        concurrency: argv.concurrency,
-        timeout: argv.timeout,
-    }, config);
-})
-    .command("ci", "CI helper commands (used by generated GitHub Actions workflows)", (y) => y
-    .command("comment-starting", "Post a 'tests starting' comment on a PR", (y) => y
-    .option("repo", { type: "string", demandOption: true, describe: "GitHub repo (owner/repo)" })
-    .option("pr", { type: "number", demandOption: true, describe: "PR number" }), (argv) => ciCommentStarting({ repo: argv.repo, pr: argv.pr }))
-    .command("comment-results", "Post test results as a PR or commit comment", (y) => y
-    .option("repo", { type: "string", demandOption: true, describe: "GitHub repo (owner/repo)" })
-    .option("output", { type: "string", demandOption: true, describe: "Path to bangonit-output.json" })
-    .option("workflow-name", { type: "string", demandOption: true, describe: "Workflow name for the header" })
-    .option("pr", { type: "number", describe: "PR number (for PR comments)" })
-    .option("comment-id", { type: "string", describe: "Existing comment ID to edit" })
-    .option("sha", { type: "string", describe: "Commit SHA (for commit comments)" })
-    .option("run-url", { type: "string", describe: "URL to workflow run logs" })
-    .option("s3-base-url", {
-    type: "string",
-    describe: "Base URL for S3 recording links",
-    default: process.env.BANGONIT_S3_BASE_URL || "",
-})
-    .option("recordings-dir", { type: "string", describe: "Recordings directory", default: "recordings" }), (argv) => ciCommentResults({
-    repo: argv.repo,
-    output: argv.output,
-    workflowName: argv.workflowName,
-    pr: argv.pr,
-    commentId: argv.commentId,
-    sha: argv.sha,
-    runUrl: argv.runUrl,
-    s3BaseUrl: argv.s3BaseUrl || undefined,
-    recordingsDir: argv.recordingsDir,
-}))
-    .command("upload-recordings", "Upload recordings to S3-compatible storage", (y) => y
-    .option("bucket", { type: "string", demandOption: true, describe: "S3 bucket name" })
-    .option("prefix", { type: "string", demandOption: true, describe: "S3 key prefix" })
-    .option("recordings-dir", { type: "string", describe: "Local recordings directory", default: "recordings" })
-    .option("endpoint-url", { type: "string", describe: "S3 endpoint URL" })
-    .option("access-key", { type: "string", describe: "S3 access key (default: AWS_ACCESS_KEY_ID env)" })
-    .option("secret-key", { type: "string", describe: "S3 secret key (default: AWS_SECRET_ACCESS_KEY env)" })
-    .option("region", { type: "string", describe: "S3 region (default: us-east-1)" }), (argv) => ciUploadRecordings({
-    bucket: argv.bucket,
-    prefix: argv.prefix,
-    recordingsDir: argv.recordingsDir,
-    endpointUrl: argv.endpointUrl,
-    accessKey: argv.accessKey,
-    secretKey: argv.secretKey,
-    region: argv.region,
-}))
-    .demandCommand(1, "Specify a ci subcommand: comment-starting, comment-results, upload-recordings"))
-    .example("$0 run test.md", "Run a test plan file")
-    .example("$0 run --plan 'test login flow'", "Run an inline test plan")
-    .example("$0 run -t checkout", "Run test plans matching 'checkout'")
-    .example("$0 run", "Launch interactive UI")
-    .example("$0 init", "Set up config, test plans, and CI")
-    .strict()
-    .help()
-    .alias("h", "help")
-    .parseAsync();