bitfab-cli 0.2.113 → 0.2.115

package/dist/index.js

@@ -5152,8 +5152,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path18) {
-      let input = path18;
+    function removeDotSegments(path19) {
+      let input = path19;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -5352,8 +5352,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path18, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path18 && path18 !== "/" ? path18 : void 0;
+        const [path19, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path19 && path19 !== "/" ? path19 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -8715,12 +8715,12 @@ var require_dist = __commonJS({
         throw new Error(`Unknown format "${name}"`);
       return f;
     };
-    function addFormats(ajv, list, fs20, exportName) {
+    function addFormats(ajv, list, fs21, 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, fs20[f]);
+        ajv.addFormat(f, fs21[f]);
     }
     module.exports = exports = formatsPlugin;
     Object.defineProperty(exports, "__esModule", { value: true });
@@ -8922,18 +8922,18 @@ async function closeStudio(client, message) {
     data: message ? { message } : {}
   });
 }
-async function navigateStudio(client, path18) {
-  if (!isValidStudioRoute(path18)) {
-    throw new Error(`Studio route not allowed: ${path18}`);
+async function navigateStudio(client, path19) {
+  if (!isValidStudioRoute(path19)) {
+    throw new Error(`Studio route not allowed: ${path19}`);
   }
   return pushAgentSessionEvent(client, {
     type: "agent:navigate",
-    data: { path: path18 }
+    data: { path: path19 }
   });
 }
 var STUDIO_NAVIGATE_ACK_TIMEOUT_MS = 12e3;
 var PING_PONG_TIMEOUT_MS = 5e3;
-function awaitNavigateAck(client, path18, ackTimeoutMs, startCursor) {
+function awaitNavigateAck(client, path19, ackTimeoutMs, startCursor) {
   const abortController = new AbortController();
   let timer = null;
   const result = new Promise((resolve) => {
@@ -8941,7 +8941,7 @@ function awaitNavigateAck(client, path18, ackTimeoutMs, startCursor) {
       resolve({ acked: false, reason: "timeout" });
       abortController.abort();
     }, ackTimeoutMs);
-    const pathOnly = path18.split("?")[0];
+    const pathOnly = path19.split("?")[0];
     pollAgentSessionEvents({
       serviceUrl: client.serviceUrl,
       apiKey: client.apiKey,
@@ -9027,18 +9027,18 @@ function awaitPong(client, pingTs) {
     });
   });
 }
-async function navigateStudioAndAwaitAck(client, path18, opts = {}) {
+async function navigateStudioAndAwaitAck(client, path19, opts = {}) {
   const ackTimeoutMs = opts.ackTimeoutMs ?? STUDIO_NAVIGATE_ACK_TIMEOUT_MS;
-  if (!isValidStudioRoute(path18)) {
+  if (!isValidStudioRoute(path19)) {
     return { acked: false, reason: "invalid-route" };
   }
   const startCursor = await fetchStreamTip(client);
   try {
-    await navigateStudio(client, path18);
+    await navigateStudio(client, path19);
   } catch {
     return { acked: false, reason: "push-failed" };
   }
-  const result = await awaitNavigateAck(client, path18, ackTimeoutMs, startCursor);
+  const result = await awaitNavigateAck(client, path19, ackTimeoutMs, startCursor);
   if (result.acked || result.reason !== "timeout") {
     return result;
   }
@@ -9397,6 +9397,103 @@ function updateActiveStudioSession(updates) {
   writeStateFile(sessionFilePath(), updated);
   return updated;
 }
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+function processStartToken(pid) {
+  try {
+    const out = execFileSync2("ps", ["-o", "lstart=", "-p", String(pid)], {
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2e3
+    }).trim();
+    return out || null;
+  } catch {
+    return null;
+  }
+}
+function monitorLockPath() {
+  return path6.join(SESSIONS_DIR, `${shortHash(resolveAgentSessionKey())}.monitor.lock`);
+}
+function monitorLockBody(pid) {
+  return `${pid}
+${processStartToken(pid) ?? ""}`;
+}
+function isMonitorOwnerLive(owner) {
+  if (!isProcessAlive(owner.pid)) {
+    return false;
+  }
+  if (!owner.start) {
+    return true;
+  }
+  const current = processStartToken(owner.pid);
+  if (current === null) {
+    return true;
+  }
+  return current === owner.start;
+}
+function readLockOwner(lock) {
+  try {
+    const [pidLine = "", ...rest] = fs7.readFileSync(lock, "utf-8").split("\n");
+    const pid = Number.parseInt(pidLine.trim(), 10);
+    if (!Number.isInteger(pid)) {
+      return null;
+    }
+    return { pid, start: rest.join("\n").trim() };
+  } catch {
+    return null;
+  }
+}
+function stampMonitorPid() {
+  const current = readStateFile(sessionFilePath());
+  if (current) {
+    writeStateFile(sessionFilePath(), { ...current, pollerPid: process.pid });
+  }
+}
+function tryClaimStudioMonitor() {
+  const lock = monitorLockPath();
+  fs7.mkdirSync(path6.dirname(lock), { recursive: true });
+  for (let attempt = 0; attempt < 10; attempt++) {
+    try {
+      const fd = fs7.openSync(lock, "wx");
+      fs7.writeSync(fd, monitorLockBody(process.pid));
+      fs7.closeSync(fd);
+      stampMonitorPid();
+      return true;
+    } catch (err) {
+      if (err.code !== "EEXIST") {
+        throw err;
+      }
+      const owner = readLockOwner(lock);
+      if (owner?.pid === process.pid) {
+        return true;
+      }
+      if (owner && isMonitorOwnerLive(owner)) {
+        return false;
+      }
+      try {
+        fs7.unlinkSync(lock);
+      } catch {
+      }
+    }
+  }
+  stampMonitorPid();
+  return true;
+}
+function releaseStudioMonitor() {
+  try {
+    const lock = monitorLockPath();
+    if (readLockOwner(lock)?.pid === process.pid) {
+      fs7.unlinkSync(lock);
+    }
+  } catch {
+  }
+}
 
 // ../bitfab-plugin-lib/dist/browser.js
 import { execFileSync as execFileSync3, execSync, spawn } from "child_process";
@@ -9795,7 +9892,7 @@ function extractCommandName(argv) {
 }
 
 // ../bitfab-plugin-lib/dist/studioChannel.js
-import crypto6 from "crypto";
+import crypto7 from "crypto";
 
 // ../bitfab-plugin-lib/dist/commands/createStudioSession.js
 function ensureStudioPath(p5) {
@@ -10238,6 +10335,92 @@ var DaemonClient = class {
   }
 };
 
+// ../bitfab-plugin-lib/dist/studioEventLog.js
+import crypto6 from "crypto";
+import fs10 from "fs";
+import os10 from "os";
+import path9 from "path";
+var SESSIONS_DIR2 = path9.join(os10.homedir(), ".config", "bitfab", "sessions");
+function shortHash2(input) {
+  return crypto6.createHash("sha256").update(input).digest("hex").slice(0, 16);
+}
+function eventLogPathForKey(key) {
+  return path9.join(SESSIONS_DIR2, `${shortHash2(key)}.events.jsonl`);
+}
+function studioEventToLogLine(event, sessionId) {
+  const data = event.data ?? {};
+  const line = {
+    event: event.type.replace("studio:", ""),
+    sessionId,
+    ...data
+  };
+  delete line.token;
+  return line;
+}
+function appendStudioEvent(key, line) {
+  try {
+    const target = eventLogPathForKey(key);
+    fs10.mkdirSync(path9.dirname(target), { recursive: true });
+    fs10.appendFileSync(target, `${JSON.stringify(line)}
+`);
+  } catch {
+  }
+}
+function truncateStudioEventLog(key) {
+  try {
+    fs10.rmSync(eventLogPathForKey(key), { force: true });
+  } catch {
+  }
+}
+function readStudioEventLogTail(key, fromLine = 1) {
+  try {
+    const raw = fs10.readFileSync(eventLogPathForKey(key), "utf-8");
+    const all = raw.split("\n").filter((l) => l.length > 0);
+    const start = Math.max(0, fromLine - 1);
+    const slice = all.slice(start);
+    const lines = [];
+    for (const l of slice) {
+      try {
+        lines.push(JSON.parse(l));
+      } catch {
+      }
+    }
+    return { lines, nextLine: all.length + 1 };
+  } catch {
+    return { lines: [], nextLine: fromLine };
+  }
+}
+function tailStudioEvents(key, onLine, opts) {
+  const pollMs = opts.pollMs ?? 200;
+  let cursor = opts.fromLine ?? 1;
+  return new Promise((resolve) => {
+    if (opts.abortSignal.aborted) {
+      resolve();
+      return;
+    }
+    const tick = () => {
+      const { lines, nextLine } = readStudioEventLogTail(key, cursor);
+      cursor = nextLine;
+      for (const line of lines) {
+        if (opts.abortSignal.aborted) {
+          return;
+        }
+        onLine(line);
+      }
+    };
+    const timer = setInterval(() => {
+      if (!opts.abortSignal.aborted) {
+        tick();
+      }
+    }, pollMs);
+    opts.abortSignal.addEventListener("abort", () => {
+      clearInterval(timer);
+      resolve();
+    }, { once: true });
+    tick();
+  });
+}
+
 // ../bitfab-plugin-lib/dist/studioUrl.js
 var DEFAULT_STUDIO_PATH = "/studio";
 function resolveStudioInitialPath(input) {
@@ -10247,12 +10430,12 @@ function resolveStudioInitialPath(input) {
   return DEFAULT_STUDIO_PATH;
 }
 function buildStudioSessionUrl(args) {
-  const { serviceUrl, path: path18, sessionId } = args;
-  if (path18.includes("session=")) {
-    return `${serviceUrl}${path18}`;
+  const { serviceUrl, path: path19, sessionId } = args;
+  if (path19.includes("session=")) {
+    return `${serviceUrl}${path19}`;
   }
-  const separator = path18.includes("?") ? "&" : "?";
-  return `${serviceUrl}${path18}${separator}session=${encodeURIComponent(sessionId)}`;
+  const separator = path19.includes("?") ? "&" : "?";
+  return `${serviceUrl}${path19}${separator}session=${encodeURIComponent(sessionId)}`;
 }
 
 // ../bitfab-plugin-lib/dist/studioChannel.js
@@ -10266,10 +10449,13 @@ var DirectChannel = class {
   setApiKey(apiKey) {
     this.apiKey = apiKey;
   }
-  async openOrNavigate(path18, opts) {
+  isPersistent() {
+    return false;
+  }
+  async openOrNavigate(path19, opts) {
     if (!this.apiKey) {
-      const sessionId2 = opts?.sessionId ?? crypto6.randomUUID();
-      const initialPath = resolveStudioInitialPath(path18);
+      const sessionId2 = opts?.sessionId ?? crypto7.randomUUID();
+      const initialPath = resolveStudioInitialPath(path19);
       const url2 = buildStudioSessionUrl({
         serviceUrl: this.serviceUrl,
         path: initialPath,
@@ -10290,18 +10476,19 @@ var DirectChannel = class {
         serviceUrl: existing.serviceUrl,
         apiKey: this.apiKey,
         sessionId: existing.sessionId
-      }, path18);
+      }, path19);
       if (!ack.acked) {
         throw new StudioNavigationError(ack.reason ?? "unknown", ack.blockedReason, existing.sessionId);
       }
       return { sessionId: existing.sessionId, opened: false };
     }
-    const sessionId = opts?.sessionId ?? crypto6.randomUUID();
+    truncateStudioEventLog(resolveAgentSessionKey());
+    const sessionId = opts?.sessionId ?? crypto7.randomUUID();
     const session = await createStudioSession({
       serviceUrl: this.serviceUrl,
       apiKey: this.apiKey,
       sessionId,
-      initialPath: path18,
+      initialPath: path19,
       clientHeaders: opts?.clientHeaders
     });
     return { sessionId: session.sessionId, opened: true };
@@ -10365,17 +10552,21 @@ var DaemonChannel = class _DaemonChannel {
   setApiKey(apiKey) {
     this.apiKey = apiKey;
   }
-  async openOrNavigate(path18, opts) {
+  isPersistent() {
+    return true;
+  }
+  async openOrNavigate(path19, opts) {
     const openRes = await this.client.open({
       key: this.key,
       serviceUrl: this.serviceUrl,
       apiKey: this.apiKey,
       sessionId: opts?.sessionId,
-      initialPath: path18,
-      clientHeaders: opts?.clientHeaders
+      initialPath: path19,
+      clientHeaders: opts?.clientHeaders,
+      focusTarget: opts?.focusTarget
     });
     if (openRes.reconnected) {
-      const navRes = await this.client.navigate(this.key, path18);
+      const navRes = await this.client.navigate(this.key, path19);
       if (!navRes.acked) {
         this.client.destroy();
         throw new StudioNavigationError(navRes.reason ?? "unknown", void 0, openRes.sessionId);
@@ -10384,7 +10575,7 @@ var DaemonChannel = class _DaemonChannel {
         sessionId: openRes.sessionId,
         serviceUrl: this.serviceUrl,
         source: "daemon",
-        currentPath: path18
+        currentPath: path19
       });
       return { sessionId: openRes.sessionId, opened: false };
     }
@@ -10392,7 +10583,7 @@ var DaemonChannel = class _DaemonChannel {
       sessionId: openRes.sessionId,
       serviceUrl: this.serviceUrl,
       source: "daemon",
-      currentPath: path18
+      currentPath: path19
     });
     return { sessionId: openRes.sessionId, opened: true };
   }
@@ -10445,9 +10636,9 @@ function isDaemonEnabled() {
 function withDirectFallback(primary, apiKey, serviceUrl) {
   let active = primary;
   return {
-    async openOrNavigate(path18, opts) {
+    async openOrNavigate(path19, opts) {
       try {
-        return await active.openOrNavigate(path18, opts);
+        return await active.openOrNavigate(path19, opts);
       } catch (err) {
         if (err instanceof StudioNavigationError || active !== primary) {
           throw err;
@@ -10455,7 +10646,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(path18, opts);
+        return active.openOrNavigate(path19, opts);
       }
     },
     async close(sessionId, message) {
@@ -10473,6 +10664,9 @@ function withDirectFallback(primary, apiKey, serviceUrl) {
     setApiKey(key) {
       active.setApiKey(key);
     },
+    isPersistent() {
+      return active.isPersistent();
+    },
     destroy() {
       active.destroy();
     }
@@ -10503,12 +10697,12 @@ var semver3 = __toESM(require_semver2(), 1);
 
 // ../bitfab-plugin-lib/dist/installedSdk.js
 var semver2 = __toESM(require_semver2(), 1);
-import fs11 from "fs";
-import path10 from "path";
+import fs12 from "fs";
+import path11 from "path";
 
 // ../bitfab-plugin-lib/dist/workspaces.js
-import fs10 from "fs";
-import path9 from "path";
+import fs11 from "fs";
+import path10 from "path";
 
 // ../bitfab-plugin-lib/dist/analytics.js
 async function reportHandoff(apiKey, pluginVersion, platform2, body) {
@@ -10532,11 +10726,11 @@ async function reportHandoff(apiKey, pluginVersion, platform2, body) {
 }
 
 // ../bitfab-plugin-lib/dist/commands/openStudioTo.js
-import crypto7 from "crypto";
+import crypto8 from "crypto";
 
 // ../bitfab-plugin-lib/dist/frontmostApp.js
 import { execFileSync as execFileSync5, spawn as spawn2 } from "child_process";
-import os10 from "os";
+import os11 from "os";
 function findAncestorApp() {
   try {
     let pid = process.ppid;
@@ -10597,7 +10791,7 @@ function focusItermSession(sessionId) {
   spawnQuiet("osascript", ["-e", script]);
 }
 function getFrontmostApp() {
-  const platform2 = os10.platform();
+  const platform2 = os11.platform();
   try {
     if (platform2 === "darwin") {
       return execFileSync5("osascript", [
@@ -10631,7 +10825,7 @@ function focusApp(identifier) {
   if (!identifier) {
     return;
   }
-  const platform2 = os10.platform();
+  const platform2 = os11.platform();
   if (platform2 === "darwin") {
     spawnQuiet("osascript", [
       "-e",
@@ -10660,26 +10854,54 @@ function focusApp(identifier) {
     spawnQuiet("powershell.exe", ["-NoProfile", "-Command", script]);
   }
 }
-function recordFocus() {
-  const platform2 = os10.platform();
+function captureFocusTarget() {
+  const platform2 = os11.platform();
   if (platform2 === "linux") {
     const windowId = process.env.WINDOWID;
     if (windowId) {
-      return () => spawnQuiet("xdotool", ["windowactivate", windowId]);
+      return { kind: "linux-window", windowId };
     }
   }
   if (platform2 === "darwin") {
     const app = findAncestorApp();
     if (app) {
-      const itermSessionId = process.env.ITERM_SESSION_ID ?? null;
-      return () => focusAncestorApp(app, itermSessionId);
+      return {
+        kind: "mac-ancestor",
+        bundleName: app.bundleName,
+        executableName: app.executableName,
+        itermSessionId: process.env.ITERM_SESSION_ID ?? null
+      };
     }
   }
   const frontmost = getFrontmostApp();
-  return () => focusApp(frontmost);
+  return frontmost ? { kind: "frontmost", identifier: frontmost } : null;
+}
+function applyFocusTarget(target) {
+  if (!target) {
+    return;
+  }
+  switch (target.kind) {
+    case "linux-window":
+      spawnQuiet("xdotool", ["windowactivate", target.windowId]);
+      return;
+    case "mac-ancestor":
+      focusAncestorApp({
+        bundleName: target.bundleName,
+        executableName: target.executableName
+      }, target.itermSessionId);
+      return;
+    case "frontmost":
+      focusApp(target.identifier);
+      return;
+  }
 }
 
 // ../bitfab-plugin-lib/dist/commands/openStudioTo.js
+function lineToAgentEvent(line) {
+  const name = typeof line.event === "string" ? line.event : "";
+  const type = name.includes(":") ? name : `studio:${name}`;
+  return { id: "", type, data: line };
+}
 var WINDOW_CLOSE_GRACE_PERIOD_MS = 1e4;
 var LOGIN_TIMEOUT_MS = 10 * 60 * 1e3;
 function createEventSubscription(channel, sessionId, onEvent, restoreFocus) {
@@ -10746,23 +10968,92 @@ function createEventSubscription(channel, sessionId, onEvent, restoreFocus) {
     done: sub.done
   };
 }
-async function openStudioTo(path18, opts = {}) {
+async function openStudioTo(path19, opts = {}) {
   const config2 = getConfig();
   const serviceUrl = config2.serviceUrl;
   const apiKey = !opts.forceLogin && hasCredentials() ? config2.apiKey : null;
-  const noop = () => {
-  };
-  const restoreFocus = recordFocus();
+  const key = resolveAgentSessionKey();
+  const focusTarget = captureFocusTarget();
+  const restoreFocus = () => applyFocusTarget(focusTarget);
   const channel = await resolveChannel(apiKey ?? "", serviceUrl);
+  const finish = (sessionId2, opened2, resolvedApiKey) => {
+    const persistent = channel.isPersistent();
+    const base = {
+      sessionId: sessionId2,
+      serviceUrl,
+      apiKey: resolvedApiKey,
+      opened: opened2,
+      persistent
+    };
+    const wantsEvents = opts.tail || Boolean(opts.onEvent);
+    if (persistent) {
+      if (!wantsEvents || opts.tail) {
+        if (!opts.tail) {
+          restoreFocus();
+        }
+        return {
+          ...base,
+          abort: () => channel.destroy(),
+          done: Promise.resolve()
+        };
+      }
+      const subscription = createEventSubscription(channel, sessionId2, opts.onEvent ?? (() => {
+      }), restoreFocus);
+      return { ...base, ...subscription };
+    }
+    if (!wantsEvents) {
+      restoreFocus();
+      return {
+        ...base,
+        abort: () => channel.destroy(),
+        done: Promise.resolve()
+      };
+    }
+    if (tryClaimStudioMonitor()) {
+      const userOnEvent2 = opts.onEvent ?? (() => {
+      });
+      const sink = (event) => {
+        appendStudioEvent(key, studioEventToLogLine(event, sessionId2));
+        userOnEvent2(event);
+      };
+      const subscription = createEventSubscription(channel, sessionId2, sink, restoreFocus);
+      return {
+        ...base,
+        abort: subscription.abort,
+        done: subscription.done.finally(() => releaseStudioMonitor())
+      };
+    }
+    if (opts.tail) {
+      channel.destroy();
+      return { ...base, abort: () => {
+      }, done: Promise.resolve() };
+    }
+    const userOnEvent = opts.onEvent ?? (() => {
+    });
+    const abortController = new AbortController();
+    const done = tailStudioEvents(key, (line) => userOnEvent(lineToAgentEvent(line)), {
+      fromLine: readStudioEventLogTail(key).nextLine,
+      abortSignal: abortController.signal
+    });
+    return {
+      ...base,
+      abort: () => {
+        abortController.abort();
+        channel.destroy();
+      },
+      done
+    };
+  };
   if (!apiKey) {
-    const sessionId2 = crypto7.randomUUID();
-    const destination = opts.freshWindowPath ?? path18;
+    const sessionId2 = crypto8.randomUUID();
+    const destination = opts.freshWindowPath ?? path19;
     const destSeparator = destination.includes("?") ? "&" : "?";
     const redirectPath = `${destination}${destSeparator}session=${encodeURIComponent(sessionId2)}&pluginLogin=true`;
     const signInInitialPath = `/studio/sign-in?redirect_url=${encodeURIComponent(redirectPath)}&session=${encodeURIComponent(sessionId2)}`;
     await channel.openOrNavigate(signInInitialPath, {
       clientHeaders: opts.clientHeaders,
-      sessionId: sessionId2
+      sessionId: sessionId2,
+      focusTarget: focusTarget ?? void 0
     });
     const signInUrl = `${serviceUrl}${signInInitialPath}`;
     opts.onLoginRequired?.(sessionId2, signInUrl);
@@ -10790,37 +11081,13 @@ async function openStudioTo(path18, opts = {}) {
     saveCredentials(loginApiKey);
     opts.onAuthenticated?.(sessionId2);
     channel.setApiKey(loginApiKey);
-    if (opts.onEvent) {
-      const subscription2 = createEventSubscription(channel, sessionId2, opts.onEvent, restoreFocus);
-      return {
-        sessionId: sessionId2,
-        serviceUrl,
-        apiKey: loginApiKey,
-        opened: true,
-        ...subscription2
-      };
-    }
-    restoreFocus();
-    return {
-      sessionId: sessionId2,
-      serviceUrl,
-      apiKey: loginApiKey,
-      opened: true,
-      abort: noop,
-      done: Promise.resolve()
-    };
+    return finish(sessionId2, true, loginApiKey);
   }
-  const { sessionId, opened } = await channel.openOrNavigate(path18, {
-    clientHeaders: opts.clientHeaders
+  const { sessionId, opened } = await channel.openOrNavigate(path19, {
+    clientHeaders: opts.clientHeaders,
+    focusTarget: focusTarget ?? void 0
   });
-  const subscription = opts.onEvent ? createEventSubscription(channel, sessionId, opts.onEvent, restoreFocus) : { abort: () => channel.destroy(), done: Promise.resolve() };
-  return {
-    sessionId,
-    serviceUrl,
-    apiKey,
-    opened,
-    ...subscription
-  };
+  return finish(sessionId, opened, apiKey);
 }
 
 // ../bitfab-plugin-lib/dist/commands/login.js
@@ -11683,10 +11950,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path18) {
-  if (!path18)
+function getElementAtPath(obj, path19) {
+  if (!path19)
     return obj;
-  return path18.reduce((acc, key) => acc?.[key], obj);
+  return path19.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -12069,11 +12336,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path18, issues) {
+function prefixIssues(path19, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path18);
+    iss.path.unshift(path19);
     return iss;
   });
 }
@@ -12256,7 +12523,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path18 = []) => {
+  const processError = (error49, path19 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -12266,7 +12533,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path18, ...issue2.path];
+        const fullpath = [...path19, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -12298,8 +12565,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path18 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path18) {
+  const path19 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path19) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -24276,13 +24543,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path18 = ref.slice(1).split("/").filter(Boolean);
-  if (path18.length === 0) {
+  const path19 = ref.slice(1).split("/").filter(Boolean);
+  if (path19.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path18[0] === defsKey) {
-    const key = path18[1];
+  if (path19[0] === defsKey) {
+    const key = path19[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -24719,18 +24986,18 @@ import { tmpdir } from "os";
 import { join } from "path";
 
 // ../bitfab-plugin-lib/dist/activePreviewSession.js
-import fs12 from "fs";
-import os11 from "os";
-import path11 from "path";
-var FILE_PATH = path11.join(os11.homedir(), ".config", "bitfab", "active-preview-session.json");
+import fs13 from "fs";
+import os12 from "os";
+import path12 from "path";
+var FILE_PATH = path12.join(os12.homedir(), ".config", "bitfab", "active-preview-session.json");
 
 // ../bitfab-plugin-lib/dist/commands/status.js
-import path13 from "path";
+import path14 from "path";
 
 // ../bitfab-plugin-lib/dist/updates.js
-import fs13 from "fs";
-import os12 from "os";
-import path12 from "path";
+import fs14 from "fs";
+import os13 from "os";
+import path13 from "path";
 
 // ../bitfab-plugin-lib/dist/commands/update.js
 import { execSync as execSync2 } from "child_process";
@@ -24739,15 +25006,15 @@ import { execSync as execSync2 } from "child_process";
 var DEFAULT_TIMEOUT_MS = 10 * 60 * 1e3;
 
 // ../bitfab-plugin-lib/dist/hooks/captureHook.js
-import fs14 from "fs";
+import fs15 from "fs";
 
 // ../bitfab-plugin-lib/dist/hooks/userPromptSubmit.js
-import fs15 from "fs";
+import fs16 from "fs";
 
 // ../bitfab-plugin-lib/dist/installScope.js
-import fs16 from "fs";
-import os13 from "os";
-import path14 from "path";
+import fs17 from "fs";
+import os14 from "os";
+import path15 from "path";
 
 // ../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/helpers/util.js
 var util;
@@ -25108,8 +25375,8 @@ function getErrorMap2() {
 
 // ../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path18, errorMaps, issueData } = params;
-  const fullPath = [...path18, ...issueData.path || []];
+  const { data, path: path19, errorMaps, issueData } = params;
+  const fullPath = [...path19, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -25224,11 +25491,11 @@ var errorUtil;
 
 // ../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path18, key) {
+  constructor(parent, value, path19, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path18;
+    this._path = path19;
     this._key = key;
   }
   get path() {
@@ -30124,9 +30391,9 @@ import process3 from "process";
 
 // src/claude.ts
 import { spawnSync } from "child_process";
-import fs17 from "fs";
-import os14 from "os";
-import path15 from "path";
+import fs18 from "fs";
+import os15 from "os";
+import path16 from "path";
 import * as p from "@clack/prompts";
 var REPO = "Project-White-Rabbit/bitfab-claude-plugin";
 var MARKETPLACE = "bitfab";
@@ -30146,7 +30413,7 @@ function runClaudeInstall() {
   }
   s.start("Enabling auto-updates");
   const changed = enableAutoUpdate(
-    path15.join(os14.homedir(), ".claude", "settings.json")
+    path16.join(os15.homedir(), ".claude", "settings.json")
   );
   if (changed) {
     s.stop("Auto-updates enabled");
@@ -30237,8 +30504,8 @@ function runClaude(args) {
 }
 function enableAutoUpdate(settingsPath) {
   let settings = {};
-  if (fs17.existsSync(settingsPath)) {
-    const raw = fs17.readFileSync(settingsPath, "utf-8");
+  if (fs18.existsSync(settingsPath)) {
+    const raw = fs18.readFileSync(settingsPath, "utf-8");
     settings = raw.trim() === "" ? {} : JSON.parse(raw);
   }
   const marketplaces = settings.extraKnownMarketplaces ?? {};
@@ -30252,17 +30519,17 @@ function enableAutoUpdate(settingsPath) {
     autoUpdate: true
   };
   settings.extraKnownMarketplaces = marketplaces;
-  fs17.mkdirSync(path15.dirname(settingsPath), { recursive: true });
-  fs17.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
+  fs18.mkdirSync(path16.dirname(settingsPath), { recursive: true });
+  fs18.writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
 `);
   return true;
 }
 
 // src/codex.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import fs18 from "fs";
-import os15 from "os";
-import path16 from "path";
+import fs19 from "fs";
+import os16 from "os";
+import path17 from "path";
 import * as p2 from "@clack/prompts";
 var REPO2 = "Project-White-Rabbit/bitfab-codex-plugin";
 var PLUGIN_KEY2 = "bitfab@bitfab";
@@ -30290,7 +30557,7 @@ function runCodexInstall() {
   }
   s.start("Enabling bitfab plugin in config");
   const changed = enableCodexPlugin(
-    path16.join(os15.homedir(), ".codex", "config.toml")
+    path17.join(os16.homedir(), ".codex", "config.toml")
   );
   if (changed) {
     s.stop("Plugin enabled");
@@ -30353,8 +30620,8 @@ function runCodexUpdate(args, skipPermissions) {
 }
 function enableCodexPlugin(configPath) {
   let content = "";
-  if (fs18.existsSync(configPath)) {
-    content = fs18.readFileSync(configPath, "utf-8");
+  if (fs19.existsSync(configPath)) {
+    content = fs19.readFileSync(configPath, "utf-8");
   }
   const header = `[plugins."${PLUGIN_KEY2}"]`;
   const desiredSection = `${header}
@@ -30377,8 +30644,8 @@ enabled = true
 
 ${desiredSection}`;
   }
-  fs18.mkdirSync(path16.dirname(configPath), { recursive: true });
-  fs18.writeFileSync(configPath, next);
+  fs19.mkdirSync(path17.dirname(configPath), { recursive: true });
+  fs19.writeFileSync(configPath, next);
   return true;
 }
 function escapeRegex2(s) {
@@ -30387,7 +30654,7 @@ function escapeRegex2(s) {
 
 // src/cursor.ts
 import { spawn as spawn4, spawnSync as spawnSync3 } from "child_process";
-import os16 from "os";
+import os17 from "os";
 import * as p3 from "@clack/prompts";
 var REPO3 = "Project-White-Rabbit/bitfab-cursor-plugin";
 var ADD_PLUGIN_CMD = `/add-plugin ${REPO3}`;
@@ -30459,13 +30726,13 @@ function copyToClipboard(text) {
   return result.status === 0;
 }
 function clipboardCommand() {
-  if (os16.platform() === "darwin") {
+  if (os17.platform() === "darwin") {
     return { bin: "pbcopy", args: [] };
   }
-  if (os16.platform() === "linux") {
+  if (os17.platform() === "linux") {
     return { bin: "xclip", args: ["-selection", "clipboard"] };
   }
-  if (os16.platform() === "win32") {
+  if (os17.platform() === "win32") {
     return { bin: "clip", args: [] };
   }
   return null;
@@ -30489,12 +30756,12 @@ var platform = {
 };
 
 // src/version.ts
-import fs19 from "fs";
-import path17 from "path";
+import fs20 from "fs";
+import path18 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var CLI_VERSION = JSON.parse(
-  fs19.readFileSync(
-    path17.join(path17.dirname(fileURLToPath3(import.meta.url)), "../package.json"),
+  fs20.readFileSync(
+    path18.join(path18.dirname(fileURLToPath3(import.meta.url)), "../package.json"),
     "utf-8"
   )
 ).version;

package/package.json

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