bangonit 0.2.1 → 0.3.0

package/app/webapp/.next/types/app/api/screenshot/route.ts

@@ -1,4 +1,4 @@
-// File: /home/floydophone/repos/domyjob/app/webapp/src/app/api/screenshot/route.ts
+// File: /Users/pete/repos/growthgirl/app/webapp/src/app/api/screenshot/route.ts
 import * as entry from '../../../../../src/app/api/screenshot/route.js'
 import type { NextRequest } from 'next/server.js'
 

package/app/webapp/.next/types/app/app/page.ts

@@ -1,4 +1,4 @@
-// File: /home/floydophone/repos/domyjob/app/webapp/src/app/app/page.tsx
+// File: /Users/pete/repos/growthgirl/app/webapp/src/app/app/page.tsx
 import * as entry from '../../../../src/app/app/page.js'
 import type { ResolvingMetadata, ResolvingViewport } from 'next/dist/lib/metadata/types/metadata-interface.js'
 

package/app/webapp/.next/types/app/layout.ts

@@ -1,4 +1,4 @@
-// File: /home/floydophone/repos/domyjob/app/webapp/src/app/layout.tsx
+// File: /Users/pete/repos/growthgirl/app/webapp/src/app/layout.tsx
 import * as entry from '../../../src/app/layout.js'
 import type { ResolvingMetadata, ResolvingViewport } from 'next/dist/lib/metadata/types/metadata-interface.js'
 

package/app/webapp/.next/types/app/page.ts

@@ -1,4 +1,4 @@
-// File: /home/floydophone/repos/domyjob/app/webapp/src/app/page.tsx
+// File: /Users/pete/repos/growthgirl/app/webapp/src/app/page.tsx
 import * as entry from '../../../src/app/page.js'
 import type { ResolvingMetadata, ResolvingViewport } from 'next/dist/lib/metadata/types/metadata-interface.js'
 

package/bin/bangonit.js

@@ -34,6 +34,9 @@ var __importStar = (this && this.__importStar) || (function () {
         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"));
@@ -42,6 +45,9 @@ 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 ROOT = path.resolve(__dirname, "..");
 const WEBAPP_DIR = path.join(ROOT, "app", "webapp");
 const DESKTOP_DIR = path.join(ROOT, "app", "desktopapp");
@@ -192,12 +198,10 @@ function createS3Client(opts) {
     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) {
-        // Custom endpoint (DigitalOcean Spaces, MinIO, etc.)
         const useSSL = !opts.endpoint.startsWith("http://");
         const endPoint = opts.endpoint.replace(/^https?:\/\//, "");
         return new Minio.Client({ endPoint, useSSL, accessKey, secretKey, region });
     }
-    // Default: AWS S3
     return new Minio.Client({
         endPoint: "s3.amazonaws.com",
         useSSL: true,
@@ -224,7 +228,6 @@ async function uploadToS3(localDir, 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) {
-        // Custom endpoint URL
         const proto = opts.endpoint.startsWith("http://") ? "http" : "https";
         const host = opts.endpoint.replace(/^https?:\/\//, "");
         return `${proto}://${opts.bucket}.${host}/${opts.prefix}/index.html`;
@@ -269,6 +272,7 @@ async function initProject() {
     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 = "";
@@ -280,6 +284,7 @@ async function initProject() {
     }
     p.close();
     let toml = `testplans = "${testplans}"\n`;
+    toml += `recordings_dir = "${recordingsDir}"\n`;
     if (apiKey) {
         toml += `anthropic_api_key = "${apiKey}"\n`;
     }
@@ -288,15 +293,12 @@ async function initProject() {
     }
     if (s3Bucket) {
         toml += `\n[s3]\nbucket = "${s3Bucket}"\n`;
-        if (s3Endpoint) {
+        if (s3Endpoint)
             toml += `endpoint = "${s3Endpoint}"\n`;
-        }
-        if (s3Region && s3Region !== "us-east-1") {
+        if (s3Region && s3Region !== "us-east-1")
             toml += `region = "${s3Region}"\n`;
-        }
-        if (s3Prefix && s3Prefix !== "bangonit") {
+        if (s3Prefix && s3Prefix !== "bangonit")
             toml += `prefix = "${s3Prefix}"\n`;
-        }
         toml += `# access_key = "\${AWS_ACCESS_KEY_ID}"\n`;
         toml += `# secret_key = "\${AWS_SECRET_ACCESS_KEY}"\n`;
     }
@@ -322,7 +324,6 @@ async function initCi() {
     const waitUrl = await p.ask("URL to wait for before testing", "http://localhost:3000");
     const testDir = await p.ask("Test plan directory", "testplans");
     const triggerInput = await p.askChoice("Trigger on", ["pr", "push", "both"], "both");
-    const s3Bucket = await p.ask("S3 bucket for recordings (empty to skip)", "");
     const timeout = await p.ask("Test timeout in seconds", "300");
     p.close();
     const trigger = triggerInput === "pr" ? "pull_request" :
@@ -344,94 +345,6 @@ async function initCi() {
   push:
     branches: [main, master]`;
     }
-    let s3Steps = "";
-    let s3Env = "";
-    let recordFlag = "";
-    if (s3Bucket) {
-        recordFlag = " --record";
-        s3Env = `
-      AWS_ACCESS_KEY_ID: \${{ secrets.AWS_ACCESS_KEY_ID }}
-      AWS_SECRET_ACCESS_KEY: \${{ secrets.AWS_SECRET_ACCESS_KEY }}
-      AWS_REGION: \${{ secrets.AWS_REGION || 'us-east-1' }}`;
-        s3Steps = `
-      - name: Upload recordings to S3
-        if: always()
-        run: |
-          if [ -d recordings ]; then
-            COMMIT_SHA=\${{ github.sha }}
-            RUN_ID=\${{ github.run_id }}
-            for dir in recordings/*/; do
-              [ -f "\$dir/index.html" ] || continue
-              DIRNAME=\$(basename "\$dir")
-              aws s3 cp "\$dir" "s3://${s3Bucket}/bangonit/\$COMMIT_SHA/\$DIRNAME/" --recursive --acl public-read --quiet
-            done
-          fi
-        env:
-          AWS_ACCESS_KEY_ID: \${{ secrets.AWS_ACCESS_KEY_ID }}
-          AWS_SECRET_ACCESS_KEY: \${{ secrets.AWS_SECRET_ACCESS_KEY }}
-          AWS_REGION: \${{ secrets.AWS_REGION || 'us-east-1' }}
-
-      - name: Comment on PR/commit with results
-        if: always()
-        uses: actions/github-script@v7
-        with:
-          script: |
-            const fs = require('fs');
-            const bucket = '${s3Bucket}';
-            const sha = context.sha;
-            const region = process.env.AWS_REGION || 'us-east-1';
-            const baseUrl = region === 'us-east-1'
-              ? \`https://\${bucket}.s3.amazonaws.com\`
-              : \`https://\${bucket}.s3.\${region}.amazonaws.com\`;
-
-            // Read test output
-            let output = '';
-            try { output = fs.readFileSync('bangonit-output.json', 'utf-8'); } catch {}
-            const results = output ? JSON.parse(output) : null;
-
-            // Build recording links
-            let recordingLinks = '';
-            try {
-              const dirs = fs.readdirSync('recordings');
-              for (const dir of dirs) {
-                if (fs.existsSync(\`recordings/\${dir}/index.html\`)) {
-                  const url = \`\${baseUrl}/bangonit/\${sha}/\${dir}/index.html\`;
-                  recordingLinks += \`- [\${dir}](\${url})\\n\`;
-                }
-              }
-            } catch {}
-
-            let body = '## Bang On It! Test Results\\n\\n';
-            if (results) {
-              const icon = results.status === 'pass' ? ':white_check_mark:' : ':x:';
-              body += \`\${icon} **\${results.status.toUpperCase()}**\\n\\n\`;
-              if (results.tests) {
-                for (const t of results.tests) {
-                  const ti = t.status === 'pass' ? ':white_check_mark:' : ':x:';
-                  body += \`\${ti} \${t.name} (\${(t.duration/1000).toFixed(1)}s)\\n\`;
-                }
-              }
-            }
-            if (recordingLinks) {
-              body += \`\\n### Recordings\\n\${recordingLinks}\`;
-            }
-
-            if (context.payload.pull_request) {
-              await github.rest.issues.createComment({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: context.payload.pull_request.number,
-                body
-              });
-            } else {
-              await github.rest.repos.createCommitComment({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                commit_sha: sha,
-                body
-              });
-            }`;
-    }
     const workflow = `name: Bang On It! Tests
 
 ${triggerYaml}
@@ -441,7 +354,7 @@ jobs:
     runs-on: ${baseImage}
     timeout-minutes: ${Math.ceil(parseInt(timeout) / 60) + 5}
     env:
-      ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}${s3Env}
+      ANTHROPIC_API_KEY: \${{ secrets.ANTHROPIC_API_KEY }}
 
     steps:
       - uses: actions/checkout@v4
@@ -472,8 +385,8 @@ jobs:
           xvfb-run --auto-servernum boi run ${testDir}/*.md \\
             --headless --exit \\
             --timeout ${timeout} \\
-            --output bangonit-output.json${recordFlag}
-${s3Steps}
+            --output bangonit-output.json --record
+
       - name: Upload test results
         if: always()
         uses: actions/upload-artifact@v4
@@ -491,15 +404,9 @@ ${s3Steps}
     console.log(`\n  ${c.green}Created${c.reset} ${path.relative(process.cwd(), outPath)}\n`);
     console.log(`  ${c.yellow}Required GitHub secrets:${c.reset}`);
     console.log(`  ${c.dim}  ANTHROPIC_API_KEY    ${c.reset}— your Anthropic API key`);
-    if (s3Bucket) {
-        console.log(`  ${c.dim}  AWS_ACCESS_KEY_ID    ${c.reset}— AWS credentials for S3 upload`);
-        console.log(`  ${c.dim}  AWS_SECRET_ACCESS_KEY${c.reset}`);
-        console.log(`  ${c.dim}  AWS_REGION           ${c.reset}— (optional, defaults to us-east-1)`);
-    }
     console.log("");
 }
-// --- run command ---
-async function run(args, config) {
+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) {
@@ -508,53 +415,48 @@ async function run(args, config) {
     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.");
     }
-    // Parse --s3-bucket and --filter from args (consumed here, not forwarded to Electron)
-    let s3Bucket = null;
-    let filter = null;
-    const electronArgs = [];
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === "--s3-bucket" && i + 1 < args.length) {
-            s3Bucket = args[++i];
-        }
-        else if ((args[i] === "--filter" || args[i] === "-t") && i + 1 < args.length) {
-            filter = args[++i];
-        }
-        else {
-            electronArgs.push(args[i]);
-        }
-    }
-    // Fall back to config for S3
-    if (!s3Bucket && config.s3?.bucket) {
-        s3Bucket = config.s3.bucket;
-    }
-    const s3Opts = {
-        region: config.s3?.region,
-        prefix: config.s3?.prefix || "bangonit",
-        endpoint: config.s3?.endpoint,
-        accessKey: config.s3?.access_key,
-        secretKey: config.s3?.secret_key,
-    };
-    // If --s3-bucket is set, ensure --record is also set
-    if (s3Bucket && !electronArgs.includes("--record")) {
-        electronArgs.push("--record");
-    }
-    // If no test plan files passed and not using --plan/--auto, discover from testplans dir
-    const hasFiles = electronArgs.some((a) => !a.startsWith("-"));
-    const hasPlan = electronArgs.includes("--plan");
-    const hasAuto = electronArgs.includes("--auto");
-    if (!hasFiles && !hasPlan && !hasAuto && config.testplans) {
+    const recordingsDir = config.recordings_dir
+        ? path.resolve(process.cwd(), config.recordings_dir)
+        : path.join(process.cwd(), "recordings");
+    // Discover test plans if no files/plan/auto specified
+    const files = [...argv.files];
+    if (files.length === 0 && !argv.plan && !argv.auto && config.testplans) {
         const testDirPath = path.resolve(process.cwd(), config.testplans);
-        const plans = findTestPlans(testDirPath, filter);
+        const plans = findTestPlans(testDirPath, argv.filter);
         if (plans.length > 0) {
-            electronArgs.unshift(...plans);
+            files.push(...plans);
         }
-        else if (filter) {
-            die(`No test plans matching "${filter}" found in ${config.testplans}/`);
+        else if (argv.filter) {
+            die(`No test plans matching "${argv.filter}" found in ${config.testplans}/`);
         }
     }
-    else if (!hasFiles && !hasPlan && !hasAuto && filter) {
+    else if (files.length === 0 && !argv.plan && !argv.auto && argv.filter) {
         die(`--filter requires a testplans directory configured in .bangonit/config.toml`);
     }
+    // Build args to forward to Electron
+    const electronArgs = [...files];
+    if (argv.plan)
+        electronArgs.push("--plan", argv.plan);
+    if (argv.auto)
+        electronArgs.push("--auto");
+    if (argv.prompt)
+        electronArgs.push("--prompt", argv.prompt);
+    if (argv.record)
+        electronArgs.push("--record", "--recordings-dir", recordingsDir);
+    if (argv.headless)
+        electronArgs.push("--headless");
+    if (argv.exit)
+        electronArgs.push("--exit");
+    if (argv.json)
+        electronArgs.push("--json");
+    if (argv.console)
+        electronArgs.push("--console");
+    if (argv.output)
+        electronArgs.push("--output", argv.output);
+    if (argv.concurrency != null)
+        electronArgs.push("--concurrency", String(argv.concurrency));
+    if (argv.timeout != null)
+        electronArgs.push("--timeout", String(argv.timeout));
     const PORT = await getFreePort();
     fs.mkdirSync(LOGS_DIR, { recursive: true });
     const nextDir = path.join(WEBAPP_DIR, ".next");
@@ -626,18 +528,20 @@ async function run(args, config) {
     });
     electronProc.on("exit", async (code) => {
         // Upload recordings to S3 if configured
-        if (s3Bucket) {
-            const recordingsDir = path.join(process.cwd(), "recordings");
+        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);
-                    const prefix = `${s3Opts.prefix}/${dir}`;
                     try {
                         const url = await uploadToS3(localPath, {
-                            bucket: s3Bucket,
-                            prefix,
-                            ...s3Opts,
+                            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}`);
                     }
@@ -648,72 +552,56 @@ async function run(args, config) {
             }
         }
         cleanup();
-        process.exit(code || 0);
+        process.exit(code ?? 1);
     });
 }
 // --- main ---
-async function main() {
-    const args = process.argv.slice(2);
-    // Extract --config before other parsing
-    let configPath = null;
-    const filteredArgs = [];
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === "--config" && i + 1 < args.length) {
-            configPath = args[++i];
-        }
-        else {
-            filteredArgs.push(args[i]);
-        }
-    }
-    if (filteredArgs.includes("--help") || filteredArgs.includes("-h")) {
-        console.log(`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
-
-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 to recordings/ directory
-  --s3-bucket <bucket>       Upload recordings to S3 (overrides config)
-  --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)
-  --help                     Show this help message
-
-Aliases: bangonit, bang-on-it, boi
-
-Examples:
-  boi run test.md                        Run a test plan file
-  boi run --plan "test login flow"       Run an inline test plan
-  boi run --auto                         Auto-discover from git state
-  boi run -t checkout                    Run test plans matching "checkout"
-  boi run                                Launch interactive UI
-  boi init                               Create .bangonit/config.toml
-  boi init-ci                            Set up GitHub Actions`);
-        process.exit(0);
-    }
-    // Route to subcommand
-    if (filteredArgs[0] === "init" && !filteredArgs[1]) {
-        await initProject();
-    }
-    else if (filteredArgs[0] === "init-ci") {
-        await initCi();
-    }
-    else {
-        // "run" command (explicit or implicit)
-        const config = loadConfig(configPath);
-        const runArgs = filteredArgs[0] === "run" ? filteredArgs.slice(1) : filteredArgs;
-        await run(runArgs, config);
-    }
-}
-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", "Create a .bangonit/config.toml config file", {}, () => { initProject(); })
+    .command("init-ci", "Generate a GitHub Actions workflow", {}, () => { initCi(); })
+    .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("auto", { type: "boolean", default: false, describe: "Auto-generate test plan from git state" })
+    .option("prompt", { type: "string", describe: "Additional instructions appended to test plan" })
+    .option("record", { type: "boolean", default: false, describe: "Record session replay" })
+    .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("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,
+        auto: argv.auto,
+        prompt: argv.prompt,
+        record: argv.record,
+        headless: argv.headless,
+        exit: argv.exit,
+        json: argv.json,
+        console: argv.console,
+        output: argv.output,
+        concurrency: argv.concurrency,
+        timeout: argv.timeout,
+    }, config);
+})
+    .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 --auto", "Auto-discover from git state")
+    .example("$0 run -t checkout", "Run test plans matching 'checkout'")
+    .example("$0 run", "Launch interactive UI")
+    .example("$0 init", "Create .bangonit/config.toml")
+    .example("$0 init-ci", "Set up GitHub Actions")
+    .strict()
+    .help()
+    .alias("h", "help")
+    .parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bangonit",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "AI-powered E2E testing tool",
   "bin": {
     "bangonit": "bin/bangonit.js",
@@ -49,6 +49,12 @@
   },
   "dependencies": {
     "@iarna/toml": "^2.2.5",
-    "minio": "^8.0.7"
+    "is-ci": "^4.1.0",
+    "minio": "^8.0.7",
+    "yargs": "^18.0.0"
+  },
+  "devDependencies": {
+    "@types/is-ci": "^3.0.4",
+    "@types/yargs": "^17.0.35"
   }
 }

package/app/webapp/.next/static/chunks/app/layout-40f50d9380154ecf.js

@@ -1 +0,0 @@
-(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[185],{5603:function(n,e,u){Promise.resolve().then(u.t.bind(u,2625,23))},2625:function(){}},function(n){n.O(0,[387,293,528,744],function(){return n(n.s=5603)}),_N_E=n.O()}]);

package/scripts/regen-replays.sh

@@ -1,46 +0,0 @@
-#!/usr/bin/env bash
-# Regenerate index.html for all existing recordings using the current replay bundle.
-# Usage: ./scripts/regen-replays.sh [recordings-dir]
-set -e
-
-cd "$(dirname "$0")/.."
-
-RECORDINGS_DIR="${1:-recordings}"
-REPLAY_JS="app/replay/dist/replay.js"
-REPLAY_CSS="app/replay/dist/replay.css"
-
-if [ ! -f "$REPLAY_JS" ] || [ ! -f "$REPLAY_CSS" ]; then
-  echo "Replay bundle not found. Building..."
-  cd app/replay && npx vite build && cd ../..
-fi
-
-count=0
-for dir in "$RECORDINGS_DIR"/*/; do
-  [ -f "$dir/data.json" ] || continue
-  python3 -c "
-import sys
-js = open('$REPLAY_JS').read()
-css = open('$REPLAY_CSS').read()
-data = open('${dir}data.json').read()
-html = '''<!DOCTYPE html>
-<html lang=\"en\">
-<head>
-  <meta charset=\"UTF-8\">
-  <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">
-  <title>Session Replay</title>
-  <style>''' + css + '''</style>
-</head>
-<body>
-  <div id=\"root\"></div>
-  <script>window.__REPLAY_DATA__ = ''' + data + ''';</script>
-  <script>''' + js + '''</script>
-</body>
-</html>'''
-with open('${dir}index.html', 'w') as f:
-    f.write(html)
-"
-  echo "  Regenerated ${dir}index.html"
-  count=$((count + 1))
-done
-
-echo "Done — $count recording(s) updated."