bangonit 0.5.0 → 0.5.4

package/bin/src/cli/bangonit.js

@@ -44,7 +44,6 @@ 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"));
@@ -183,50 +182,6 @@ function findTestPlans(dir, filter) {
     }
     return results;
 }
-function createS3Client(opts) {
-    const accessKey = opts.accessKey || process.env.AWS_ACCESS_KEY_ID || "";
-    const secretKey = opts.secretKey || process.env.AWS_SECRET_ACCESS_KEY || "";
-    const region = opts.region || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || "us-east-1";
-    if (opts.endpoint) {
-        const useSSL = !opts.endpoint.startsWith("http://");
-        const endPoint = opts.endpoint.replace(/^https?:\/\//, "");
-        return new Minio.Client({ endPoint, useSSL, accessKey, secretKey, region });
-    }
-    return new Minio.Client({
-        endPoint: "s3.amazonaws.com",
-        useSSL: true,
-        accessKey,
-        secretKey,
-        region,
-    });
-}
-async function uploadDir(client, localDir, bucket, prefix) {
-    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()) {
-            await uploadDir(client, fullPath, bucket, objectName);
-        }
-        else {
-            await client.fPutObject(bucket, objectName, fullPath, {});
-        }
-    }
-}
-async function uploadToS3(localDir, opts) {
-    const client = createS3Client(opts);
-    await uploadDir(client, localDir, opts.bucket, opts.prefix);
-    const region = opts.region || process.env.AWS_REGION || process.env.AWS_DEFAULT_REGION || "us-east-1";
-    if (opts.endpoint) {
-        const proto = opts.endpoint.startsWith("http://") ? "http" : "https";
-        const host = opts.endpoint.replace(/^https?:\/\//, "");
-        return `${proto}://${opts.bucket}.${host}/${opts.prefix}/index.html`;
-    }
-    if (region === "us-east-1") {
-        return `https://${opts.bucket}.s3.amazonaws.com/${opts.prefix}/index.html`;
-    }
-    return `https://${opts.bucket}.s3.${region}.amazonaws.com/${opts.prefix}/index.html`;
-}
 function createPrompter() {
     let closed = false;
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -261,63 +216,40 @@ function createPrompter() {
     };
 }
 // --- init command ---
-// Common timezone offsets from UTC (standard time)
-const TIMEZONE_OFFSETS = {
-    "us/eastern": -5,
-    "us/central": -6,
-    "us/mountain": -7,
-    "us/pacific": -8,
-    "europe/london": 0,
-    "europe/berlin": 1,
-    "europe/paris": 1,
-    "asia/tokyo": 9,
-    "asia/shanghai": 8,
-    "asia/kolkata": 5,
-    "australia/sydney": 11,
-};
-function localHourToUtc(localHour, utcOffset) {
-    return (((localHour - utcOffset) % 24) + 24) % 24;
-}
 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 apiKey = await p.ask("Anthropic API key (empty to use env var)", "");
     const recordingsDir = await p.ask("Recordings directory", "recordings");
-    const s3Bucket = await p.ask("S3 bucket for recordings (empty to skip)", "");
-    let s3Endpoint = "";
-    let s3Region = "";
-    let s3Prefix = "";
-    if (s3Bucket) {
-        s3Endpoint = await p.ask("S3 endpoint (empty for AWS, or e.g. nyc3.digitaloceanspaces.com)", "");
-        s3Region = await p.ask("S3 region", "us-east-1");
-        s3Prefix = await p.ask("S3 prefix", "bangonit");
-    }
     // --- Config file ---
-    let toml = `testplans = "${testplans}"\n`;
-    toml += `recordings_dir = "${recordingsDir}"\n`;
-    if (apiKey) {
-        toml += `anthropic_api_key = "${apiKey}"\n`;
-    }
-    else {
-        toml += `# anthropic_api_key = "\${ANTHROPIC_API_KEY}"\n`;
-    }
-    if (s3Bucket) {
-        toml += `\n[s3]\nbucket = "${s3Bucket}"\n`;
-        if (s3Endpoint)
-            toml += `endpoint = "${s3Endpoint}"\n`;
-        if (s3Region && s3Region !== "us-east-1")
-            toml += `region = "${s3Region}"\n`;
-        if (s3Prefix && s3Prefix !== "bangonit")
-            toml += `prefix = "${s3Prefix}"\n`;
-        toml += `# access_key = "\${AWS_ACCESS_KEY_ID}"\n`;
-        toml += `# secret_key = "\${AWS_SECRET_ACCESS_KEY}"\n`;
-    }
+    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"];
@@ -329,26 +261,12 @@ async function initProject() {
             fs.writeFileSync(gitkeep, "");
         console.log(`  ${c.green}Created${c.reset} ${testplans}/${dir}/`);
     }
-    // Write example smoke test
-    const smokeExample = path.join(testplanBase, "smoke", "homepage.md");
-    if (!fs.existsSync(smokeExample)) {
-        fs.writeFileSync(smokeExample, `---
-name: Homepage loads
----
-
-## Steps
-1. Navigate to http://localhost:3000
-2. Verify the page loads with a heading
-3. Verify there are no console errors
-`);
-        console.log(`  ${c.green}Created${c.reset} ${testplans}/smoke/homepage.md`);
-    }
     // --- Claude Code skills ---
     const claudeSkillsDir = path.join(process.cwd(), ".claude", "skills");
-    const testSkillDir = path.join(claudeSkillsDir, "test");
+    const testSkillDir = path.join(claudeSkillsDir, "boi-test");
     fs.mkdirSync(testSkillDir, { recursive: true });
     fs.writeFileSync(path.join(testSkillDir, "SKILL.md"), `---
-name: test
+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
 ---
@@ -380,11 +298,11 @@ Run Bang On It! end-to-end tests locally.
 
 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/test/SKILL.md`);
-    const createTestSkillDir = path.join(claudeSkillsDir, "create-test");
+    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: create-test
+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
 ---
@@ -439,67 +357,170 @@ Create new Bang On It! test plan files.
 
 6. Output the path to the created file.
 `);
-    console.log(`  ${c.green}Created${c.reset} .claude/skills/create-test/SKILL.md`);
+    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 CI?", ["y", "n"], "y");
+    const setupCi = await p.askChoice("Set up GitHub Actions?", ["y", "n"], "y");
     if (setupCi === "y") {
-        console.log("");
-        const baseImage = await p.ask("GitHub Actions runner", "ubuntu-latest");
-        const nodeVersion = await p.ask("Node.js version", "20");
-        const setupCommand = await p.ask("Setup command", "npm install && npm run build");
-        const startCommand = await p.ask("Command to start your web server", "npm start &");
-        const waitUrl = await p.ask("URL to wait for before testing", "http://localhost:3000");
-        const timeout = await p.ask("Test timeout in seconds", "300");
-        const tzNames = Object.keys(TIMEZONE_OFFSETS).join(", ");
-        const tz = await p.ask(`Timezone for full run (${tzNames})`, "us/eastern");
-        const utcOffset = TIMEZONE_OFFSETS[tz.toLowerCase()] ?? -5;
-        const fullUtcHour = localHourToUtc(18, utcOffset);
-        const timeoutMinutes = Math.ceil(parseInt(timeout) / 60) + 5;
-        const stepsYaml = `
+        // Build the comment shell script once, reused by both workflows
+        const commentScript = `OUTPUT="\${{ github.workspace }}/bangonit-output.json"
+          if [ ! -f "$OUTPUT" ]; then
+            BODY="## \${{ github.workflow }} — ❌ Failed\\n\\nNo test output was produced. Check the [workflow logs](\${{ github.server_url }}/\${{ github.repository }}/actions/runs/\${{ github.run_id }})."
+          else
+            STATUS=$(jq -r '.status' "$OUTPUT")
+            if [ "$STATUS" = "pass" ]; then
+              HEADER="## \${{ github.workflow }} — ✅ Passed"
+            else
+              HEADER="## \${{ github.workflow }} — ❌ Failed"
+            fi
+
+            TABLE="| Test | Status | Duration | Recording |\\n|------|--------|----------|-----------|"
+            for row in $(jq -r '.tests[] | @base64' "$OUTPUT"); do
+              NAME=$(echo "$row" | base64 -d | jq -r '.name')
+              TEST_STATUS=$(echo "$row" | base64 -d | jq -r '.status')
+              DURATION=$(echo "$row" | base64 -d | jq -r '(.duration / 1000 * 10 | round / 10)')
+              if [ "$TEST_STATUS" = "pass" ]; then
+                EMOJI="✅"
+              else
+                EMOJI="❌"
+              fi
+              RECORDING=""
+              RECORDING_URL=$(jq -r --arg name "$NAME" '.recordings[]? | select(.name | contains($name)) | .url // empty' "$OUTPUT" 2>/dev/null || true)
+              if [ -z "$RECORDING_URL" ] && [ -n "$BANGONIT_S3_BASE_URL" ] && [ -d "recordings" ]; then
+                for rdir in recordings/*/index.html; do
+                  if [ -f "$rdir" ]; then
+                    RNAME=$(basename "$(dirname "$rdir")")
+                    RECORDING_URL="$BANGONIT_S3_BASE_URL/$RNAME/index.html"
+                    break
+                  fi
+                done
+              fi
+              if [ -n "$RECORDING_URL" ]; then
+                RECORDING="[View recording]($RECORDING_URL)"
+              fi
+              TABLE="$TABLE\\n| $NAME | $EMOJI $TEST_STATUS | \${DURATION}s | $RECORDING |"
+            done
+
+            BODY="$HEADER\\n\\n$TABLE"
+          fi`;
+        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: '${nodeVersion}'
+          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 libasound2
+          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: ${setupCommand}
+        run: npm install && npm run build  # EDIT: your install/build commands
 
       - name: Start server
-        run: ${startCommand}
+        run: npm start &  # EDIT: command to start your web server
 
       - name: Wait for server
-        run: npx wait-on ${waitUrl} --timeout 30000
+        run: npx wait-on http://localhost:3000 --timeout 30000  # EDIT: your app's URL
 
       - name: Install bangonit
-        run: npm install -g bangonit`;
-        const smokeWorkflow = `name: "Bang On It! Smoke Tests"
-
-on:
-  push:
-    branches: [main, master]
-  pull_request:
+        run: npm install -g bangonit
 
-jobs:
-  smoke:
-    runs-on: ${baseImage}
-    timeout-minutes: ${timeoutMinutes}
-    env:
-      ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
-${stepsYaml}
+      - name: Comment test starting
+        id: start-comment
+        if: github.event_name == 'pull_request'
+        run: |
+          COMMENT_ID=$(gh api repos/\${{ github.repository }}/issues/\${{ github.event.pull_request.number }}/comments \\
+            --method POST --field "body=🧪 **Bang On It!** smoke tests starting..." --jq '.id')
+          echo "comment_id=$COMMENT_ID" >> "$GITHUB_OUTPUT"
+        env:
+          GH_TOKEN: \${{ github.token }}
 
       - name: Run smoke tests
         run: |
-          xvfb-run --auto-servernum boi run ${testplans}/smoke/ \\
-            --timeout ${timeout} \\
-            --output bangonit-output.json --record
+          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: |
+      #     if [ -d recordings ]; then
+      #       for dir in recordings/*/; do
+      #         if [ -d "$dir" ]; then
+      #           DIRNAME=$(basename "$dir")
+      #           aws s3 sync "$dir" "s3://MY-BUCKET/bangonit/$DIRNAME/" \\
+      #             --endpoint-url https://s3.us-east-1.amazonaws.com --no-progress
+      #           aws s3api list-objects-v2 --bucket MY-BUCKET --prefix "bangonit/$DIRNAME/" \\
+      #             --endpoint-url https://s3.us-east-1.amazonaws.com --query 'Contents[].Key' --output text | tr '\\t' '\\n' | while read -r key; do
+      #             aws s3api put-object-acl --bucket MY-BUCKET --key "$key" --acl public-read \\
+      #               --endpoint-url https://s3.us-east-1.amazonaws.com
+      #           done
+      #         fi
+      #       done
+      #     fi
+
+      - name: Comment test results
+        if: always()
+        run: |
+          ${commentScript}
+
+          if [ "\${{ github.event_name }}" = "pull_request" ] && [ -n "\${{ steps.start-comment.outputs.comment_id }}" ]; then
+            printf "%b" "$BODY" | gh api repos/\${{ github.repository }}/issues/comments/\${{ steps.start-comment.outputs.comment_id }} \\
+              --method PATCH --field "body=@-"
+          elif [ "\${{ github.event_name }}" = "pull_request" ]; then
+            printf "%b" "$BODY" | gh pr comment \${{ github.event.pull_request.number }} \\
+              --repo \${{ github.repository }} --body-file -
+          else
+            printf "%b" "$BODY" | gh api repos/\${{ github.repository }}/commits/\${{ github.sha }}/comments \\
+              --method POST --field "body=@-"
+          fi
+        env:
+          GH_TOKEN: \${{ github.token }}
 
       - name: Upload test results
         if: always()
@@ -507,30 +528,82 @@ ${stepsYaml}
         with:
           name: bangonit-smoke-results
           path: |
-            bangonit-output.json
+            \${{ github.workspace }}/bangonit-output.json
             recordings/
           if-no-files-found: ignore
 `;
-        const fullWorkflow = `name: "Bang On It! Full Tests"
+        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 ${fullUtcHour} * * *'
+    - cron: '0 23 * * *'  # EDIT: daily at 6 PM US/Eastern (23:00 UTC)
   workflow_dispatch:
 
+permissions:
+  contents: write
+
 jobs:
   full:
-    runs-on: ${baseImage}
-    timeout-minutes: ${timeoutMinutes * 3}
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
     env:
       ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
-${stepsYaml}
+      # 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 ${timeout} \\
-            --output bangonit-output.json --record
+            --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: |
+      #     ...
+
+      - name: Comment test results on commit
+        if: always()
+        run: |
+          ${commentScript}
+
+          printf "%b" "$BODY" | gh api repos/\${{ github.repository }}/commits/\${{ github.sha }}/comments \\
+            --method POST --field "body=@-"
+        env:
+          GH_TOKEN: \${{ github.token }}
 
       - name: Upload test results
         if: always()
@@ -538,7 +611,7 @@ ${stepsYaml}
         with:
           name: bangonit-full-results
           path: |
-            bangonit-output.json
+            \${{ github.workspace }}/bangonit-output.json
             recordings/
           if-no-files-found: ignore
 `;
@@ -550,10 +623,11 @@ ${stepsYaml}
         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}Required GitHub secret:${c.reset}`);
-        console.log(`  ${c.dim}  ANTHROPIC_API_KEY${c.reset} — your Anthropic API key`);
-        console.log(`\n  ${c.dim}Smoke tests run on every push/PR.${c.reset}`);
-        console.log(`  ${c.dim}Full tests run all test plans daily at 6pm ${tz} (${fullUtcHour}:00 UTC).${c.reset}`);
+        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("");
@@ -570,15 +644,22 @@ async function run(argv, config) {
     const recordingsDir = config.recordings_dir
         ? path.resolve(process.cwd(), config.recordings_dir)
         : path.join(process.cwd(), "recordings");
-    // Validate test plan files exist before launching anything
+    // 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 = [...argv.files];
+    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);
@@ -604,13 +685,14 @@ async function run(argv, config) {
         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 || null,
+        output: argv.output ? path.resolve(process.cwd(), argv.output) : null,
         plan: argv.plan || null,
-        prompt: argv.prompt || null,
+        prompt: argv.additionalSystemPrompt || null,
         concurrency: argv.concurrency ?? 1,
         timeout: argv.timeout ?? 0,
         cwd: process.cwd(),
@@ -656,7 +738,7 @@ async function run(argv, config) {
     // Save terminal state before Electron (which inherits stdin) can modify it.
     // stty is not available on Windows.
     let savedTtyState = null;
-    if (process.platform !== "win32") {
+    if (process.platform !== "win32" && process.stdin.isTTY) {
         try {
             savedTtyState = (0, child_process_1.execSync)("stty -g", { stdio: ["inherit", "pipe", "ignore"] })
                 .toString()
@@ -738,33 +820,7 @@ async function run(argv, config) {
     const electronLog = fs.createWriteStream(path.join(LOGS_DIR, "electron.log"));
     electronProc.stderr.pipe(electronLog);
     electronProc.stderr.pipe(process.stderr, { end: false });
-    electronProc.on("exit", async (code) => {
-        // Upload recordings to S3 if configured
-        if (config.s3?.bucket && argv.record) {
-            if (fs.existsSync(recordingsDir)) {
-                const dirs = fs
-                    .readdirSync(recordingsDir)
-                    .filter((d) => fs.existsSync(path.join(recordingsDir, d, "index.html")));
-                const s3Prefix = config.s3.prefix || "bangonit";
-                for (const dir of dirs) {
-                    const localPath = path.join(recordingsDir, dir);
-                    try {
-                        const url = await uploadToS3(localPath, {
-                            bucket: config.s3.bucket,
-                            prefix: `${s3Prefix}/${dir}`,
-                            region: config.s3.region,
-                            endpoint: config.s3.endpoint,
-                            accessKey: config.s3.access_key,
-                            secretKey: config.s3.secret_key,
-                        });
-                        console.log(`\n${c.green}Recording:${c.reset} ${c.cyan}${url}${c.reset}`);
-                    }
-                    catch (err) {
-                        console.error(`\n${c.red}Failed to upload recording:${c.reset} ${err.message}`);
-                    }
-                }
-            }
-        }
+    electronProc.on("exit", (code) => {
         cleanup();
         process.exit(code ?? 1);
     });
@@ -782,7 +838,10 @@ const ciDefaults = is_ci_1.default ? { headless: true, exit: true } : {};
     .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("prompt", { type: "string", describe: "Additional instructions appended to test plan" })
+    .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", {
@@ -794,6 +853,11 @@ const ciDefaults = is_ci_1.default ? { headless: true, exit: true } : {};
     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" })
@@ -805,11 +869,12 @@ const ciDefaults = is_ci_1.default ? { headless: true, exit: true } : {};
         files: argv.files,
         filter: argv.filter,
         plan: argv.plan,
-        prompt: argv.prompt,
+        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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bangonit",
-  "version": "0.5.0",
+  "version": "0.5.4",
   "description": "AI-powered E2E testing tool",
   "bin": {
     "bangonit": "bin/src/cli/bangonit.js",
@@ -59,10 +59,10 @@
   },
   "dependencies": {
     "@iarna/toml": "^2.2.5",
+    "diff": "^8.0.3",
     "dotenv": "^17.3.1",
     "electron": "^40.8.0",
     "is-ci": "^4.1.0",
-    "minio": "^8.0.7",
     "yargs": "^18.0.0",
     "zod": "^3.25.0"
   },