bitfab-cli 0.2.10 → 0.2.12

package/dist/index.js

@@ -6805,6 +6805,307 @@ import { cancel as cancel2 } from "@clack/prompts";
 import { execSync as execSync3 } from "child_process";
 import * as p4 from "@clack/prompts";
 
+// ../bitfab-plugin-lib/dist/errors.js
+var NotAuthenticatedError = class extends Error {
+  constructor(message) {
+    super(message ?? "Not authenticated. Run the login command to connect your Bitfab account.");
+    this.name = "NotAuthenticatedError";
+  }
+};
+
+// ../bitfab-plugin-lib/dist/studioRoutes.js
+var STUDIO_ROUTE_PATTERNS = [
+  /^\/studio$/,
+  /^\/studio\/experiments$/,
+  /^\/studio\/close$/,
+  /^\/studio\/sign-in$/,
+  /^\/studio\/trace-plan\/[^/]+$/,
+  /^\/studio\/trace-functions\/[^/]+\/datasets\/labeled$/,
+  /^\/studio\/trace-functions\/[^/]+\/datasets\/[^/]+$/,
+  /^\/studio\/trace-functions\/[^/]+\/template-preview$/,
+  /^\/studio\/trace-functions\/[^/]+\/template-preview\/[^/]+$/,
+  /^\/studio\/auth\/[^/]+$/
+];
+function isValidStudioRoute(input) {
+  const pathname = input.split("?")[0];
+  return STUDIO_ROUTE_PATTERNS.some((pattern) => pattern.test(pathname));
+}
+
+// ../bitfab-plugin-lib/dist/agentSessionChannel.js
+var DEFAULT_POLL_INTERVAL_MS = 1500;
+async function createAgentSession(opts) {
+  if (!opts.apiKey) {
+    throw new NotAuthenticatedError();
+  }
+  const url2 = `${opts.serviceUrl}/api/studio/sessions`;
+  const res = await fetch(url2, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${opts.apiKey}`,
+      "Content-Type": "application/json",
+      ...opts.extraHeaders
+    },
+    body: JSON.stringify({ sessionId: opts.sessionId })
+  });
+  if (!res.ok) {
+    if (res.status === 401) {
+      throw new NotAuthenticatedError("Session expired or invalid. Run the login command to re-authenticate.");
+    }
+    throw new Error(`createAgentSession failed (${res.status}): ${await res.text()}`);
+  }
+  return await res.json();
+}
+async function pushAgentSessionEvent(client, event) {
+  const url2 = `${client.serviceUrl}/api/studio/events`;
+  const res = await fetch(url2, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${client.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      session: client.sessionId,
+      type: event.type,
+      data: event.data
+    })
+  });
+  if (!res.ok) {
+    throw new Error(`pushAgentSessionEvent failed (${res.status}): ${await res.text()}`);
+  }
+  return await res.json();
+}
+async function pollAgentSessionEvents(opts) {
+  const interval = opts.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  const client = {
+    serviceUrl: opts.serviceUrl,
+    apiKey: opts.apiKey,
+    sessionId: opts.sessionId
+  };
+  let since = opts.startCursor ?? null;
+  while (!opts.abortSignal.aborted) {
+    try {
+      const url2 = new URL(`${opts.serviceUrl}/api/studio/events`);
+      url2.searchParams.set("session", opts.sessionId);
+      if (since) {
+        url2.searchParams.set("since", since);
+      }
+      const res = await fetch(url2.toString(), {
+        headers: { Authorization: `Bearer ${opts.apiKey}` },
+        signal: opts.abortSignal
+      });
+      if (res.ok) {
+        const body = await res.json();
+        for (const event of body.events) {
+          if (event.type === "studio:ping") {
+            sendPong(client, event.data.ts).catch(() => {
+            });
+          }
+          opts.onEvent(event);
+          since = event.id;
+        }
+        if (opts.onBrowserStatus && typeof body.browserConnected === "boolean") {
+          opts.onBrowserStatus(body.browserConnected);
+        }
+      } else if (opts.onError) {
+        opts.onError(new Error(`agent-session poll failed (${res.status})`));
+      }
+    } catch (err) {
+      if (opts.abortSignal.aborted) {
+        return;
+      }
+      if (opts.onError) {
+        opts.onError(err instanceof Error ? err : new Error(String(err)));
+      }
+    }
+    await new Promise((resolve) => {
+      const onAbort = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+      const timer = setTimeout(() => {
+        opts.abortSignal.removeEventListener("abort", onAbort);
+        resolve();
+      }, interval);
+      opts.abortSignal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+}
+async function pollLoginEvents(opts) {
+  const interval = opts.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  let since = null;
+  while (!opts.abortSignal.aborted) {
+    try {
+      const url2 = new URL(`${opts.serviceUrl}/api/studio/sessions/poll`);
+      url2.searchParams.set("session", opts.sessionId);
+      if (since) {
+        url2.searchParams.set("since", since);
+      }
+      const res = await fetch(url2.toString(), {
+        signal: opts.abortSignal
+      });
+      if (res.ok) {
+        const body = await res.json();
+        for (const event of body.events) {
+          since = event.id;
+          if (event.type === "studio:authenticated" && typeof event.data.token === "string") {
+            return event.data.token;
+          }
+        }
+      }
+    } catch {
+      if (opts.abortSignal.aborted) {
+        break;
+      }
+    }
+    await new Promise((resolve) => {
+      const onAbort = () => {
+        clearTimeout(timer);
+        resolve();
+      };
+      const timer = setTimeout(() => {
+        opts.abortSignal.removeEventListener("abort", onAbort);
+        resolve();
+      }, interval);
+      opts.abortSignal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  throw new Error("Login polling aborted");
+}
+async function navigateStudio(client, path14) {
+  if (!isValidStudioRoute(path14)) {
+    throw new Error(`Studio route not allowed: ${path14}`);
+  }
+  return pushAgentSessionEvent(client, {
+    type: "agent:navigate",
+    data: { path: path14 }
+  });
+}
+var STUDIO_NAVIGATE_ACK_TIMEOUT_MS = 12e3;
+var PING_PONG_TIMEOUT_MS = 5e3;
+function awaitNavigateAck(client, path14, ackTimeoutMs) {
+  const abortController = new AbortController();
+  let timer = null;
+  const result = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      resolve({ acked: false, reason: "timeout" });
+      abortController.abort();
+    }, ackTimeoutMs);
+    const pathOnly = path14.split("?")[0];
+    pollAgentSessionEvents({
+      serviceUrl: client.serviceUrl,
+      apiKey: client.apiKey,
+      sessionId: client.sessionId,
+      abortSignal: abortController.signal,
+      onEvent: (event) => {
+        if (event.type === "studio:navigated" && event.data.path === pathOnly) {
+          if (timer) {
+            clearTimeout(timer);
+          }
+          resolve({ acked: true });
+          abortController.abort();
+          return;
+        }
+        if (event.type === "studio:navigation-blocked" && event.data.path === pathOnly) {
+          if (timer) {
+            clearTimeout(timer);
+          }
+          resolve({
+            acked: false,
+            reason: "blocked",
+            blockedReason: event.data.reason
+          });
+          abortController.abort();
+          return;
+        }
+        if (event.type === "studio:session-ended" || event.type === "studio:session-closed") {
+          if (timer) {
+            clearTimeout(timer);
+          }
+          resolve({ acked: false, reason: "session-ended" });
+          abortController.abort();
+        }
+      },
+      onError: () => {
+      }
+    }).catch(() => {
+      if (abortController.signal.aborted) {
+        return;
+      }
+      if (timer) {
+        clearTimeout(timer);
+      }
+      resolve({ acked: false, reason: "timeout" });
+    });
+  });
+  return result;
+}
+function awaitPong(client, pingTs) {
+  return new Promise((resolve) => {
+    const abortController = new AbortController();
+    let received = false;
+    const timer = setTimeout(() => {
+      abortController.abort();
+      resolve(false);
+    }, PING_PONG_TIMEOUT_MS);
+    pollAgentSessionEvents({
+      serviceUrl: client.serviceUrl,
+      apiKey: client.apiKey,
+      sessionId: client.sessionId,
+      abortSignal: abortController.signal,
+      onEvent: (event) => {
+        if (event.type === "studio:pong" && event.data.replyTo === pingTs) {
+          received = true;
+          clearTimeout(timer);
+          abortController.abort();
+          resolve(true);
+        }
+      },
+      onError: () => {
+      }
+    }).catch(() => {
+      if (!received) {
+        clearTimeout(timer);
+        resolve(false);
+      }
+    });
+  });
+}
+async function navigateStudioAndAwaitAck(client, path14, opts = {}) {
+  const ackTimeoutMs = opts.ackTimeoutMs ?? STUDIO_NAVIGATE_ACK_TIMEOUT_MS;
+  if (!isValidStudioRoute(path14)) {
+    return { acked: false, reason: "invalid-route" };
+  }
+  try {
+    await navigateStudio(client, path14);
+  } catch {
+    return { acked: false, reason: "push-failed" };
+  }
+  const result = await awaitNavigateAck(client, path14, ackTimeoutMs);
+  if (result.acked || result.reason !== "timeout") {
+    return result;
+  }
+  const pingTs = Date.now();
+  try {
+    await pushAgentSessionEvent(client, {
+      type: "agent:ping",
+      data: { ts: pingTs }
+    });
+  } catch {
+    return result;
+  }
+  const pongReceived = await awaitPong(client, pingTs);
+  if (pongReceived) {
+    return { acked: true };
+  }
+  return result;
+}
+async function sendPong(client, replyTo) {
+  return pushAgentSessionEvent(client, {
+    type: "agent:pong",
+    data: { ts: Date.now(), replyTo }
+  });
+}
+
 // ../bitfab-plugin-lib/dist/buildInfo.js
 import crypto from "crypto";
 import fs from "fs";
@@ -6840,9 +7141,9 @@ var GLOBAL_CONFIG_FILE = path3.join(GLOBAL_CONFIG_DIR, "config.json");
 var GLOBAL_CREDENTIALS_FILE = path3.join(GLOBAL_CONFIG_DIR, "credentials.json");
 var PROJECT_CONFIG_RELATIVE = path3.join(".bitfab", "config.local.json");
 var PROJECT_CREDENTIALS_RELATIVE = path3.join(".bitfab", "credentials.local.json");
-function readJsonFile(filePath) {
+function readJsonFile(filePath2) {
   try {
-    const content = fs3.readFileSync(filePath, "utf-8");
+    const content = fs3.readFileSync(filePath2, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -6863,18 +7164,18 @@ function findProjectFile(relativePath, startDir = process.cwd()) {
   }
 }
 function getProjectConfigData() {
-  const filePath = findProjectFile(PROJECT_CONFIG_RELATIVE);
-  if (!filePath) {
+  const filePath2 = findProjectFile(PROJECT_CONFIG_RELATIVE);
+  if (!filePath2) {
     return null;
   }
-  return readJsonFile(filePath);
+  return readJsonFile(filePath2);
 }
 function getProjectCredentialsData() {
-  const filePath = findProjectFile(PROJECT_CREDENTIALS_RELATIVE);
-  if (!filePath) {
+  const filePath2 = findProjectFile(PROJECT_CREDENTIALS_RELATIVE);
+  if (!filePath2) {
     return null;
   }
-  return readJsonFile(filePath) ?? {};
+  return readJsonFile(filePath2) ?? {};
 }
 function getConfigData() {
   return readJsonFile(GLOBAL_CONFIG_FILE) ?? {};
@@ -6941,6 +7242,12 @@ function getConfig() {
   };
 }
 function saveCredentials(apiKey) {
+  const projectFile = findProjectFile(PROJECT_CREDENTIALS_RELATIVE);
+  if (projectFile) {
+    fs3.writeFileSync(projectFile, `${JSON.stringify({ apiKey }, null, 2)}
+`);
+    return;
+  }
   fs3.mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true });
   fs3.writeFileSync(GLOBAL_CREDENTIALS_FILE, `${JSON.stringify({ apiKey }, null, 2)}
 `);
@@ -6996,36 +7303,62 @@ function buildBitfabRequestHeaders(apiKey, pluginVersion, platform2) {
   };
 }
 
-// ../bitfab-plugin-lib/dist/commands/login.js
+// ../bitfab-plugin-lib/dist/activeStudioSession.js
 import crypto3 from "crypto";
-
-// ../bitfab-plugin-lib/dist/analytics.js
-async function reportHandoff(apiKey, pluginVersion, platform2, body) {
-  const config2 = getConfig();
-  const headers = buildBitfabRequestHeaders(apiKey, pluginVersion, platform2);
+import fs6 from "fs";
+import os6 from "os";
+import path5 from "path";
+function cwdHash() {
+  return crypto3.createHash("sha256").update(process.cwd()).digest("hex").slice(0, 16);
+}
+function filePath() {
+  return path5.join(os6.homedir(), ".config", "bitfab", `active-studio-session.${cwdHash()}.json`);
+}
+function writeActiveStudioSession(session) {
+  const target = filePath();
+  fs6.mkdirSync(path5.dirname(target), { recursive: true });
+  const payload = {
+    ...session,
+    pid: process.pid,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const tmp = `${target}.${process.pid}.tmp`;
+  fs6.writeFileSync(tmp, `${JSON.stringify(payload, null, 2)}
+`);
+  fs6.renameSync(tmp, target);
+}
+function clearActiveStudioSession() {
   try {
-    const response = await fetch(`${config2.serviceUrl}/api/plugin/analytics/handoff`, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body)
-    });
-    if (config2.debug && !response.ok) {
-      console.error(`reportHandoff: server returned ${response.status} for ${body.flow}`);
+    const current = readActiveStudioSessionRaw();
+    if (current && current.pid !== process.pid) {
+      return;
     }
-  } catch (err) {
-    if (config2.debug) {
-      const message = err instanceof Error ? err.message : String(err);
-      console.error(`reportHandoff: request failed for ${body.flow}: ${message}`);
+    fs6.rmSync(filePath(), { force: true });
+  } catch {
+  }
+}
+function readActiveStudioSessionRaw() {
+  try {
+    const raw = fs6.readFileSync(filePath(), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.sessionId === "string" && typeof parsed.serviceUrl === "string" && typeof parsed.pid === "number" && typeof parsed.startedAt === "string") {
+      return parsed;
     }
+    return null;
+  } catch {
+    return null;
   }
 }
+function readActiveStudioSession() {
+  return readActiveStudioSessionRaw();
+}
 
 // ../bitfab-plugin-lib/dist/browser.js
 import { execSync, spawn } from "child_process";
-import fs6 from "fs";
-import os6 from "os";
+import fs7 from "fs";
+import os7 from "os";
 function getChromiumBrowsers() {
-  const platform2 = os6.platform();
+  const platform2 = os7.platform();
   if (platform2 === "darwin") {
     return [
       {
@@ -7113,7 +7446,7 @@ function getChromiumBrowsers() {
 function findExistingBinary(paths) {
   for (const candidate of paths) {
     if (candidate.includes("/") || candidate.includes("\\")) {
-      if (fs6.existsSync(candidate)) {
+      if (fs7.existsSync(candidate)) {
         return candidate;
       }
     } else {
@@ -7127,10 +7460,10 @@ function findExistingBinary(paths) {
   return null;
 }
 function getDefaultBrowserId() {
-  const platform2 = os6.platform();
+  const platform2 = os7.platform();
   try {
     if (platform2 === "darwin") {
-      const plistPath = `${os6.homedir()}/Library/Preferences/com.apple.LaunchServices/com.apple.launchservices.secure.plist`;
+      const plistPath = `${os7.homedir()}/Library/Preferences/com.apple.LaunchServices/com.apple.launchservices.secure.plist`;
       const json2 = execSync(`plutil -convert json -o - "${plistPath}"`, {
         stdio: ["ignore", "pipe", "ignore"],
         encoding: "utf-8",
@@ -7171,7 +7504,7 @@ function matchChromiumBrowser(defaultId, browsers) {
 var SCREEN_FRACTION = 0.95;
 function getWorkArea() {
   try {
-    const platform2 = os6.platform();
+    const platform2 = os7.platform();
     if (platform2 === "darwin") {
       const out = execSync(`osascript -l JavaScript -e 'ObjC.import("AppKit"); const s = $.NSScreen.mainScreen; const f = s.frame; const v = s.visibleFrame; const topY = f.size.height - (v.origin.y + v.size.height); JSON.stringify([v.origin.x, topY, v.size.width, v.size.height])'`, {
         stdio: ["ignore", "pipe", "ignore"],
@@ -7240,7 +7573,7 @@ function openChromiumApp(binaryPath, url2, sizeArgs) {
   spawnDetached(binaryPath, [`--app=${url2}`, ...sizeArgs]);
 }
 function openOsDefault(url2) {
-  const platform2 = os6.platform();
+  const platform2 = os7.platform();
   if (platform2 === "darwin") {
     spawnDetached("open", [url2]);
   } else if (platform2 === "win32") {
@@ -7291,9 +7624,61 @@ function openChromelessWindow(url2) {
   openOsDefault(url2);
 }
 
+// ../bitfab-plugin-lib/dist/commands/createStudioSession.js
+function ensureStudioPath(p5) {
+  if (!p5.startsWith("/studio")) {
+    return "/studio";
+  }
+  return p5;
+}
+async function createStudioSession({ serviceUrl, apiKey, sessionId, initialPath = "/studio", clientHeaders }) {
+  if (!apiKey) {
+    throw new NotAuthenticatedError();
+  }
+  initialPath = ensureStudioPath(initialPath);
+  if (!isValidStudioRoute(initialPath)) {
+    throw new Error(`Studio route not allowed: ${initialPath}`);
+  }
+  await createAgentSession({
+    serviceUrl,
+    apiKey,
+    sessionId,
+    extraHeaders: clientHeaders
+  });
+  writeActiveStudioSession({ sessionId, serviceUrl });
+  const separator = initialPath.includes("?") ? "&" : "?";
+  const url2 = `${serviceUrl}${initialPath}${separator}session=${encodeURIComponent(sessionId)}`;
+  openChromelessWindow(url2);
+  return { sessionId, serviceUrl };
+}
+
+// ../bitfab-plugin-lib/dist/commands/login.js
+import crypto5 from "crypto";
+
+// ../bitfab-plugin-lib/dist/analytics.js
+async function reportHandoff(apiKey, pluginVersion, platform2, body) {
+  const config2 = getConfig();
+  const headers = buildBitfabRequestHeaders(apiKey, pluginVersion, platform2);
+  try {
+    const response = await fetch(`${config2.serviceUrl}/api/plugin/analytics/handoff`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    });
+    if (config2.debug && !response.ok) {
+      console.error(`reportHandoff: server returned ${response.status} for ${body.flow}`);
+    }
+  } catch (err) {
+    if (config2.debug) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(`reportHandoff: request failed for ${body.flow}: ${message}`);
+    }
+  }
+}
+
 // ../bitfab-plugin-lib/dist/frontmostApp.js
 import { execFileSync as execFileSync2, spawn as spawn2 } from "child_process";
-import os7 from "os";
+import os8 from "os";
 function findAncestorApp() {
   try {
     let pid = process.ppid;
@@ -7354,7 +7739,7 @@ function focusItermSession(sessionId) {
   spawnQuiet("osascript", ["-e", script]);
 }
 function getFrontmostApp() {
-  const platform2 = os7.platform();
+  const platform2 = os8.platform();
   try {
     if (platform2 === "darwin") {
       return execFileSync2("osascript", [
@@ -7388,7 +7773,7 @@ function focusApp(identifier) {
   if (!identifier) {
     return;
   }
-  const platform2 = os7.platform();
+  const platform2 = os8.platform();
   if (platform2 === "darwin") {
     spawnQuiet("osascript", [
       "-e",
@@ -7418,7 +7803,7 @@ function focusApp(identifier) {
   }
 }
 function recordFocus() {
-  const platform2 = os7.platform();
+  const platform2 = os8.platform();
   if (platform2 === "linux") {
     const windowId = process.env.WINDOWID;
     if (windowId) {
@@ -7436,9 +7821,151 @@ function recordFocus() {
   return () => focusApp(frontmost);
 }
 
-// ../bitfab-plugin-lib/dist/commands/login.js
+// ../bitfab-plugin-lib/dist/commands/openStudioTo.js
+import crypto4 from "crypto";
+
+// ../bitfab-plugin-lib/dist/commands/loginForSession.js
 var LOGIN_TIMEOUT_MS = 10 * 60 * 1e3;
-var POLL_INTERVAL_MS = 1500;
+
+// ../bitfab-plugin-lib/dist/commands/openStudioTo.js
+var SESSION_CLOSE_GRACE_PERIOD_MS = 1e4;
+var StudioNavigationError = class extends Error {
+  reason;
+  blockedReason;
+  staleSessionId;
+  constructor(reason, blockedReason, staleSessionId) {
+    super(blockedReason ? `Studio navigation failed (${reason}): ${blockedReason}` : `Studio navigation failed: ${reason}`);
+    this.reason = reason;
+    this.blockedReason = blockedReason;
+    this.staleSessionId = staleSessionId;
+    this.name = "StudioNavigationError";
+  }
+};
+async function openStudioTo(path14, opts) {
+  const sessionId = opts.sessionId ?? crypto4.randomUUID();
+  const noop = () => {
+  };
+  const restoreFocus = recordFocus();
+  if (!opts.apiKey) {
+    const separator = path14.includes("?") ? "&" : "?";
+    const url2 = `${opts.serviceUrl}${path14}${separator}session=${encodeURIComponent(sessionId)}`;
+    openChromelessWindow(url2);
+    return {
+      sessionId,
+      serviceUrl: opts.serviceUrl,
+      opened: true,
+      abort: noop,
+      done: Promise.resolve()
+    };
+  }
+  if (opts.forceNew) {
+    clearActiveStudioSession();
+  }
+  const existing = opts.forceNew ? null : readActiveStudioSession();
+  if (existing) {
+    const client = {
+      serviceUrl: existing.serviceUrl,
+      apiKey: opts.apiKey,
+      sessionId: existing.sessionId
+    };
+    const ack = await navigateStudioAndAwaitAck(client, path14);
+    if (ack.acked) {
+      const poller2 = opts.onEvent ? startEventPoller(existing.serviceUrl, opts.apiKey, existing.sessionId, opts.onEvent, restoreFocus) : { abort: noop, done: Promise.resolve() };
+      return {
+        sessionId: existing.sessionId,
+        serviceUrl: existing.serviceUrl,
+        opened: false,
+        ...poller2
+      };
+    }
+    if (ack.reason === "session-ended" || ack.reason === "push-failed") {
+      if (ack.reason === "session-ended") {
+        clearActiveStudioSession();
+      }
+    } else {
+      throw new StudioNavigationError(ack.reason ?? "unknown", ack.blockedReason, existing.sessionId);
+    }
+  }
+  const session = await createStudioSession({
+    serviceUrl: opts.serviceUrl,
+    apiKey: opts.apiKey,
+    sessionId,
+    initialPath: path14,
+    clientHeaders: opts.clientHeaders
+  });
+  const poller = opts.onEvent ? startEventPoller(session.serviceUrl, opts.apiKey, session.sessionId, opts.onEvent, restoreFocus) : { abort: noop, done: Promise.resolve() };
+  return {
+    sessionId: session.sessionId,
+    serviceUrl: session.serviceUrl,
+    opened: true,
+    ...poller
+  };
+}
+function startEventPoller(serviceUrl, apiKey, sessionId, onEvent, restoreFocus) {
+  const abortController = new AbortController();
+  let sessionEndGraceTimer = null;
+  const done = pollAgentSessionEvents({
+    serviceUrl,
+    apiKey,
+    sessionId,
+    abortSignal: abortController.signal,
+    onEvent: (event) => {
+      if (event.type === "studio:session-closed") {
+        if (sessionEndGraceTimer) {
+          return;
+        }
+        sessionEndGraceTimer = setTimeout(() => {
+          sessionEndGraceTimer = null;
+          clearActiveStudioSession();
+          restoreFocus();
+          onEvent({ ...event, type: "studio:session-ended" });
+          abortController.abort();
+        }, SESSION_CLOSE_GRACE_PERIOD_MS);
+        return;
+      }
+      if (event.type === "studio:session-started") {
+        if (sessionEndGraceTimer) {
+          clearTimeout(sessionEndGraceTimer);
+          sessionEndGraceTimer = null;
+          console.error("Studio reconnected after page refresh");
+        }
+        return;
+      }
+      if (event.type === "studio:session-ended") {
+        if (sessionEndGraceTimer) {
+          clearTimeout(sessionEndGraceTimer);
+          sessionEndGraceTimer = null;
+        }
+        clearActiveStudioSession();
+        restoreFocus();
+        onEvent(event);
+        abortController.abort();
+        return;
+      }
+      if (event.type === "studio:not-member") {
+        restoreFocus();
+        onEvent(event);
+        abortController.abort();
+        return;
+      }
+      if (event.type === "studio:return-to-agent" || event.type === "studio:edit-with-agent") {
+        restoreFocus();
+      }
+      onEvent(event);
+    },
+    onError: (err) => {
+      console.error(`studio agent-event poll: ${err.message}`);
+    }
+  }).catch((err) => {
+    if (!abortController.signal.aborted) {
+      console.error(`studio agent-event poll terminated: ${err.message}`);
+    }
+  });
+  return { abort: () => abortController.abort(), done };
+}
+
+// ../bitfab-plugin-lib/dist/commands/login.js
+var LOGIN_TIMEOUT_MS2 = 10 * 60 * 1e3;
 async function verifyToken(serviceUrl, token) {
   try {
     const res = await fetch(`${serviceUrl}/api/plugin/whoami`, {
@@ -7452,58 +7979,50 @@ async function verifyToken(serviceUrl, token) {
     return null;
   }
 }
-async function pollLoginStatus(serviceUrl, loginId, signal) {
-  while (!signal.aborted) {
-    try {
-      const url2 = `${serviceUrl}/api/studio/login-status?loginId=${encodeURIComponent(loginId)}`;
-      const res = await fetch(url2, { signal });
-      if (res.ok) {
-        const body = await res.json();
-        if (body.status === "complete" && body.token) {
-          return body.token;
-        }
-      }
-    } catch {
-      if (signal.aborted) {
-        throw new Error("Login polling aborted");
-      }
-    }
-    await new Promise((resolve) => {
-      const timer = setTimeout(resolve, POLL_INTERVAL_MS);
-      signal.addEventListener("abort", () => {
-        clearTimeout(timer);
-        resolve();
-      }, { once: true });
-    });
-  }
-  throw new Error("Login polling aborted");
-}
 async function runLogin(platform2, pluginVersion, options) {
   const exitOnComplete = options?.exitOnComplete ?? true;
   const config2 = getConfig();
   const restoreFocus = recordFocus();
-  const loginId = crypto3.randomUUID();
-  const redirectUrl = `/studio/close?pluginLogin=true&loginId=${loginId}`;
-  const browserUrl = `${config2.serviceUrl}/studio/sign-in?redirect_url=${encodeURIComponent(redirectUrl)}`;
+  const sessionId = crypto5.randomUUID();
+  const redirectPath = `/studio/close?pluginLogin=true&session=${sessionId}&autoClose=true&message=${encodeURIComponent("Login complete")}`;
+  const signInPath = `/studio/sign-in?redirect_url=${encodeURIComponent(redirectPath)}`;
   console.log("\nOpening Studio to sign in...");
-  console.log(`  ${browserUrl}`);
-  console.log("");
-  console.log("(If the browser didn't open, visit the URL above manually.)");
-  openChromelessWindow(browserUrl);
+  console.log("(If the browser didn't open, visit the Studio URL manually.)");
+  try {
+    await openStudioTo(signInPath, {
+      apiKey: hasCredentials() ? config2.apiKey : null,
+      serviceUrl: config2.serviceUrl,
+      sessionId
+    });
+  } catch (err) {
+    if (err instanceof StudioNavigationError) {
+      await openStudioTo(signInPath, {
+        apiKey: null,
+        serviceUrl: config2.serviceUrl,
+        sessionId
+      });
+    } else {
+      throw err;
+    }
+  }
   const abortController = new AbortController();
   let loginTimer;
   const timeoutPromise = new Promise((_resolve, reject) => {
     loginTimer = setTimeout(() => {
       abortController.abort();
       reject(new Error("Authentication timed out after 10 minutes. Run login again."));
-    }, LOGIN_TIMEOUT_MS);
+    }, LOGIN_TIMEOUT_MS2);
   });
   const keepaliveTimer = setInterval(() => {
     process.stdout.write("");
   }, 3e4);
   try {
     const token = await Promise.race([
-      pollLoginStatus(config2.serviceUrl, loginId, abortController.signal),
+      pollLoginEvents({
+        serviceUrl: config2.serviceUrl,
+        sessionId,
+        abortSignal: abortController.signal
+      }),
       timeoutPromise
     ]);
     if (loginTimer) {
@@ -7511,11 +8030,6 @@ async function runLogin(platform2, pluginVersion, options) {
     }
     clearInterval(keepaliveTimer);
     saveCredentials(token);
-    const who = await verifyToken(config2.serviceUrl, token);
-    const greeting = who?.user.email ? `Logged in as ${who.user.email}.` : "Authentication successful.";
-    console.log(`
-${greeting}`);
-    console.log("Bitfab MCP tools are now active. (via studio)");
     await reportHandoff(token, pluginVersion, platform2, {
       flow: "auth.login",
       wonBy: "studio",
@@ -7523,6 +8037,11 @@ ${greeting}`);
       ticketAvailable: false
     });
     restoreFocus();
+    const who = await verifyToken(config2.serviceUrl, token);
+    const greeting = who?.user.email ? `Logged in as ${who.user.email}.` : "Authentication successful.";
+    console.log(`
+${greeting}`);
+    console.log("Bitfab MCP tools are now active. (via studio)");
     if (exitOnComplete) {
       process.exit(0);
     }
@@ -7552,19 +8071,8 @@ function runLogout() {
   console.log("Logged out of Bitfab.");
 }
 
-// ../bitfab-plugin-lib/dist/commands/openStudio.js
-import crypto5 from "crypto";
-
-// ../bitfab-plugin-lib/dist/activeStudioSession.js
-import crypto4 from "crypto";
-import fs7 from "fs";
-import os8 from "os";
-import path5 from "path";
-
-// ../bitfab-plugin-lib/dist/withStudioSession.js
-import crypto6 from "crypto";
-
 // ../bitfab-plugin-lib/dist/commands/openTracePlan.js
+import crypto6 from "crypto";
 var OPEN_TRACE_PLAN_TIMEOUT_MS = 30 * 60 * 1e3;
 
 // ../bitfab-plugin-lib/dist/commands/persistReplayLabels.js
@@ -21364,6 +21872,12 @@ var inputFileSchema = external_exports.object({
   verdicts: external_exports.array(external_exports.unknown()).min(1)
 });
 
+// ../bitfab-plugin-lib/dist/commands/startDataset.js
+import crypto7 from "crypto";
+
+// ../bitfab-plugin-lib/dist/commands/startTemplatePreview.js
+import crypto8 from "crypto";
+
 // ../bitfab-plugin-lib/dist/activePreviewSession.js
 import fs8 from "fs";
 import os9 from "os";
@@ -27390,7 +27904,7 @@ Examples:
   bitfab setup --skip-permissions          Setup without permission prompts
   bitfab assistant --skip-permissions      Run assistant autonomously
 `;
-function parseArgs(argv) {
+function parseArgs2(argv) {
   const [command, ...tail] = argv;
   let editor;
   let skipPermissions;
@@ -27417,7 +27931,7 @@ function parseArgs(argv) {
   return { command, editor, skipPermissions, rest };
 }
 async function main() {
-  const { command, editor, skipPermissions, rest } = parseArgs(
+  const { command, editor, skipPermissions, rest } = parseArgs2(
     process.argv.slice(2)
   );
   const abortUpdateCheck = startUpdateCheck();
@@ -27473,5 +27987,5 @@ main().catch((err) => {
   process.exit(1);
 });
 export {
-  parseArgs
+  parseArgs2 as parseArgs
 };

package/package.json

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