bangonit 0.5.4 → 0.5.7

package/bin/src/cli/bangonit.js

@@ -44,6 +44,7 @@ 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"));
@@ -362,47 +363,6 @@ Create new Bang On It! test plan files.
     console.log("");
     const setupCi = await p.askChoice("Set up GitHub Actions?", ["y", "n"], "y");
     if (setupCi === "y") {
-        // 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.
 #
@@ -471,10 +431,7 @@ jobs:
       - 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"
+        run: boi ci comment-starting --repo \${{ github.repository }} --pr \${{ github.event.pull_request.number }} >> "$GITHUB_OUTPUT"
         env:
           GH_TOKEN: \${{ github.token }}
 
@@ -488,37 +445,26 @@ jobs:
       # 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
+      #   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: |
-          ${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=@-"
+          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 }}
 
@@ -592,16 +538,20 @@ jobs:
       # EDIT: Uncomment to upload recordings to S3 (see bangonit-smoke.yml for full example)
       # - name: Upload recordings to S3
       #   if: always()
-      #   run: |
-      #     ...
+      #   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: |
-          ${commentScript}
-
-          printf "%b" "$BODY" | gh api repos/\${{ github.repository }}/commits/\${{ github.sha }}/comments \\
-            --method POST --field "body=@-"
+        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 }}
 
@@ -825,6 +775,153 @@ async function run(argv, config) {
         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))
@@ -882,6 +979,51 @@ const ciDefaults = is_ci_1.default ? { headless: true, exit: true } : {};
         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'")
@@ -890,4 +1032,4 @@ const ciDefaults = is_ci_1.default ? { headless: true, exit: true } : {};
     .strict()
     .help()
     .alias("h", "help")
-    .parse();
+    .parseAsync();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bangonit",
-  "version": "0.5.4",
+  "version": "0.5.7",
   "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"
   },

package/app/webapp/.next/standalone/app/webapp/.next/static/chunks/app/layout-57acb80d8da0067a.js

@@ -1 +0,0 @@
-(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[185],{4143: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=4143)}),_N_E=n.O()}]);

package/app/webapp/.next/static/chunks/app/layout-57acb80d8da0067a.js

@@ -1 +0,0 @@
-(self.webpackChunk_N_E=self.webpackChunk_N_E||[]).push([[185],{4143: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=4143)}),_N_E=n.O()}]);