@bugmole/cli 0.4.0

package/scripts/bugmole.test.ts

@@ -0,0 +1,344 @@
+import { strict as assert } from "node:assert";
+import { fileURLToPath } from "node:url";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { describe, it } from "node:test";
+import {
+  buildDashboardHandoffUrl,
+  parseArgs,
+  printHelp,
+  resolveDashboardOrigin,
+  resolveDashboardUrl,
+  resolveDeviceId,
+  resolveLocalRegistryEnabled,
+  resolveLocalRegistryPort,
+  resolveMode,
+  runModeExitCode,
+  shouldOpenServeBrowser,
+} from "./bugmole.js";
+import os from "node:os";
+import path from "node:path";
+import { runInitWizard, validateStorageProvider } from "../src/runtime/init-wizard.js";
+
+describe("Bugmole CLI contract", () => {
+  it("starts MCP for the canonical --mcp flag", () => {
+    assert.equal(resolveMode(parseArgs(["node", "bugmole", "--mcp"])), "mcp");
+  });
+
+  it("keeps --mode mcp compatible", () => {
+    assert.equal(resolveMode(parseArgs(["node", "bugmole", "--mode", "mcp"])), "mcp");
+  });
+
+  it("accepts the init command and --init flag", () => {
+    assert.equal(resolveMode(parseArgs(["node", "bugmole", "--init"])), "init");
+    assert.equal(resolveMode(parseArgs(["node", "bugmole", "init"])), "init");
+  });
+
+  it("accepts the local artifacts serve command", () => {
+    assert.equal(resolveMode(parseArgs(["node", "bugmole", "artifacts", "serve"])), "artifacts");
+    assert.equal(resolveMode(parseArgs(["node", "bugmole", "serve"])), "serve");
+    assert.equal(resolveMode(parseArgs(["node", "bugmole", "gateway"])), "gateway");
+    assert.equal(resolveMode(parseArgs(["node", "bugmole", "reset"])), "reset");
+  });
+
+  it("accepts the serve no-open flag", () => {
+    const args = parseArgs(["node", "bugmole", "serve", "--no-open"]);
+    assert.equal(args.noopen, true);
+    assert.equal(shouldOpenServeBrowser(args), false);
+    assert.equal(shouldOpenServeBrowser(parseArgs(["node", "bugmole", "serve"]), {}, "darwin"), true);
+  });
+
+  it("does not open a browser for serve on a headless machine", () => {
+    const serve = parseArgs(["node", "bugmole", "serve"]);
+    assert.equal(shouldOpenServeBrowser(serve, {}, "linux"), false);
+    assert.equal(shouldOpenServeBrowser(serve, { DISPLAY: ":0" }, "linux"), true);
+    assert.equal(shouldOpenServeBrowser(serve, { CI: "true" }, "darwin"), false);
+    assert.equal(shouldOpenServeBrowser(serve, { BUGMOLE_HEADLESS: "true" }, "darwin"), false);
+  });
+
+  it("fails the process when --mode run reports anything but success", () => {
+    assert.equal(runModeExitCode("run", { status: "success" }), 0);
+    assert.equal(runModeExitCode("run", { status: "partial" }), 1);
+    assert.equal(runModeExitCode("run", { status: "error" }), 1);
+    assert.equal(runModeExitCode("run", undefined), 1);
+  });
+
+  it("leaves other modes' exit code alone regardless of their result", () => {
+    assert.equal(runModeExitCode("explore", { status: "partial" }), 0);
+    assert.equal(runModeExitCode("report", undefined), 0);
+  });
+
+  it("accepts a dashboard URL override for serve handoffs", () => {
+    const args = parseArgs([
+      "node",
+      "bugmole",
+      "serve",
+      "--dashboard-url",
+      "http://localhost:3020/dashboard?mode=dev",
+    ]);
+    const previousUrl = process.env.BUGMOLE_DASHBOARD_URL;
+    process.env.BUGMOLE_DASHBOARD_URL = "https://example.invalid";
+    try {
+      assert.equal(resolveDashboardUrl(args), "http://localhost:3020/dashboard?mode=dev");
+      const handoff = new URL(
+        buildDashboardHandoffUrl(
+          resolveDashboardUrl(args),
+          "project/demo",
+          new URLSearchParams({
+            "local-artifact-project": "project/demo",
+            "local-artifact-origin": "http://127.0.0.1:3190",
+            "local-artifact-token": "capability",
+          }),
+        ),
+      );
+      assert.equal(handoff.searchParams.get("mode"), "dev");
+      assert.equal(handoff.searchParams.get("project"), "project/demo");
+      assert.equal(
+        new URLSearchParams(handoff.hash.slice(1)).get("local-artifact-token"),
+        "capability",
+      );
+    } finally {
+      if (previousUrl === undefined) delete process.env.BUGMOLE_DASHBOARD_URL;
+      else process.env.BUGMOLE_DASHBOARD_URL = previousUrl;
+    }
+  });
+
+  it("defaults the bridge's CORS allowlist to the resolved dashboard URL's origin", () => {
+    // Reproduces a real bug caught by actually running `bugmole serve` against
+    // a local dashboard: --dashboard-url changed the printed handoff link,
+    // but the bridge's CORS allowlist silently stayed the production origin
+    // and every request from the local dashboard was rejected.
+    const args = parseArgs(["node", "bugmole", "serve", "--dashboard-url", "http://localhost:3020"]);
+    const dashboardUrl = resolveDashboardUrl(args);
+    assert.equal(resolveDashboardOrigin(args, dashboardUrl), "http://localhost:3020");
+  });
+
+  it("keeps an explicit --dashboard-origin as an override", () => {
+    const args = parseArgs([
+      "node",
+      "bugmole",
+      "serve",
+      "--dashboard-url",
+      "http://localhost:3020",
+      "--dashboard-origin",
+      "https://proxy.example.invalid",
+    ]);
+    const dashboardUrl = resolveDashboardUrl(args);
+    assert.equal(resolveDashboardOrigin(args, dashboardUrl), "https://proxy.example.invalid");
+  });
+
+  it("falls back to the production origin when neither is configured", () => {
+    const previousUrl = process.env.BUGMOLE_DASHBOARD_URL;
+    delete process.env.BUGMOLE_DASHBOARD_URL;
+    try {
+      const args = parseArgs(["node", "bugmole", "serve"]);
+      const dashboardUrl = resolveDashboardUrl(args);
+      assert.equal(resolveDashboardOrigin(args, dashboardUrl), "https://app.bugmole.com");
+    } finally {
+      if (previousUrl === undefined) delete process.env.BUGMOLE_DASHBOARD_URL;
+      else process.env.BUGMOLE_DASHBOARD_URL = previousUrl;
+    }
+  });
+
+  it("documents the dashboard URL option in help", () => {
+    const output: string[] = [];
+    const originalLog = console.log;
+    console.log = (message?: unknown) => output.push(String(message ?? ""));
+    try {
+      printHelp();
+    } finally {
+      console.log = originalLog;
+    }
+    assert.match(output.join("\n"), /--dashboard-url <url>/);
+    assert.match(output.join("\n"), /BUGMOLE_DASHBOARD_URL/);
+    assert.match(output.join("\n"), /gateway.*Multiplex project serve workers/s);
+  });
+
+  it("validates supported storage providers", () => {
+    assert.equal(validateStorageProvider("r2"), "r2");
+    assert.throws(() => validateStorageProvider("azure"), /Unsupported storage provider/);
+  });
+
+  it("writes safe defaults in non-interactive mode without stdin", async () => {
+    const cwd = await mkdtemp(path.join(os.tmpdir(), "bugmole-init-"));
+    try {
+      const result = await runInitWizard({ cwd, nonInteractive: true });
+      const config = await readFile(path.join(cwd, result.configPath), "utf8");
+      const env = await readFile(path.join(cwd, result.envPath), "utf8");
+      assert.match(config, /provider: local/);
+      assert.match(config, /artifacts_dir: \.\/qa\/bugmole-runs/);
+      assert.match(env, /BUGMOLE_STORAGE_PROVIDER=local/);
+      assert.doesNotMatch(env, /ACCESS_KEY|SECRET_ACCESS_KEY|CREDENTIALS_JSON/);
+    } finally {
+      await rm(cwd, { recursive: true, force: true });
+    }
+  });
+
+  it("persists the remembered Aegis email without writing credentials", async () => {
+    const cwd = await mkdtemp(path.join(os.tmpdir(), "bugmole-init-email-"));
+    const previousEmail = process.env.BUGMOLE_AEGIS_EMAIL;
+    process.env.BUGMOLE_AEGIS_EMAIL = "tester@example.com";
+    try {
+      const result = await runInitWizard({ cwd, nonInteractive: true });
+      const env = await readFile(path.join(cwd, result.envPath), "utf8");
+      assert.match(env, /BUGMOLE_AEGIS_EMAIL="tester@example\.com"/);
+      assert.doesNotMatch(env, /BUGMOLE_API_KEY=/);
+    } finally {
+      if (previousEmail === undefined) delete process.env.BUGMOLE_AEGIS_EMAIL;
+      else process.env.BUGMOLE_AEGIS_EMAIL = previousEmail;
+      await rm(cwd, { recursive: true, force: true });
+    }
+  });
+
+  it("accepts config alongside a boolean MCP flag", () => {
+    assert.deepEqual(parseArgs(["node", "bugmole", "--mcp", "--config", "custom.yaml"]), {
+      mcp: true,
+      config: "custom.yaml",
+    });
+  });
+
+  it("keeps the local registry stub off by default, matching real-registry serve behavior", () => {
+    const previous = process.env.BUGMOLE_LOCAL_REGISTRY;
+    delete process.env.BUGMOLE_LOCAL_REGISTRY;
+    try {
+      assert.equal(resolveLocalRegistryEnabled(parseArgs(["node", "bugmole", "serve"])), false);
+    } finally {
+      if (previous === undefined) delete process.env.BUGMOLE_LOCAL_REGISTRY;
+      else process.env.BUGMOLE_LOCAL_REGISTRY = previous;
+    }
+  });
+
+  it("enables the local registry stub via --local-registry or BUGMOLE_LOCAL_REGISTRY", () => {
+    assert.equal(
+      resolveLocalRegistryEnabled(parseArgs(["node", "bugmole", "serve", "--local-registry"])),
+      true,
+    );
+    const previous = process.env.BUGMOLE_LOCAL_REGISTRY;
+    process.env.BUGMOLE_LOCAL_REGISTRY = "true";
+    try {
+      assert.equal(resolveLocalRegistryEnabled(parseArgs(["node", "bugmole", "serve"])), true);
+    } finally {
+      if (previous === undefined) delete process.env.BUGMOLE_LOCAL_REGISTRY;
+      else process.env.BUGMOLE_LOCAL_REGISTRY = previous;
+    }
+  });
+
+  it("an explicit --local-registry=false overrides BUGMOLE_LOCAL_REGISTRY=true", () => {
+    const previous = process.env.BUGMOLE_LOCAL_REGISTRY;
+    process.env.BUGMOLE_LOCAL_REGISTRY = "true";
+    try {
+      assert.equal(
+        resolveLocalRegistryEnabled(parseArgs(["node", "bugmole", "serve", "--local-registry", "false"])),
+        false,
+      );
+    } finally {
+      if (previous === undefined) delete process.env.BUGMOLE_LOCAL_REGISTRY;
+      else process.env.BUGMOLE_LOCAL_REGISTRY = previous;
+    }
+  });
+
+  it("resolves an explicit local registry port from either the flag or the env var", () => {
+    assert.equal(
+      resolveLocalRegistryPort(parseArgs(["node", "bugmole", "serve", "--local-registry-port", "4190"])),
+      4190,
+    );
+    const previous = process.env.BUGMOLE_LOCAL_REGISTRY_PORT;
+    process.env.BUGMOLE_LOCAL_REGISTRY_PORT = "4191";
+    try {
+      assert.equal(resolveLocalRegistryPort(parseArgs(["node", "bugmole", "serve"])), 4191);
+    } finally {
+      if (previous === undefined) delete process.env.BUGMOLE_LOCAL_REGISTRY_PORT;
+      else process.env.BUGMOLE_LOCAL_REGISTRY_PORT = previous;
+    }
+  });
+
+  it("defaults the local registry port to a fixed, fetch-spec-safe port so .env.local never goes stale", () => {
+    // A fixed default (not a random ephemeral port, unlike the artifact
+    // bridge) so a dashboard .env.local pointing BUGMOLE_REGISTRY_URL here
+    // keeps working across `bugmole serve` restarts. Regression coverage for a
+    // real bug: an earlier default of 4190 is on the Fetch spec's forbidden
+    // port list (reserved for ManageSieve) — every fetch to it fails with
+    // "bad port" before even attempting a connection.
+    const previous = process.env.BUGMOLE_LOCAL_REGISTRY_PORT;
+    delete process.env.BUGMOLE_LOCAL_REGISTRY_PORT;
+    try {
+      const port = resolveLocalRegistryPort(parseArgs(["node", "bugmole", "serve", "--local-registry"]));
+      assert.equal(port, 4600);
+      const forbiddenPorts = new Set([
+        1, 7, 9, 11, 13, 15, 17, 19, 20, 21, 22, 23, 25, 37, 42, 43, 53, 69, 77, 79, 87, 95, 101, 102, 103,
+        104, 109, 110, 111, 113, 115, 117, 119, 123, 135, 137, 139, 143, 161, 179, 389, 427, 465, 512, 513,
+        514, 515, 526, 530, 531, 532, 540, 548, 554, 556, 563, 587, 601, 636, 989, 990, 993, 995, 1719, 1720,
+        1723, 2049, 3659, 4045, 4190, 5060, 5061, 6000, 6566, 6665, 6666, 6667, 6668, 6669, 6697, 10080,
+      ]);
+      assert.equal(forbiddenPorts.has(port), false);
+    } finally {
+      if (previous === undefined) delete process.env.BUGMOLE_LOCAL_REGISTRY_PORT;
+      else process.env.BUGMOLE_LOCAL_REGISTRY_PORT = previous;
+    }
+  });
+
+  it("publishes both bugmole and bm commands", async () => {
+    const packageJson = JSON.parse(
+      // A path string, not a URL: @types/node 26 types PathLike with
+      // node:url's URL while the global URL is the web-standard one, and the
+      // two are no longer interchangeable.
+      await readFile(fileURLToPath(new URL("../package.json", import.meta.url).href), "utf8"),
+    ) as { name: string; bin: Record<string, string> };
+
+    assert.equal(packageJson.name, "@bugmole/cli");
+    assert.equal(packageJson.bin.bugmole, packageJson.bin.bm);
+    assert.equal(packageJson.bin.bugmole, "scripts/bugmole.cjs");
+  });
+
+  it("generates a device id on first use and reuses the same one afterward", async () => {
+    const stateDir = await mkdtemp(path.join(os.tmpdir(), "bugmole-device-id-"));
+    try {
+      const first = resolveDeviceId({ stateDir });
+      const second = resolveDeviceId({ stateDir });
+      assert.equal(first, second);
+      assert.match(first, /^[a-z0-9][a-z0-9-]{0,62}$/);
+    } finally {
+      await rm(stateDir, { recursive: true, force: true });
+    }
+  });
+
+  it("gives two machines (two state dirs) two different device ids", async () => {
+    const stateDirA = await mkdtemp(path.join(os.tmpdir(), "bugmole-device-id-a-"));
+    const stateDirB = await mkdtemp(path.join(os.tmpdir(), "bugmole-device-id-b-"));
+    try {
+      assert.notEqual(resolveDeviceId({ stateDir: stateDirA }), resolveDeviceId({ stateDir: stateDirB }));
+    } finally {
+      await rm(stateDirA, { recursive: true, force: true });
+      await rm(stateDirB, { recursive: true, force: true });
+    }
+  });
+
+  it("never derives a device id from the project id, so two projects on one machine still share one binding", async () => {
+    const stateDir = await mkdtemp(path.join(os.tmpdir(), "bugmole-device-id-shared-"));
+    try {
+      // Regression test: deviceId used to be cfg.project?.id, so every
+      // checkout of this same repo (or any project named the same thing)
+      // produced the identical literal string. Aegis permanently binds a
+      // deviceId to one tenant on first claim, so that collided across
+      // teammates and even across a single person's second `bugmole serve` run.
+      const id = resolveDeviceId({ stateDir });
+      assert.notEqual(id, "bugmole");
+      assert.notEqual(id, "default");
+    } finally {
+      await rm(stateDir, { recursive: true, force: true });
+    }
+  });
+
+  it("respects an explicit BUGMOLE_DEVICE_ID override without touching the state dir", async () => {
+    const stateDir = await mkdtemp(path.join(os.tmpdir(), "bugmole-device-id-override-"));
+    const previous = process.env.BUGMOLE_DEVICE_ID;
+    process.env.BUGMOLE_DEVICE_ID = "operator-chosen-id";
+    try {
+      assert.equal(resolveDeviceId({ stateDir }), "operator-chosen-id");
+      await assert.rejects(readFile(path.join(stateDir, "device-id"), "utf8"));
+    } finally {
+      if (previous === undefined) delete process.env.BUGMOLE_DEVICE_ID;
+      else process.env.BUGMOLE_DEVICE_ID = previous;
+      await rm(stateDir, { recursive: true, force: true });
+    }
+  });
+});