@bugmole/cli 0.4.0

package/src/registry-worker/features.ts

@@ -0,0 +1,20 @@
+// Loads the route and job modules added for plans, billing and integrations.
+// Each registers itself with routes/index.ts or jobs/index.ts on import.
+import "./org/routes.js";
+import "./billing/routes.js";
+import "./jobs/retention.js";
+import "./ai/routes.js";
+import "./runner/routes.js";
+import "./signup/routes.js";
+import "./billing/checkout-routes.js";
+import "./notifications/outbox.js";
+import "./notifications/alerts.js";
+import "./notifications/routes.js";
+import "./github/checks.js";
+import "./gitlab/checks.js";
+import "./personas/routes.js";
+import "./feedback/routes.js";
+import "./devices/routes.js";
+import "./domains/routes.js";
+import "./sso/routes.js";
+import "./mcp/routes.js";

package/src/registry-worker/feedback/feedback.test.ts

@@ -0,0 +1,230 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { generateKeyPairSync } from "node:crypto";
+import type { Env } from "../core.js";
+import { call, createTestEnv, seedProject } from "../testing/harness.js";
+import { drainOutbox } from "../notifications/outbox.js";
+import { cleanConsole, fingerprintOf, formatIssue, quietMentions, redactSecrets, redactUrl } from "./format.js";
+import { RATE_LIMIT_PER_HOUR } from "./routes.js";
+
+const privateKey = generateKeyPairSync("rsa", { modulusLength: 2048 }).privateKey.export({ type: "pkcs8", format: "pem" }).toString();
+const PNG = `data:image/png;base64,${Buffer.from("fake-png-bytes").toString("base64")}`;
+
+function fakeGithub() {
+  const state = { issues: [] as any[], comments: [] as Array<{ issue: number; body: string }>, labels: new Set<string>(), fail: 0 };
+  const doFetch = (async (input: RequestInfo | URL, init?: RequestInit) => {
+    const url = new URL(String(input));
+    const body = init?.body ? JSON.parse(String(init.body)) : null;
+    if (url.pathname.endsWith("/access_tokens")) return Response.json({ token: "ghs_x", expires_at: new Date(Date.now() + 3_600_000).toISOString() }, { status: 201 });
+    if (state.fail) return new Response("down", { status: state.fail });
+    const label = url.pathname.match(/\/labels\/([^/]+)$/);
+    if (label) return state.labels.has(decodeURIComponent(label[1])) ? Response.json({}) : new Response("", { status: 404 });
+    if (url.pathname.endsWith("/labels")) {
+      state.labels.add(body.name);
+      return Response.json(body, { status: 201 });
+    }
+    if (url.pathname.endsWith("/issues")) {
+      const number = state.issues.length + 1;
+      state.issues.push({ number, ...body });
+      return Response.json({ number, html_url: `https://github.com/theaiinc/bugmole/issues/${number}` }, { status: 201 });
+    }
+    const comment = url.pathname.match(/\/issues\/(\d+)\/comments$/);
+    if (comment) {
+      state.comments.push({ issue: Number(comment[1]), body: body.body });
+      return Response.json({ id: 1 }, { status: 201 });
+    }
+    return new Response("not found", { status: 404 });
+  }) as unknown as typeof fetch;
+  return { state, doFetch };
+}
+
+function feedbackEnv(gh: ReturnType<typeof fakeGithub>, extra: Record<string, unknown> = {}) {
+  return createTestEnv({
+    FEATURE_FEEDBACK: "on",
+    GITHUB_APP_ID: "1",
+    GITHUB_APP_PRIVATE_KEY: privateKey,
+    GITHUB_FETCH: gh.doFetch,
+    BUGMOLE_FEEDBACK_REPO: "theaiinc/bugmole",
+    BUGMOLE_FEEDBACK_INSTALLATION_ID: "5",
+    SECRETS_ENCRYPTION_KEY: "k",
+    REGISTRY_PUBLIC_URL: "https://registry.test",
+    DASHBOARD_URL: "https://dash.test",
+    PLATFORM_STAFF_IDS: "user_staff",
+    PLATFORM_STAFF_EMAILS: "staff@bugmole.test",
+    ...extra,
+  } as Partial<Env>);
+}
+
+const bug = (description: string, extra: Record<string, unknown> = {}) => ({
+  kind: "bug",
+  page: "https://dash.test/runs?project=shop&token=abc",
+  payload: {
+    description,
+    expectation: "It should save",
+    screenshot: PNG,
+    consoleLogs: [
+      { level: "log", message: "boot" },
+      { level: "error", message: "TypeError: x is undefined (Authorization: Bearer abcdefghijklmnop)" },
+    ],
+    networkLogs: [{ url: "https://registry.test/api/runs?key=bm_live_secret123456", duration: 42.4 }], // gitleaks:allow (fake value for the redaction test)
+    environment: { url: "https://dash.test/runs?secret=1", userAgent: "Mozilla/5.0", windowWidth: 1440, windowHeight: 900 },
+    ...extra,
+  },
+});
+
+test("secrets are scrubbed from logs, links and free text", () => {
+  assert.doesNotMatch(redactSecrets("Authorization: Bearer abc.def.ghi-123"), /abc\.def/);
+  assert.equal(redactSecrets("key bm_live_key_abc_1234567890 and xoxb-1234-5678-abcdefgh"), "key [redacted token] and [redacted token]");
+  assert.equal(redactSecrets("password=hunter22 token: 'abc123'"), "password=[redacted] token: '[redacted]'");
+  // nosemgrep: generic.secrets.security.detected-aws-access-key-id-value.detected-aws-access-key-id-value -- a fake key, so the redaction has something to catch.
+  assert.equal(redactSecrets("AKIAABCDEFGHIJKLMNOP"), "[redacted key]"); // gitleaks:allow (fake value for the redaction test)
+  assert.equal(redactUrl("https://dash.test/runs?token=abc#local-artifact-token=zzz"), "https://dash.test/runs?[redacted]");
+  assert.equal(cleanConsole([{ level: "error", message: "x".repeat(5000) }, { nope: true }])[0].message.length, 1000);
+  assert.equal(quietMentions("ping @octocat and me@example.com"), "ping @​octocat and me@example.com");
+});
+
+test("the same problem gets the same fingerprint, whatever the ids", async () => {
+  const a = await fingerprintOf("bug", "Run run_8f3a2c1d9e failed at step 3", "https://dash.test/runs/abcdef0123456789abcd", [{ level: "error", message: "Timeout 30000ms" }]);
+  const b = await fingerprintOf("bug", "run run_77aa99bb11 failed at step 4", "https://dash.test/runs/0123456789abcdef0123", [{ level: "error", message: "Timeout 45000ms" }]);
+  const c = await fingerprintOf("bug", "Something else broke", "https://dash.test/runs", []);
+  assert.equal(a, b);
+  assert.notEqual(a, c);
+});
+
+test("issue bodies carry context, fold logs away, and can't break out of their code blocks", () => {
+  const { title, body, labels } = formatIssue({
+    id: "fb_1", kind: "feedback", message: "Love it @everyone", rating: 4, category: "Speed", screenshotUrls: [],
+    console: [{ level: "log", message: "```\n## injected" }], network: [], fingerprint: "f", submittedAt: "now",
+    workspace: { id: "acme", name: "Acme", plan: "team" }, page: "https://dash.test/?x=1",
+  });
+  assert.equal(title, "[Feedback] ★★★★☆ Love it @​everyone");
+  assert.deepEqual(labels, ["feedback", "feedback"]);
+  assert.match(body, /Workspace:\*\* Acme \(`acme`, team plan\)/);
+  assert.match(body, /<details><summary>Console \(1\)<\/summary>/);
+  assert.match(body, /````\n\[log\] ```\n## injected\n````/);
+  assert.match(body, /Page:\*\* https:\/\/dash\.test\/\?\[redacted\]/);
+});
+
+test("a bug report is stored scrubbed, and filed once as a GitHub issue with a screenshot GitHub can load", async () => {
+  const gh = fakeGithub();
+  const { env, db, artifacts, workspaceId, projectId, owner } = await (async () => {
+    const setup = feedbackEnv(gh);
+    return { ...setup, ...(await seedProject(setup.env)) };
+  })();
+  const sent = await call(env, "POST", "/api/feedback", { as: owner, body: { ...bug("Saving the plan fails"), workspaceId, projectId } });
+  assert.equal(sent.status, 201, JSON.stringify(sent.json));
+  const id = sent.json.id;
+  const row = db.db.prepare("SELECT data_json AS data, page, screenshot_keys_json AS keys, plan FROM feedback_reports WHERE id = ?").get(id) as any;
+  assert.ok(!row.data.includes("abcdefghijklmnop"), "bearer token removed");
+  assert.ok(!row.data.includes("bm_live_secret"), "query string removed");
+  assert.equal(row.page, "https://dash.test/runs?[redacted]");
+  assert.equal(row.plan, "free");
+  assert.ok(artifacts.objects.has(`feedback/${id}/0`));
+
+  await drainOutbox(env);
+  assert.equal(gh.state.issues.length, 1);
+  const issue = gh.state.issues[0];
+  assert.deepEqual(issue.labels, ["feedback", "bug"]);
+  assert.deepEqual([...gh.state.labels].sort(), ["bug", "feedback"]);
+  assert.equal(issue.title, "[Bug] Saving the plan fails");
+  const image = issue.body.match(/!\[screenshot\]\((https:\/\/registry\.test[^)]+)\)/)?.[1];
+  assert.ok(image);
+  const fetched = await call(env, "GET", new URL(image).pathname + new URL(image).search);
+  assert.equal(fetched.status, 200);
+  assert.equal(fetched.headers.get("content-type"), "image/png");
+  const tampered = new URL(image);
+  tampered.searchParams.set("expires", String(Date.now() + 999_999_999));
+  assert.equal((await call(env, "GET", tampered.pathname + tampered.search)).status, 404);
+  assert.equal((await call(env, "GET", `/api/feedback/${id}/images/1${new URL(image).search}`)).status, 404);
+
+  const reports = await call(env, "GET", "/api/feedback/mine", { as: owner });
+  assert.equal(reports.json.reports[0].status, "open");
+  assert.equal(reports.json.reports[0].issueUrl, undefined, "reporters don't get the internal issue link");
+});
+
+test("the same problem again comments on the open issue; closing it tells every reporter", async () => {
+  const gh = fakeGithub();
+  const setup = feedbackEnv(gh);
+  const { owner, workspaceId } = await seedProject(setup.env);
+  const { env, email } = setup;
+  await call(env, "GET", "/api/workspaces", { as: owner, headers: { "x-aegis-email": "owner@acme.test", "x-aegis-email-verified": "true" } });
+  await call(env, "GET", "/api/workspaces", { as: "user_two", headers: { "x-aegis-email": "two@acme.test", "x-aegis-email-verified": "true" } });
+  await call(env, "POST", "/api/feedback", { as: owner, body: bug("Run run_111aaa222b froze", { screenshot: undefined }) });
+  await call(env, "POST", "/api/feedback", { as: "user_two", body: bug("run run_999fff000c froze", { screenshot: undefined }) });
+  await drainOutbox(env);
+  await drainOutbox(env, new Date(Date.now() + 60_000));
+  assert.equal(gh.state.issues.length, 1);
+  assert.equal(gh.state.comments.length, 1);
+  assert.match(gh.state.comments[0].body, /Reported again/);
+
+  const service = { "x-aegis-id": "bugmole-dashboard-service", "x-aegis-secret": "test-service-secret" };
+  assert.equal((await call(env, "POST", "/api/feedback/issue-state", { as: owner, body: { repo: "theaiinc/bugmole", issueNumber: 1, state: "closed" } })).status, 403);
+  const closed = await call(env, "POST", "/api/feedback/issue-state", { headers: service, body: { repo: "theaiinc/bugmole", issueNumber: 1, state: "closed" } });
+  assert.equal(closed.json.updated, 2);
+  await drainOutbox(env);
+  const notices = email.sent.filter((message) => /fixed or closed/.test(message.subject)).map((message) => message.to[0].email).sort();
+  assert.deepEqual(notices, ["owner@acme.test", "two@acme.test"]);
+  const mine = await call(env, "GET", "/api/feedback/mine", { as: "user_two" });
+  assert.equal(mine.json.reports[0].status, "closed", "a duplicate shows its original's status");
+  assert.ok(workspaceId);
+});
+
+test("feedback is validated, limited per person, and only for signed-in people", async () => {
+  const gh = fakeGithub();
+  const setup = feedbackEnv(gh);
+  const { env } = setup;
+  const { owner, projectId } = await seedProject(env);
+  const send = (body: unknown, as = owner) => call(env, "POST", "/api/feedback", { as, body });
+  assert.equal((await send({ kind: "praise", payload: {} })).status, 422);
+  assert.equal((await send({ kind: "bug", payload: { description: "  " } })).status, 422);
+  assert.equal((await send({ kind: "feedback", payload: { comment: "ok", rating: 9 } })).status, 422);
+  assert.equal((await send({ kind: "bug", payload: { description: "x", screenshot: "data:text/html;base64,PGgxPg==" } })).status, 422);
+  const key = await call(env, "POST", "/api/api-keys", { as: owner, body: { name: "ci", projectIds: [projectId] } });
+  assert.equal((await call(env, "POST", "/api/feedback", { token: key.json.token, body: { kind: "bug", payload: { description: "x" } } })).status, 403);
+
+  // Context the reporter can't see isn't recorded.
+  const sneaky = await send({ kind: "feedback", payload: { comment: "hi", rating: 5 }, workspaceId: "someone-else", projectId: "theirs" });
+  const row = setup.db.db.prepare("SELECT workspace_id AS w, project_id AS p FROM feedback_reports WHERE id = ?").get(sneaky.json.id) as any;
+  assert.deepEqual({ ...row }, { w: null, p: null });
+
+  for (let index = 1; index < RATE_LIMIT_PER_HOUR; index++) {
+    assert.equal((await send({ kind: "feedback", payload: { comment: `note ${index}`, rating: 4 } })).status, 201);
+  }
+  assert.equal((await send({ kind: "feedback", payload: { comment: "one more", rating: 4 } })).status, 429);
+});
+
+test("only platform staff see the triage list", async () => {
+  const gh = fakeGithub();
+  const { env } = feedbackEnv(gh);
+  await call(env, "POST", "/api/feedback", { as: "user_a", body: { kind: "feedback", payload: { comment: "Nice", rating: 5 } } });
+  assert.equal((await call(env, "GET", "/api/admin/feedback", { as: "user_a" })).status, 404);
+  const list = await call(env, "GET", "/api/admin/feedback?kind=feedback", { as: "user_staff" });
+  assert.equal(list.json.reports.length, 1);
+
+  // Staff can also be listed by email, but only once Aegis has verified it.
+  const byEmail = (verified: string) => call(env, "GET", "/api/admin/feedback", {
+    as: "user_other",
+    headers: { "x-aegis-email": "Staff@bugmole.test", "x-aegis-email-verified": verified },
+  });
+  assert.equal((await byEmail("true")).status, 200);
+  assert.equal((await byEmail("false")).status, 404);
+});
+
+test("a report is kept even when screenshots can't be stored", async () => {
+  const gh = fakeGithub();
+  const { env, db } = feedbackEnv(gh, { ARTIFACTS: undefined });
+  const sent = await call(env, "POST", "/api/feedback", { as: "user_a", body: bug("Button does nothing") });
+  assert.equal(sent.status, 201);
+  const row = db.db.prepare("SELECT data_json AS data, screenshot_keys_json AS keys FROM feedback_reports WHERE id = ?").get(sent.json.id) as any;
+  assert.equal(JSON.parse(row.data).imagesDropped, 1);
+  assert.equal(row.keys, "[]");
+});
+
+test("a missing GitHub setup keeps the report and stops retrying", async () => {
+  const gh = fakeGithub();
+  const { env, db } = feedbackEnv(gh, { BUGMOLE_FEEDBACK_REPO: "" });
+  const sent = await call(env, "POST", "/api/feedback", { as: "user_a", body: { kind: "feedback", payload: { comment: "Nice", rating: 5 } } });
+  await drainOutbox(env);
+  assert.equal((db.db.prepare("SELECT status FROM outbox").get() as any).status, "dead");
+  assert.equal((db.db.prepare("SELECT status FROM feedback_reports WHERE id = ?").get(sent.json.id) as any).status, "new");
+});

package/src/registry-worker/feedback/format.ts

@@ -0,0 +1,148 @@
+// Turning a report into something safe to store and useful on GitHub.
+// Issue titles, labels and the metadata footer follow @theaiinc/feedback-gh-issue's
+// conventions (used by realistiz-dd), with the logs and context Bugmole has.
+
+export type ConsoleEntry = { level: string; message: string; timestamp?: number };
+export type NetworkEntry = { url: string; duration?: number; startTime?: number };
+
+const SECRET_PATTERNS: Array<[RegExp, string]> = [
+  [/\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]{8,}/gi, "$1 [redacted]"],
+  [/\b(bm_live|vk_live|vrt|ghs|gho|ghp|ghu|github_pat)_[A-Za-z0-9_.-]{8,}/g, "[redacted token]"],
+  [/\bxox[abposr]-[A-Za-z0-9-]{8,}/g, "[redacted token]"],
+  [/\bsk-[A-Za-z0-9_-]{16,}/g, "[redacted key]"],
+  [/\bAKIA[0-9A-Z]{16}\b/g, "[redacted key]"],
+  [/\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g, "[redacted jwt]"],
+  [/((?:password|passwd|secret|token|api[_-]?key|access[_-]?key|authorization|session|code)["']?\s*[:=]\s*["']?)[^\s"'&,;}]+/gi, "$1[redacted]"],
+  [/#local-artifact-token=[^&\s]+/g, "#local-artifact-token=[redacted]"],
+];
+
+/** Removes things that look like credentials from text people didn't mean to share. */
+export function redactSecrets(text: string): string {
+  let result = text;
+  for (const [pattern, replacement] of SECRET_PATTERNS) result = result.replace(pattern, replacement);
+  return result;
+}
+
+/** Query strings often carry tokens; keep the path. */
+export function redactUrl(value: string): string {
+  try {
+    const url = new URL(value);
+    if (url.search) url.search = "?[redacted]";
+    url.hash = "";
+    return redactSecrets(url.toString());
+  } catch {
+    return redactSecrets(value.split("?")[0]);
+  }
+}
+
+function clip(text: string, max: number): string {
+  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+
+export function cleanConsole(entries: unknown, limit = 50): ConsoleEntry[] {
+  if (!Array.isArray(entries)) return [];
+  return entries.slice(-limit).flatMap((entry) => {
+    const item = entry as Partial<ConsoleEntry>;
+    if (typeof item?.message !== "string") return [];
+    return [{
+      level: typeof item.level === "string" ? item.level.slice(0, 10) : "log",
+      message: clip(redactSecrets(item.message), 1000),
+      ...(typeof item.timestamp === "number" ? { timestamp: item.timestamp } : {}),
+    }];
+  });
+}
+
+export function cleanNetwork(entries: unknown, limit = 50): NetworkEntry[] {
+  if (!Array.isArray(entries)) return [];
+  return entries.slice(-limit).flatMap((entry) => {
+    const item = entry as Partial<NetworkEntry>;
+    if (typeof item?.url !== "string") return [];
+    return [{
+      url: clip(redactUrl(item.url), 300),
+      ...(typeof item.duration === "number" ? { duration: Math.round(item.duration) } : {}),
+    }];
+  });
+}
+
+function normalize(text: string): string {
+  return text.toLowerCase().replace(/[0-9a-f]{8,}/g, "#").replace(/\d+/g, "#").replace(/\s+/g, " ").trim().slice(0, 200);
+}
+
+/** Same kind, same words (ignoring ids and numbers), same page, same first error: the same problem. */
+export async function fingerprintOf(kind: string, message: string, page: string | null, consoleEntries: ConsoleEntry[]): Promise<string> {
+  let path = "";
+  try {
+    path = page ? new URL(page).pathname.replace(/\/[0-9a-z_-]{16,}/gi, "/:id") : "";
+  } catch {
+    path = "";
+  }
+  const firstError = consoleEntries.find((entry) => entry.level === "error")?.message ?? "";
+  const source = [kind, normalize(message), path, normalize(firstError)].join("|");
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(source));
+  return [...new Uint8Array(digest)].slice(0, 12).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+export type IssueReport = {
+  id: string;
+  kind: "bug" | "feedback";
+  message: string;
+  expectation?: string;
+  rating?: number;
+  category?: string;
+  contact?: string;
+  page?: string | null;
+  workspace?: { id: string; name: string; plan: string } | null;
+  runUrl?: string | null;
+  environment?: Record<string, unknown> | null;
+  screenshotUrls: string[];
+  console: ConsoleEntry[];
+  network: NetworkEntry[];
+  fingerprint: string;
+  submittedAt: string;
+};
+
+/** Markdown can't break out of a fenced block made of more backticks than it contains. */
+function fence(text: string): string {
+  const longest = Math.max(2, ...[...text.matchAll(/`+/g)].map((match) => match[0].length));
+  const ticks = "`".repeat(longest + 1);
+  return `${ticks}\n${text}\n${ticks}`;
+}
+
+/** Reporter text can't ping people or teams on GitHub. */
+export function quietMentions(text: string): string {
+  return text.replace(/(^|[^\w`])@(?=[A-Za-z0-9])/g, "$1@\u200b");
+}
+
+function oneLine(text: string): string {
+  return text.replace(/\s+/g, " ").trim();
+}
+
+export function formatIssue(report: IssueReport): { title: string; body: string; labels: string[] } {
+  const title = report.kind === "bug"
+    ? `[Bug] ${clip(oneLine(quietMentions(report.message)), 80)}`
+    : `[Feedback] ${"★".repeat(report.rating ?? 0)}${"☆".repeat(5 - (report.rating ?? 0))} ${clip(oneLine(quietMentions(report.message)), 60)}`;
+  const env = report.environment ?? {};
+  const lines: string[] = [];
+  if (report.kind === "bug") {
+    lines.push("### What happened", quietMentions(report.message));
+    if (report.expectation) lines.push("", "### Expected", quietMentions(report.expectation));
+  } else {
+    lines.push(`**Rating:** ${report.rating}/5${report.category ? ` · **Topic:** ${quietMentions(report.category)}` : ""}`, "", quietMentions(report.message));
+  }
+  for (const url of report.screenshotUrls) lines.push("", `![screenshot](${url})`);
+  lines.push("", "### Context");
+  if (report.workspace) lines.push(`- **Workspace:** ${report.workspace.name} (\`${report.workspace.id}\`, ${report.workspace.plan} plan)`);
+  if (report.page) lines.push(`- **Page:** ${redactUrl(report.page)}`);
+  if (report.runUrl) lines.push(`- **Run:** ${report.runUrl}`);
+  if (typeof env.userAgent === "string") lines.push(`- **Browser:** ${oneLine(env.userAgent).slice(0, 200)}`);
+  if (typeof env.windowWidth === "number") lines.push(`- **Window:** ${env.windowWidth}×${env.windowHeight}`);
+  if (report.contact) lines.push(`- **Contact (shared by the reporter):** ${quietMentions(oneLine(report.contact)).slice(0, 200)}`);
+  if (report.console.length) {
+    lines.push("", `<details><summary>Console (${report.console.length})</summary>`, "", fence(report.console.map((entry) => `[${entry.level}] ${entry.message}`).join("\n")), "", "</details>");
+  }
+  if (report.network.length) {
+    lines.push("", `<details><summary>Network (${report.network.length})</summary>`, "", fence(report.network.map((entry) => `${entry.duration ?? "?"}ms ${entry.url}`).join("\n")), "", "</details>");
+  }
+  lines.push("", "---", `<sub>Sent from the Bugmole dashboard · report \`${report.id}\` · ${report.submittedAt} · fingerprint \`${report.fingerprint}\`</sub>`);
+  return { title, body: lines.join("\n"), labels: ["feedback", report.kind] };
+}