bitfab-cli 0.2.45 → 0.2.46

package/dist/index.js

@@ -6972,6 +6972,79 @@ async function pollLoginEvents(opts) {
   }
   throw new Error("Login polling aborted");
 }
+var STUDIO_SESSION_SCOPE_HEADER = "x-bitfab-auth-scope";
+var STUDIO_SESSION_SCOPE_VALUE = "session";
+async function requestSessionReauth(opts) {
+  try {
+    const res = await fetch(`${opts.serviceUrl}/api/studio/events`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        [STUDIO_SESSION_SCOPE_HEADER]: STUDIO_SESSION_SCOPE_VALUE
+      },
+      body: JSON.stringify({
+        session: opts.sessionId,
+        type: "agent:request-reauth",
+        data: { redirectPath: opts.redirectPath }
+      })
+    });
+    if (!res.ok) {
+      return { ok: false };
+    }
+    const body = await res.json();
+    return {
+      ok: true,
+      pushedEventId: body.id,
+      signInUrl: `${opts.serviceUrl}${body.signInPath}`
+    };
+  } catch {
+    return { ok: false };
+  }
+}
+async function pollSessionAuthEvents(opts) {
+  const interval = opts.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+  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: {
+          [STUDIO_SESSION_SCOPE_HEADER]: STUDIO_SESSION_SCOPE_VALUE
+        },
+        signal: opts.abortSignal
+      });
+      if (res.ok) {
+        const body = await res.json();
+        for (const event of body.events) {
+          since = event.id;
+          opts.onEvent(event);
+        }
+        if (body.cursor) {
+          since = body.cursor;
+        }
+      }
+    } catch {
+      if (opts.abortSignal.aborted) {
+        return;
+      }
+    }
+    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 fetchStreamTip(client) {
   const PAGE_LIMIT = 500;
   const MAX_PAGES = 10;
@@ -7964,6 +8037,7 @@ async function waitForSessionReady(opts) {
 
 // ../bitfab-plugin-lib/dist/commands/openStudioTo.js
 var LOGIN_TIMEOUT_MS = 10 * 60 * 1e3;
+var REAUTH_ACK_TIMEOUT_MS = 2e4;
 var StudioNavigationError = class extends Error {
   reason;
   blockedReason;
@@ -7979,14 +8053,34 @@ var StudioNavigationError = class extends Error {
 async function openStudioTo(path15, opts = {}) {
   const config2 = getConfig();
   const serviceUrl = config2.serviceUrl;
-  const apiKey = hasCredentials() ? config2.apiKey : null;
+  const apiKey = !opts.forceLogin && hasCredentials() ? config2.apiKey : null;
   const noop = () => {
   };
   const restoreFocus = recordFocus();
   if (!apiKey) {
+    const existing2 = readActiveStudioSession();
+    if (existing2) {
+      const reauth = await requestSessionReauth({
+        serviceUrl: existing2.serviceUrl,
+        sessionId: existing2.sessionId,
+        redirectPath: path15
+      });
+      if (!reauth.ok) {
+        throw new StudioNavigationError("push-failed", void 0, existing2.sessionId);
+      }
+      return loginViaExistingWindow({
+        serviceUrl: existing2.serviceUrl,
+        sessionId: existing2.sessionId,
+        startCursor: reauth.pushedEventId,
+        signInUrl: reauth.signInUrl,
+        restoreFocus,
+        opts
+      });
+    }
     const sessionId2 = crypto4.randomUUID();
-    const separator = path15.includes("?") ? "&" : "?";
-    const redirectPath = `${path15}${separator}session=${encodeURIComponent(sessionId2)}&pluginLogin=true`;
+    const freshPath = opts.freshWindowPath ?? path15;
+    const separator = freshPath.includes("?") ? "&" : "?";
+    const redirectPath = `${freshPath}${separator}session=${encodeURIComponent(sessionId2)}&pluginLogin=true`;
     const signInPath = `/studio/sign-in?redirect_url=${encodeURIComponent(redirectPath)}`;
     const signInUrl = `${serviceUrl}${signInPath}&session=${encodeURIComponent(sessionId2)}`;
     const windowPid = openChromelessWindow(signInUrl);
@@ -8077,6 +8171,97 @@ async function openStudioTo(path15, opts = {}) {
     ...poller
   };
 }
+async function loginViaExistingWindow(args) {
+  const { serviceUrl, sessionId } = args;
+  const noop = () => {
+  };
+  const keepalive = setInterval(() => process.stderr.write(""), 3e4);
+  let loginApiKey;
+  try {
+    loginApiKey = await awaitReauthLogin({
+      serviceUrl,
+      sessionId,
+      startCursor: args.startCursor,
+      // Only fired once the sign-in page proved the window alive AND is
+      // waiting on the user; a still-valid browser session re-auths silently
+      // and the caller never surfaces a sign-in prompt.
+      onAck: () => args.opts.onLoginRequired?.(sessionId, args.signInUrl)
+    });
+  } finally {
+    clearInterval(keepalive);
+  }
+  saveCredentials(loginApiKey);
+  args.opts.onAuthenticated?.(sessionId);
+  if (args.opts.onEvent) {
+    await waitForSessionReady({
+      serviceUrl,
+      apiKey: loginApiKey,
+      sessionId
+    });
+    const poller = startEventPoller(serviceUrl, loginApiKey, sessionId, args.opts.onEvent, args.restoreFocus);
+    return {
+      sessionId,
+      serviceUrl,
+      apiKey: loginApiKey,
+      opened: false,
+      ...poller
+    };
+  }
+  args.restoreFocus();
+  return {
+    sessionId,
+    serviceUrl,
+    apiKey: loginApiKey,
+    opened: false,
+    abort: noop,
+    done: Promise.resolve()
+  };
+}
+function awaitReauthLogin(args) {
+  return new Promise((resolve, reject) => {
+    const abortController = new AbortController();
+    let settled = false;
+    let acked = false;
+    const settle = (fn) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(ackTimer);
+      clearTimeout(loginTimer);
+      abortController.abort();
+      fn();
+    };
+    const ackTimer = setTimeout(() => {
+      settle(() => reject(new StudioNavigationError("timeout", void 0, args.sessionId)));
+    }, REAUTH_ACK_TIMEOUT_MS);
+    const loginTimer = setTimeout(() => {
+      settle(() => reject(new Error("Login polling aborted")));
+    }, LOGIN_TIMEOUT_MS);
+    pollSessionAuthEvents({
+      serviceUrl: args.serviceUrl,
+      sessionId: args.sessionId,
+      startCursor: args.startCursor,
+      abortSignal: abortController.signal,
+      onEvent: (event) => {
+        if (event.type === "studio:auth-required" && !acked) {
+          acked = true;
+          clearTimeout(ackTimer);
+          args.onAck();
+          return;
+        }
+        if (event.type === "studio:authenticated") {
+          const token = event.data.token;
+          if (typeof token === "string") {
+            settle(() => resolve(token));
+          }
+        }
+      }
+    }).catch((err) => {
+      settle(() => reject(err instanceof Error ? err : new Error(String(err))));
+    });
+  });
+}
 function startEventPoller(serviceUrl, apiKey, sessionId, onEvent, restoreFocus) {
   const abortController = new AbortController();
   let endedNotified = false;
@@ -8160,11 +8345,25 @@ async function verifyToken(serviceUrl, token) {
 }
 async function runLogin(platform2, pluginVersion, options) {
   const exitOnComplete = options?.exitOnComplete ?? true;
+  const force = options?.force ?? process.argv.includes("--force");
   const config2 = getConfig();
+  if (!force && hasCredentials() && config2.apiKey) {
+    const who = await verifyToken(config2.serviceUrl, config2.apiKey);
+    if (who) {
+      const identity = who.user.email ?? "your account";
+      console.log(`
+Already logged in as ${identity}. Run the login command with --force to re-authenticate.`);
+      if (exitOnComplete) {
+        process.exit(0);
+      }
+      return;
+    }
+  }
   console.log("\nOpening Studio to sign in...");
-  const closePath = `/studio/close?autoClose=true&message=${encodeURIComponent("Login complete")}`;
   try {
-    const result = await openStudioTo(closePath, {
+    const result = await openStudioTo("/studio", {
+      forceLogin: true,
+      freshWindowPath: `/studio/close?autoClose=true&message=${encodeURIComponent("Login complete")}`,
       onLoginRequired: (_sessionId, signInUrl) => {
         console.log(`
 If the browser didn't open, visit this URL manually:
@@ -8191,8 +8390,12 @@ ${greeting}`);
     }
   } catch (err) {
     if (exitOnComplete) {
-      console.error(`
+      if (err instanceof StudioNavigationError && err.staleSessionId) {
+        console.error("\nA Studio window is recorded as open but is not responding. Close it (or run the clearStudioSession command), then try again.");
+      } else {
+        console.error(`
 ${err.message}`);
+      }
       process.exit(1);
     }
     throw err;

package/package.json

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