bitfab-cli 0.2.178 → 0.2.180

package/dist/index.js

@@ -5155,8 +5155,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path20) {
-      let input = path20;
+    function removeDotSegments(path21) {
+      let input = path21;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -5408,8 +5408,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path20, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path20 && path20 !== "/" ? path20 : void 0;
+        const [path21, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path21 && path21 !== "/" ? path21 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -8802,12 +8802,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs23, exportName) {
+    function addFormats(ajv, list, fs24, exportName) {
       var _a2;
       var _b;
       (_a2 = (_b = ajv.opts.code).formats) !== null && _a2 !== void 0 ? _a2 : _b.formats = (0, codegen_1._)`require("ajv-formats/dist/formats").${exportName}`;
       for (const f of list)
-        ajv.addFormat(f, fs23[f]);
+        ajv.addFormat(f, fs24[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -9013,18 +9013,18 @@ async function closeStudio(client, message) {
     data: message ? { message } : {}
   });
 }
-async function navigateStudio(client, path20) {
-  if (!isValidStudioRoute(path20)) {
-    throw new Error(`Studio route not allowed: ${path20}`);
+async function navigateStudio(client, path21) {
+  if (!isValidStudioRoute(path21)) {
+    throw new Error(`Studio route not allowed: ${path21}`);
   }
   return pushAgentSessionEvent(client, {
     type: "agent:navigate",
-    data: { path: path20 }
+    data: { path: path21 }
   });
 }
 var STUDIO_NAVIGATE_ACK_TIMEOUT_MS = 12e3;
 var PING_PONG_TIMEOUT_MS = 5e3;
-function awaitNavigateAck(client, path20, ackTimeoutMs, startCursor) {
+function awaitNavigateAck(client, path21, ackTimeoutMs, startCursor) {
   const abortController = new AbortController();
   let timer = null;
   const result = new Promise((resolve2) => {
@@ -9032,7 +9032,7 @@ function awaitNavigateAck(client, path20, ackTimeoutMs, startCursor) {
       resolve2({ acked: false, reason: "timeout" });
       abortController.abort();
     }, ackTimeoutMs);
-    const pathOnly = path20.split("?")[0];
+    const pathOnly = path21.split("?")[0];
     pollAgentSessionEvents({
       serviceUrl: client.serviceUrl,
       apiKey: client.apiKey,
@@ -9118,18 +9118,18 @@ function awaitPong(client, pingTs) {
     });
   });
 }
-async function navigateStudioAndAwaitAck(client, path20, opts = {}) {
+async function navigateStudioAndAwaitAck(client, path21, opts = {}) {
   const ackTimeoutMs = opts.ackTimeoutMs ?? STUDIO_NAVIGATE_ACK_TIMEOUT_MS;
-  if (!isValidStudioRoute(path20)) {
+  if (!isValidStudioRoute(path21)) {
     return { acked: false, reason: "invalid-route" };
   }
   const startCursor = await fetchStreamTip(client);
   try {
-    await navigateStudio(client, path20);
+    await navigateStudio(client, path21);
   } catch {
     return { acked: false, reason: "push-failed" };
   }
-  const result = await awaitNavigateAck(client, path20, ackTimeoutMs, startCursor);
+  const result = await awaitNavigateAck(client, path21, ackTimeoutMs, startCursor);
   if (result.acked || result.reason !== "timeout") {
     return result;
   }
@@ -10077,20 +10077,20 @@ function resolveStudioInitialPath(input) {
   return DEFAULT_STUDIO_PATH;
 }
 function buildStudioSessionUrl(args) {
-  const { serviceUrl, path: path20, sessionId } = args;
-  if (path20.includes("session=")) {
-    return `${serviceUrl}${path20}`;
+  const { serviceUrl, path: path21, sessionId } = args;
+  if (path21.includes("session=")) {
+    return `${serviceUrl}${path21}`;
   }
-  const separator = path20.includes("?") ? "&" : "?";
-  return `${serviceUrl}${path20}${separator}session=${encodeURIComponent(sessionId)}`;
+  const separator = path21.includes("?") ? "&" : "?";
+  return `${serviceUrl}${path21}${separator}session=${encodeURIComponent(sessionId)}`;
 }
 function resolveStudioSessionTarget(args) {
-  const path20 = resolveStudioInitialPath(args.path);
+  const path21 = resolveStudioInitialPath(args.path);
   return {
-    path: path20,
+    path: path21,
     url: buildStudioSessionUrl({
       serviceUrl: args.serviceUrl,
-      path: path20,
+      path: path21,
       sessionId: args.sessionId
     })
   };
@@ -10751,8 +10751,8 @@ function tailStudioEvents(key, onLine, opts) {
 }
 
 // ../bitfab-plugin-lib/dist/studioChannel.js
-function stripSessionId(path20, sessionId) {
-  return sessionId ? path20.split(sessionId).join("__SID__") : path20;
+function stripSessionId(path21, sessionId) {
+  return sessionId ? path21.split(sessionId).join("__SID__") : path21;
 }
 var DirectChannel = class {
   apiKey;
@@ -10767,10 +10767,10 @@ var DirectChannel = class {
   isPersistent() {
     return false;
   }
-  async openOrNavigate(path20, opts) {
+  async openOrNavigate(path21, opts) {
     if (!this.apiKey) {
       const sessionId2 = opts?.sessionId ?? crypto8.randomUUID();
-      const initialPath = resolveStudioInitialPath(path20);
+      const initialPath = resolveStudioInitialPath(path21);
       const live = readActiveStudioSession();
       if (live && live.source === "direct" && !live.authenticated && live.windowState !== "closed" && live.serviceUrl === this.serviceUrl && live.currentPath != null && stripSessionId(live.currentPath, live.sessionId) === stripSessionId(initialPath, sessionId2)) {
         return { sessionId: live.sessionId, opened: false };
@@ -10801,11 +10801,11 @@ var DirectChannel = class {
         serviceUrl: existing.serviceUrl,
         apiKey: this.apiKey,
         sessionId: existing.sessionId
-      }, path20);
+      }, path21);
       if (!ack.acked) {
         throw new StudioNavigationError(ack.reason ?? "unknown", ack.blockedReason, existing.sessionId);
       }
-      updateActiveStudioSession({ currentPath: path20 });
+      updateActiveStudioSession({ currentPath: path21 });
       return { sessionId: existing.sessionId, opened: false };
     }
     truncateStudioEventLog(resolveAgentSessionKey());
@@ -10814,7 +10814,7 @@ var DirectChannel = class {
       serviceUrl: this.serviceUrl,
       apiKey: this.apiKey,
       sessionId,
-      initialPath: path20,
+      initialPath: path21,
       clientHeaders: opts?.clientHeaders
     });
     return { sessionId: session.sessionId, opened: true };
@@ -10881,18 +10881,18 @@ var DaemonChannel = class _DaemonChannel {
   isPersistent() {
     return true;
   }
-  async openOrNavigate(path20, opts) {
+  async openOrNavigate(path21, opts) {
     const openRes = await this.client.open({
       key: this.key,
       serviceUrl: this.serviceUrl,
       apiKey: this.apiKey,
       sessionId: opts?.sessionId,
-      initialPath: path20,
+      initialPath: path21,
       clientHeaders: opts?.clientHeaders,
       focusTarget: opts?.focusTarget
     });
     if (openRes.reconnected) {
-      const navRes = await this.client.navigate(this.key, path20);
+      const navRes = await this.client.navigate(this.key, path21);
       if (!navRes.acked) {
         this.client.destroy();
         throw new StudioNavigationError(navRes.reason ?? "unknown", void 0, openRes.sessionId);
@@ -10950,9 +10950,9 @@ function isDaemonEnabled() {
 function withDirectFallback(primary, apiKey, serviceUrl) {
   let active = primary;
   return {
-    async openOrNavigate(path20, opts) {
+    async openOrNavigate(path21, opts) {
       try {
-        return await active.openOrNavigate(path20, opts);
+        return await active.openOrNavigate(path21, opts);
       } catch (err) {
         if (err instanceof StudioNavigationError || active !== primary) {
           throw err;
@@ -10960,7 +10960,7 @@ function withDirectFallback(primary, apiKey, serviceUrl) {
         console.error(`daemon failed, falling back to direct: ${err instanceof Error ? err.message : String(err)}`);
         active.destroy();
         active = new DirectChannel(apiKey, serviceUrl);
-        return active.openOrNavigate(path20, opts);
+        return active.openOrNavigate(path21, opts);
       }
     },
     async close(sessionId, message) {
@@ -11285,7 +11285,7 @@ function createEventSubscription(channel, sessionId, onEvent, restoreFocus) {
     done: sub.done
   };
 }
-async function openStudioTo(path20, opts = {}) {
+async function openStudioTo(path21, opts = {}) {
   const config4 = getConfig();
   const serviceUrl = config4.serviceUrl;
   const apiKey = !opts.forceLogin && hasCredentials() ? config4.apiKey : null;
@@ -11363,7 +11363,7 @@ async function openStudioTo(path20, opts = {}) {
     };
   };
   if (!apiKey) {
-    const destination = opts.freshWindowPath ?? path20;
+    const destination = opts.freshWindowPath ?? path21;
     const destSeparator = destination.includes("?") ? "&" : "?";
     const buildSignInPath = (sid) => {
       const redirectPath = `${destination}${destSeparator}session=${encodeURIComponent(sid)}&pluginLogin=true`;
@@ -11408,11 +11408,11 @@ async function openStudioTo(path20, opts = {}) {
     channel.setApiKey(loginApiKey);
     return finish(sessionId2, openResult.opened, loginApiKey, openResult.opened ? signInUrl : void 0);
   }
-  const { sessionId, opened } = await channel.openOrNavigate(path20, {
+  const { sessionId, opened } = await channel.openOrNavigate(path21, {
     clientHeaders: opts.clientHeaders,
     focusTarget: focusTarget ?? void 0
   });
-  const url2 = opened ? resolveStudioSessionTarget({ serviceUrl, path: path20, sessionId }).url : void 0;
+  const url2 = opened ? resolveStudioSessionTarget({ serviceUrl, path: path21, sessionId }).url : void 0;
   if (url2) {
     opts.onWindowOpened?.(url2);
   }
@@ -12293,10 +12293,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path20) {
-  if (!path20)
+function getElementAtPath(obj, path21) {
+  if (!path21)
     return obj;
-  return path20.reduce((acc, key) => acc?.[key], obj);
+  return path21.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -12679,11 +12679,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path20, issues) {
+function prefixIssues(path21, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path20);
+    iss.path.unshift(path21);
     return iss;
   });
 }
@@ -12866,7 +12866,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path20 = []) => {
+  const processError = (error49, path21 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -12876,7 +12876,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path20, ...issue2.path];
+        const fullpath = [...path21, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -12908,8 +12908,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path20 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path20) {
+  const path21 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path21) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -24886,13 +24886,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path20 = ref.slice(1).split("/").filter(Boolean);
-  if (path20.length === 0) {
+  const path21 = ref.slice(1).split("/").filter(Boolean);
+  if (path21.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path20[0] === defsKey) {
-    const key = path20[1];
+  if (path21[0] === defsKey) {
+    const key = path21[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -25730,8 +25730,8 @@ function getErrorMap2() {
 
 // ../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path20, errorMaps, issueData } = params;
-  const fullPath = [...path20, ...issueData.path || []];
+  const { data, path: path21, errorMaps, issueData } = params;
+  const fullPath = [...path21, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -25846,11 +25846,11 @@ var errorUtil;
 
 // ../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path20, key) {
+  constructor(parent, value, path21, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path20;
+    this._path = path21;
     this._key = key;
   }
   get path() {
@@ -30804,6 +30804,7 @@ var tracePlanTreeShape = external_exports.object({
 
 // src/claude.ts
 import { spawn as spawn5 } from "child_process";
+import crypto10 from "crypto";
 import fs20 from "fs";
 import os15 from "os";
 import path17 from "path";
@@ -30956,6 +30957,27 @@ function cliUpdate(cfg, args, skipPermissions) {
   }
 }
 
+// src/redaction.ts
+var SECRET_PATTERN = /bf_[A-Za-z0-9]+/g;
+var STREAMING_SECRET_TAIL_LENGTH = 512;
+function redactSecrets(text) {
+  return text.replace(SECRET_PATTERN, "bf_[redacted]");
+}
+var StreamingSecretRedactor = class {
+  pending = "";
+  redact(chunk2) {
+    const text = this.pending + chunk2;
+    const flushLength = Math.max(0, text.length - STREAMING_SECRET_TAIL_LENGTH);
+    this.pending = text.slice(flushLength);
+    return redactSecrets(text.slice(0, flushLength));
+  }
+  flush() {
+    const redacted = redactSecrets(this.pending);
+    this.pending = "";
+    return redacted;
+  }
+};
+
 // src/claude.ts
 var CLI = "claude";
 var SKIP_FLAG = "--dangerously-skip-permissions";
@@ -31026,15 +31048,35 @@ async function runClaudeAnalyzeRepo(captureOverride, limit) {
     throw new Error(auth.message);
   }
   const logPath = analyzeRepoLogPath();
+  const agentRunId = crypto10.randomUUID();
   const env = { ...process.env };
+  env.BITFAB_AGENT_RUN_ID = agentRunId;
   if (captureOverride !== void 0) {
     env.BITFAB_CAPTURE_SESSIONS = captureOverride ? "1" : "0";
   }
   const command = limit === void 0 ? ANALYZE_REPO_COMMAND : `${ANALYZE_REPO_COMMAND} limit=${limit}`;
   const out = fs20.createWriteStream(logPath);
-  const spinner5 = p3.spinner();
-  spinner5.start("Analyzing repo and drafting trace plans");
+  const spinner6 = p3.spinner();
+  spinner6.start("Analyzing repo and drafting trace plans");
   const stdoutChunks = [];
+  const stdoutRedactor = new StreamingSecretRedactor();
+  const stderrRedactor = new StreamingSecretRedactor();
+  let redactorsFlushed = false;
+  const flushRedactors = () => {
+    if (redactorsFlushed) {
+      return;
+    }
+    redactorsFlushed = true;
+    const stdoutTail = stdoutRedactor.flush();
+    if (stdoutTail !== "") {
+      out.write(stdoutTail);
+      stdoutChunks.push(stdoutTail);
+    }
+    const stderrTail = stderrRedactor.flush();
+    if (stderrTail !== "") {
+      out.write(stderrTail);
+    }
+  };
   try {
     const exitCode = await new Promise((resolve2, reject) => {
       const child = spawn5(
@@ -31050,31 +31092,49 @@ async function runClaudeAnalyzeRepo(captureOverride, limit) {
         { stdio: ["ignore", "pipe", "pipe"], env, ...SHELL_OPTS }
       );
       child.stdout.on("data", (chunk2) => {
-        out.write(chunk2);
         const text = chunk2.toString();
-        stdoutChunks.push(text);
+        const redacted = stdoutRedactor.redact(text);
+        if (redacted !== "") {
+          out.write(redacted);
+          stdoutChunks.push(redacted);
+        }
         const label = latestActivityLabel(text);
         if (label) {
-          spinner5.message(label);
+          spinner6.message(label);
         }
       });
-      child.stderr.on("data", (chunk2) => out.write(chunk2));
+      child.stderr.on(
+        "data",
+        (chunk2) => out.write(stderrRedactor.redact(chunk2.toString()))
+      );
       child.on("error", reject);
-      child.on("close", (code) => resolve2(code ?? 0));
+      child.on("close", (code, signal) => {
+        if (code === null) {
+          reject(
+            new Error(
+              `analyze-repo terminated by signal ${signal ?? "unknown"}. See ${logPath}`
+            )
+          );
+          return;
+        }
+        resolve2(code);
+      });
     });
+    flushRedactors();
     if (exitCode !== 0) {
       throw new Error(
         `analyze-repo exited with status ${exitCode}. See ${logPath}`
       );
     }
     const uploaded = countUploadedTracePlans(stdoutChunks.join(""));
-    spinner5.stop(
+    spinner6.stop(
       uploaded === 0 ? "No AI workflows found - nothing to upload" : `Uploaded ${uploaded} draft trace plan${uploaded === 1 ? "" : "s"} to Bitfab`
     );
   } catch (err) {
-    spinner5.stop("analyze-repo failed");
+    spinner6.stop("analyze-repo failed");
     throw err;
   } finally {
+    flushRedactors();
     out.end();
   }
   p3.log.info(`Full run log: ${logPath}`);
@@ -31239,6 +31299,8 @@ var claudeAdapter = {
 };
 
 // src/codex.ts
+import { spawn as spawn6 } from "child_process";
+import crypto11 from "crypto";
 import fs21 from "fs";
 import os16 from "os";
 import path18 from "path";
@@ -31248,7 +31310,9 @@ var SKIP_FLAG2 = "--full-auto";
 var REPO2 = "Project-White-Rabbit/bitfab-codex-plugin";
 var MARKETPLACE2 = "bitfab";
 var PLUGIN_KEY2 = "bitfab@bitfab";
+var INTERNAL_PLUGIN_KEY = "bitfab@bitfab-internal";
 var SETUP_COMMAND2 = "$bitfab:setup";
+var ANALYZE_REPO_COMMAND2 = "$bitfab:setup analyze-repo";
 var ASSISTANT_COMMAND2 = "$bitfab:assistant";
 var UPDATE_COMMAND2 = "$bitfab:update";
 function isCodexLoginStatusLoggedIn(output) {
@@ -31268,6 +31332,12 @@ function ensureLatestCodexPlugin() {
   ensureLatestPlugin(pullLatestCodexPlugin);
 }
 function runCodexInstall() {
+  const configPath = path18.join(os16.homedir(), ".codex", "config.toml");
+  if (isCodexPluginEnabled(configPath, INTERNAL_PLUGIN_KEY)) {
+    p4.log.step("Codex dev plugin already active");
+    p4.log.success("Bitfab plugin ready in Codex");
+    return;
+  }
   const s = p4.spinner();
   s.start("Adding bitfab marketplace");
   const out = runCli(CLI2, ["plugin", "marketplace", "add", REPO2]);
@@ -31278,9 +31348,7 @@ function runCodexInstall() {
     s.stop("Marketplace added");
   }
   s.start("Enabling bitfab plugin in config");
-  const changed = enableCodexPlugin(
-    path18.join(os16.homedir(), ".codex", "config.toml")
-  );
+  const changed = enableCodexPlugin(configPath);
   if (changed) {
     s.stop("Plugin enabled");
   } else {
@@ -31291,13 +31359,229 @@ function runCodexInstall() {
   }
   p4.log.success("Bitfab plugin ready in Codex");
 }
-function runCodexAnalyzeRepo() {
-  p4.log.warn(
-    "Headless analyze-repo is currently supported for Claude Code only."
-  );
-  p4.log.info(
-    `To run it in Codex, launch ${SETUP_COMMAND2} analyze-repo interactively.`
+async function runCodexAnalyzeRepo(captureOverride, limit) {
+  const auth = checkCodexAuth();
+  if (!auth.ok) {
+    throw new Error(auth.message);
+  }
+  const logPath = analyzeRepoLogPath2();
+  const agentRunId = crypto11.randomUUID();
+  const env = { ...process.env };
+  env.BITFAB_AGENT_RUN_ID = agentRunId;
+  if (captureOverride !== void 0) {
+    env.BITFAB_CAPTURE_SESSIONS = captureOverride ? "1" : "0";
+  }
+  const command = limit === void 0 ? ANALYZE_REPO_COMMAND2 : `${ANALYZE_REPO_COMMAND2} limit=${limit}`;
+  const out = fs21.createWriteStream(logPath);
+  const spinner6 = p4.spinner();
+  spinner6.start("Analyzing repo and drafting trace plans");
+  const stdoutChunks = [];
+  const stdoutRedactor = new StreamingSecretRedactor();
+  const stderrRedactor = new StreamingSecretRedactor();
+  let redactorsFlushed = false;
+  const flushRedactors = () => {
+    if (redactorsFlushed) {
+      return;
+    }
+    redactorsFlushed = true;
+    const stdoutTail = stdoutRedactor.flush();
+    if (stdoutTail !== "") {
+      out.write(stdoutTail);
+      stdoutChunks.push(stdoutTail);
+    }
+    const stderrTail = stderrRedactor.flush();
+    if (stderrTail !== "") {
+      out.write(stderrTail);
+    }
+  };
+  try {
+    const exitCode = await new Promise((resolve2, reject) => {
+      const child = spawn6(
+        CLI2,
+        [
+          "--ask-for-approval",
+          "on-request",
+          "--config",
+          'approvals_reviewer="auto_review"',
+          "exec",
+          "--json",
+          "--sandbox",
+          "danger-full-access",
+          command
+        ],
+        { stdio: ["ignore", "pipe", "pipe"], env, ...SHELL_OPTS }
+      );
+      child.stdout.on("data", (chunk2) => {
+        const text = chunk2.toString();
+        const redacted = stdoutRedactor.redact(text);
+        if (redacted !== "") {
+          out.write(redacted);
+          stdoutChunks.push(redacted);
+        }
+        const label = latestCodexActivityLabel(text);
+        if (label) {
+          spinner6.message(label);
+        }
+      });
+      child.stderr.on(
+        "data",
+        (chunk2) => out.write(stderrRedactor.redact(chunk2.toString()))
+      );
+      child.on("error", reject);
+      child.on("close", (code, signal) => {
+        if (code === null) {
+          reject(
+            new Error(
+              `analyze-repo terminated by signal ${signal ?? "unknown"}. See ${logPath}`
+            )
+          );
+          return;
+        }
+        resolve2(code);
+      });
+    });
+    flushRedactors();
+    if (exitCode !== 0) {
+      throw new Error(
+        `analyze-repo exited with status ${exitCode}. See ${logPath}`
+      );
+    }
+    const uploaded = countUploadedTracePlans2(stdoutChunks.join(""));
+    spinner6.stop(
+      uploaded === 0 ? "No AI workflows found - nothing to upload" : `Uploaded ${uploaded} draft trace plan${uploaded === 1 ? "" : "s"} to Bitfab`
+    );
+  } catch (err) {
+    spinner6.stop("analyze-repo failed");
+    throw err;
+  } finally {
+    flushRedactors();
+    out.end();
+  }
+  p4.log.info(`Full run log: ${logPath}`);
+}
+function latestCodexActivityLabel(chunk2) {
+  const lines = chunk2.split("\n").filter((l) => l.trim() !== "");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    let event;
+    try {
+      event = JSON.parse(lines[i]);
+    } catch {
+      continue;
+    }
+    const label = codexActivityLabelFromEvent(event);
+    if (label) {
+      return label;
+    }
+  }
+  return null;
+}
+function codexActivityLabelFromEvent(event) {
+  const item = eventItem(event);
+  if (!item) {
+    return null;
+  }
+  if (isMcpToolItem(item, "create_trace_plan")) {
+    return "Uploading a draft trace plan";
+  }
+  if (isMcpToolItem(item, "get_bitfab_api_key")) {
+    return "Checking authentication";
+  }
+  const command = typeof item.command === "string" ? item.command : "";
+  if (command.includes("rg ") || command.includes("rg --files")) {
+    return "Searching the codebase";
+  }
+  if (command.includes("sed ") || command.includes("cat ") || command.includes("nl ")) {
+    return "Reading files";
+  }
+  if (typeof item.type === "string" && item.type.includes("web")) {
+    return "Reading SDK docs";
+  }
+  return null;
+}
+function countUploadedTracePlans2(logText) {
+  const planToolUseIds = /* @__PURE__ */ new Set();
+  const nonErrorResultIds = /* @__PURE__ */ new Set();
+  let completedPlanCalls = 0;
+  for (const line of logText.split("\n")) {
+    if (line.trim() === "") {
+      continue;
+    }
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const item = eventItem(event);
+    if (item && isMcpToolItem(item, "create_trace_plan")) {
+      const status = typeof item.status === "string" ? item.status : "";
+      if (status === "completed" || status === "" && eventType(event) === "item.completed") {
+        completedPlanCalls++;
+      }
+    }
+    for (const block of eventMessageContent2(event) ?? []) {
+      if (typeof block !== "object" || block === null) {
+        continue;
+      }
+      const b = block;
+      if (b.type === "tool_use" && typeof b.id === "string" && typeof b.name === "string" && b.name.includes("create_trace_plan")) {
+        planToolUseIds.add(b.id);
+      }
+      if (b.type === "tool_result" && typeof b.tool_use_id === "string" && b.is_error !== true) {
+        nonErrorResultIds.add(b.tool_use_id);
+      }
+    }
+  }
+  let pairedCount = 0;
+  for (const id of planToolUseIds) {
+    if (nonErrorResultIds.has(id)) {
+      pairedCount++;
+    }
+  }
+  return pairedCount + completedPlanCalls;
+}
+function isMcpToolItem(item, toolName) {
+  if (typeof item.type === "string" && !item.type.includes("mcp")) {
+    return false;
+  }
+  const directNames = [item.tool, item.name].filter(
+    (value) => typeof value === "string"
   );
+  if (directNames.some((name) => name.includes(toolName))) {
+    return true;
+  }
+  const toolCall = item.tool_call;
+  if (typeof toolCall === "object" && toolCall !== null) {
+    const nested = toolCall;
+    return [nested.tool, nested.name].some(
+      (value) => typeof value === "string" && value.includes(toolName)
+    );
+  }
+  return false;
+}
+function eventType(event) {
+  return typeof event === "object" && event !== null && typeof event.type === "string" ? event.type : "";
+}
+function eventItem(event) {
+  if (typeof event !== "object" || event === null) {
+    return null;
+  }
+  const item = event.item;
+  return typeof item === "object" && item !== null ? item : null;
+}
+function eventMessageContent2(event) {
+  if (typeof event !== "object" || event === null) {
+    return null;
+  }
+  const message = event.message;
+  const content = typeof message === "object" && message !== null ? message.content : void 0;
+  return Array.isArray(content) ? content : null;
+}
+function analyzeRepoLogPath2() {
+  const dir = path18.join(process.cwd(), ".bitfab", "logs");
+  fs21.mkdirSync(dir, { recursive: true });
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  return path18.join(dir, `analyze-repo-${stamp}.jsonl`);
 }
 function enableCodexPlugin(configPath) {
   let content = "";
@@ -31313,7 +31597,7 @@ enabled = true
     "m"
   );
   const match = sectionRegex.exec(content);
-  if (match?.[0].includes("enabled = true")) {
+  if (match && sectionHasEnabledTrue(match[0])) {
     return false;
   }
   let next;
@@ -31329,9 +31613,24 @@ ${desiredSection}`;
   fs21.writeFileSync(configPath, next);
   return true;
 }
+function isCodexPluginEnabled(configPath, pluginKey) {
+  if (!fs21.existsSync(configPath)) {
+    return false;
+  }
+  const content = fs21.readFileSync(configPath, "utf-8");
+  const sectionRegex = new RegExp(
+    `\\[plugins\\."${escapeRegex2(pluginKey)}"\\][^\\[]*`,
+    "m"
+  );
+  const match = sectionRegex.exec(content);
+  return match ? sectionHasEnabledTrue(match[0]) : false;
+}
 function escapeRegex2(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function sectionHasEnabledTrue(section) {
+  return section.split(/\r?\n/).some((line) => /^\s*enabled\s*=\s*true\s*(?:#.*)?$/.test(line));
+}
 var config3 = {
   cli: CLI2,
   skipFlag: SKIP_FLAG2,
@@ -31352,12 +31651,16 @@ var codexAdapter = {
 };
 
 // src/cursor.ts
-import { spawn as spawn6, spawnSync as spawnSync2 } from "child_process";
+import { spawn as spawn7, spawnSync as spawnSync2 } from "child_process";
+import crypto12 from "crypto";
+import fs22 from "fs";
 import os17 from "os";
+import path19 from "path";
 import * as p5 from "@clack/prompts";
 var REPO3 = "Project-White-Rabbit/bitfab-cursor-plugin";
 var ADD_PLUGIN_CMD = `/add-plugin ${REPO3}`;
 var SETUP_COMMAND3 = "/bitfab-setup";
+var ANALYZE_REPO_COMMAND3 = "/bitfab-setup analyze-repo";
 var ASSISTANT_COMMAND3 = "/bitfab-assistant";
 var UPDATE_COMMAND3 = "/bitfab-update";
 function isCursorAgentStatusAuthenticated(output) {
@@ -31396,7 +31699,7 @@ function runCursorInstall() {
     "Finish setup in Cursor"
   );
   p5.log.info("Opening Cursor...");
-  const child = spawn6("cursor", ["."], {
+  const child = spawn7("cursor", ["."], {
     stdio: "ignore",
     detached: true,
     windowsHide: true,
@@ -31415,11 +31718,241 @@ function runCursorSetup(skipPermissions) {
   }
   p5.log.info(`To complete setup, run ${SETUP_COMMAND3} in Cursor.`);
 }
-function runCursorAnalyzeRepo() {
-  p5.log.warn(
-    "Headless analyze-repo is currently supported for Claude Code only."
-  );
-  p5.log.info(`To run it in Cursor, run ${SETUP_COMMAND3} analyze-repo manually.`);
+async function runCursorAnalyzeRepo(captureOverride, limit) {
+  ensureCursorAuthenticated();
+  const pluginDir = resolveCursorPluginDir();
+  if (!pluginDir) {
+    throw new Error(
+      [
+        "Could not find a Cursor Bitfab plugin directory to load headlessly.",
+        `Install the plugin in Cursor with ${ADD_PLUGIN_CMD}, or run from the monorepo checkout so bitfab-cursor-plugin is available.`
+      ].join("\n")
+    );
+  }
+  const logPath = analyzeRepoLogPath3();
+  const agentRunId = crypto12.randomUUID();
+  const env = { ...process.env };
+  env.BITFAB_AGENT_RUN_ID = agentRunId;
+  if (captureOverride !== void 0) {
+    env.BITFAB_CAPTURE_SESSIONS = captureOverride ? "1" : "0";
+  }
+  const command = limit === void 0 ? ANALYZE_REPO_COMMAND3 : `${ANALYZE_REPO_COMMAND3} limit=${limit}`;
+  const out = fs22.createWriteStream(logPath);
+  const spinner6 = p5.spinner();
+  spinner6.start("Analyzing repo and drafting trace plans");
+  const stdoutChunks = [];
+  const stdoutRedactor = new StreamingSecretRedactor();
+  const stderrRedactor = new StreamingSecretRedactor();
+  let redactorsFlushed = false;
+  const flushRedactors = () => {
+    if (redactorsFlushed) {
+      return;
+    }
+    redactorsFlushed = true;
+    const stdoutTail = stdoutRedactor.flush();
+    if (stdoutTail !== "") {
+      out.write(stdoutTail);
+      stdoutChunks.push(stdoutTail);
+    }
+    const stderrTail = stderrRedactor.flush();
+    if (stderrTail !== "") {
+      out.write(stderrTail);
+    }
+  };
+  try {
+    const exitCode = await new Promise((resolve2, reject) => {
+      const child = spawn7(
+        "cursor",
+        [
+          "agent",
+          "--print",
+          "--output-format",
+          "stream-json",
+          "--trust",
+          "--approve-mcps",
+          "--force",
+          "--plugin-dir",
+          pluginDir,
+          "--workspace",
+          process.cwd(),
+          command
+        ],
+        { stdio: ["ignore", "pipe", "pipe"], env, ...SHELL_OPTS }
+      );
+      child.stdout.on("data", (chunk2) => {
+        const text = chunk2.toString();
+        const redacted = stdoutRedactor.redact(text);
+        if (redacted !== "") {
+          out.write(redacted);
+          stdoutChunks.push(redacted);
+        }
+        const label = latestCursorActivityLabel(text);
+        if (label) {
+          spinner6.message(label);
+        }
+      });
+      child.stderr.on(
+        "data",
+        (chunk2) => out.write(stderrRedactor.redact(chunk2.toString()))
+      );
+      child.on("error", reject);
+      child.on("close", (code, signal) => {
+        if (code === null) {
+          reject(
+            new Error(
+              `analyze-repo terminated by signal ${signal ?? "unknown"}. See ${logPath}`
+            )
+          );
+          return;
+        }
+        resolve2(code);
+      });
+    });
+    flushRedactors();
+    if (exitCode !== 0) {
+      throw new Error(
+        `analyze-repo exited with status ${exitCode}. See ${logPath}`
+      );
+    }
+    const uploaded = countUploadedTracePlans3(stdoutChunks.join(""));
+    spinner6.stop(
+      uploaded === 0 ? "No AI workflows found - nothing to upload" : `Uploaded ${uploaded} draft trace plan${uploaded === 1 ? "" : "s"} to Bitfab`
+    );
+  } catch (err) {
+    spinner6.stop("analyze-repo failed");
+    throw err;
+  } finally {
+    flushRedactors();
+    out.end();
+  }
+  p5.log.info(`Full run log: ${logPath}`);
+}
+function latestCursorActivityLabel(chunk2) {
+  const lines = chunk2.split("\n").filter((l) => l.trim() !== "");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    let event;
+    try {
+      event = JSON.parse(lines[i]);
+    } catch {
+      continue;
+    }
+    const label = cursorActivityLabelFromEvent(event);
+    if (label) {
+      return label;
+    }
+  }
+  return null;
+}
+function cursorActivityLabelFromEvent(event) {
+  const toolCall = eventToolCall(event);
+  if (!toolCall) {
+    return null;
+  }
+  const mcpToolName = mcpToolCallName(toolCall);
+  if (mcpToolName?.includes("create_trace_plan")) {
+    return "Uploading a draft trace plan";
+  }
+  if (mcpToolName?.includes("get_bitfab_api_key")) {
+    return "Checking authentication";
+  }
+  if ("grepToolCall" in toolCall) {
+    return "Searching the codebase";
+  }
+  if ("readToolCall" in toolCall) {
+    return "Reading files";
+  }
+  return null;
+}
+function eventToolCall(event) {
+  if (typeof event !== "object" || event === null) {
+    return null;
+  }
+  const toolCall = event.tool_call;
+  return typeof toolCall === "object" && toolCall !== null ? toolCall : null;
+}
+function mcpToolCallName(toolCall) {
+  const mcpToolCall = toolCall.mcpToolCall;
+  if (typeof mcpToolCall !== "object" || mcpToolCall === null) {
+    return null;
+  }
+  const call = mcpToolCall;
+  const args = call.args;
+  const names = [
+    call.toolName,
+    call.name,
+    typeof args === "object" && args !== null ? args.name : void 0
+  ];
+  return names.find((name) => typeof name === "string") ?? null;
+}
+function countUploadedTracePlans3(logText) {
+  let completedPlanCalls = 0;
+  for (const line of logText.split("\n")) {
+    if (line.trim() === "") {
+      continue;
+    }
+    let event;
+    try {
+      event = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (isSuccessfulCreateTracePlanEvent(event)) {
+      completedPlanCalls++;
+    }
+  }
+  if (completedPlanCalls > 0) {
+    return completedPlanCalls;
+  }
+  return 0;
+}
+function isSuccessfulCreateTracePlanEvent(event) {
+  if (typeof event !== "object" || event === null) {
+    return false;
+  }
+  const e = event;
+  if (e.type !== "tool_call" || e.subtype !== "completed") {
+    return false;
+  }
+  const toolCall = e.tool_call;
+  if (typeof toolCall !== "object" || toolCall === null) {
+    return false;
+  }
+  const mcpToolCall = toolCall.mcpToolCall;
+  if (typeof mcpToolCall !== "object" || mcpToolCall === null) {
+    return false;
+  }
+  const call = mcpToolCall;
+  const args = call.args;
+  const names = [
+    call.toolName,
+    call.name,
+    typeof args === "object" && args !== null ? args.name : void 0
+  ];
+  return names.some(
+    (name) => typeof name === "string" && name.includes("create_trace_plan")
+  ) && hasSuccessfulToolResult(call.result);
+}
+function hasSuccessfulToolResult(result) {
+  return typeof result === "object" && result !== null && "success" in result && !("error" in result);
+}
+function resolveCursorPluginDir() {
+  const candidates = [
+    path19.join(process.cwd(), "bitfab-cursor-plugin"),
+    path19.join(os17.homedir(), ".cursor", "plugins", "local", "bitfab-dev"),
+    path19.join(os17.homedir(), ".cursor", "plugins", "local", "bitfab")
+  ];
+  for (const candidate of candidates) {
+    if (fs22.existsSync(path19.join(candidate, ".cursor-plugin", "plugin.json")) && fs22.existsSync(path19.join(candidate, "mcp.json"))) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function analyzeRepoLogPath3() {
+  const dir = path19.join(process.cwd(), ".bitfab", "logs");
+  fs22.mkdirSync(dir, { recursive: true });
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  return path19.join(dir, `analyze-repo-${stamp}.jsonl`);
 }
 function runCursorAssistant(args, skipPermissions) {
   ensureCursorAuthenticated();
@@ -31495,12 +32028,12 @@ var platform = {
 };
 
 // src/version.ts
-import fs22 from "fs";
-import path19 from "path";
+import fs23 from "fs";
+import path20 from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var CLI_VERSION = JSON.parse(
-  fs22.readFileSync(
-    path19.join(path19.dirname(fileURLToPath4(import.meta.url)), "../package.json"),
+  fs23.readFileSync(
+    path20.join(path20.dirname(fileURLToPath4(import.meta.url)), "../package.json"),
     "utf-8"
   )
 ).version;
@@ -31666,10 +32199,10 @@ async function runAnalyzeRepo(opts) {
   p6.intro("Bitfab");
   const chosen = await resolveEditor(opts);
   p6.log.step(`Preparing ${ADAPTERS[chosen].label} plugin`);
-  ADAPTERS[chosen].install();
-  if (chosen !== "claude") {
-    ADAPTERS[chosen].analyzeRepo();
-    process.exit(1);
+  if (chosen === "cursor") {
+    ADAPTERS[chosen].ensureLatest();
+  } else {
+    ADAPTERS[chosen].install();
   }
   await ensureAnalyzeRepoAuth();
   const captureOverride = await resolveCaptureOverride(opts.uploadLogs);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bitfab-cli",
-  "version": "0.2.178",
+  "version": "0.2.180",
   "description": "Install and configure the Bitfab plugin in Claude Code, Codex, or Cursor.",
   "type": "module",
   "main": "dist/index.js",