clay-server 3.8.1 → 4.0.0-beta.2

package/lib/project-session-pair.js

@@ -100,11 +100,11 @@ function attachSessionPair(ctx) {
     var response = token.response || "";
     var text;
     if (token.interrupted) {
-      text = "[Worker execution interrupted] The user interrupted the Worker mid-turn. Its work is PARTIAL and unverified — do not treat it as finished. Review what was done and decide next steps with the user.";
+      text = "[Split Worker execution interrupted] The user interrupted the Split Worker mid-turn. Its work is PARTIAL and unverified — do not treat it as finished. Review what was done and decide next steps with the user.";
     } else {
-      text = "A Worker task delegated through send_to_partner has finished.\n\n" +
+      text = "A Split Worker task delegated through send_to_partner has finished.\n\n" +
         "Original task:\n" + token.message + "\n\n" +
-        (failure ? "Worker error:\n" + failure : "Worker result:\n" + (response || "(No text response was recorded.)")) +
+        (failure ? "Split Worker error:\n" + failure : "Split Worker result:\n" + (response || "(No text response was recorded.)")) +
         "\n\nReview the result, verify it as needed, and continue the task.";
     }
     sm.sendAndRecord(caller, {
@@ -361,7 +361,7 @@ function attachSessionPair(ctx) {
     var driver;
     var groupName;
     if (Number.isInteger(driverSpec.sessionId)) {
-      // "Add Worker" on an existing session: the current session becomes
+      // "Add Split Worker" on an existing session: the current session becomes
       // the Driver with its full conversation context intact.
       driver = sm.sessions.get(driverSpec.sessionId);
       if (!driver) throw new Error("driver session not found");
@@ -378,7 +378,7 @@ function attachSessionPair(ctx) {
     }
     var workerEffort = yoke.clampEffort(workerVendor, workerSpec.effort || (sm.currentEffortByVendor && sm.currentEffortByVendor[workerVendor]) || sm.currentEffort || "medium") || null;
     var worker = sm.createSessionRaw({ ownerId: ownerId, vendor: workerVendor, model: workerSpec.model || null, effort: workerEffort });
-    worker.title = "Worker · " + ((yoke.getVendorInfo(workerVendor) || {}).displayName || workerVendor);
+    worker.title = "Split Worker · " + ((yoke.getVendorInfo(workerVendor) || {}).displayName || workerVendor);
     if (workerSpec.effort) worker.loopSettings = { effort: workerSpec.effort };
     var result = store.create(ws, {
       members: [driver.localId, worker.localId],
@@ -393,7 +393,7 @@ function attachSessionPair(ctx) {
   function createWorkerForDriver(driver, args) {
     if (ctx.isMate) throw new Error("Pair sessions are only available in projects");
     var installed = sm.installedVendors || [];
-    if (installed.length === 0) throw new Error("no coding agent is installed for a Worker session");
+    if (installed.length === 0) throw new Error("no coding agent is installed for a Split Worker session");
     var vendor = typeof args.workerVendor === "string" ? args.workerVendor.trim() : "";
     if (vendor) validateVendor(vendor);
     if (!vendor) {
@@ -468,9 +468,9 @@ function attachSessionPair(ctx) {
     var group = store.groupForMember(session.localId);
     var pairPrompt = "";
     if (group && group.pair && group.pair.driverId === session.localId) {
-      pairPrompt = "You are the Driver in a two-agent pair. The tools send_to_partner, read_partner, interrupt_partner, and close_partner are provided directly to you. Use send_to_partner to delegate concrete bounded work to the Worker. The human may also message or stop the Worker directly; treat that intervention as authoritative. Use close_partner immediately when the human asks to close, dismiss, or remove the Worker pane; it preserves the session history. A completed Worker turn leaves the Worker session available for more work. Use interrupt_partner when execution must stop or change direction but the pair should remain open; its work is partial and unverified until you review it. If review or user feedback requires corrections to the Worker's implementation, delegate a follow-up turn to that Worker instead of editing the Worker-owned files yourself. If the Worker is no longer available, keep the work in the visible Worker flow and use send_to_partner again after the stale pair is removed; never substitute a background session. If a non-waiting delegation finishes later, Clay pushes the result back and resumes you automatically; use read_partner only when you need an interim status check. Integrate and verify the final outcome. Do not search the project for implementations of these tools, and do not delegate work that must be performed sequentially in this same session.";
+      pairPrompt = "You are the Driver in a two-agent pair. The tools send_to_partner, read_partner, interrupt_partner, and close_partner are provided directly to you. Infer the user's intended target from conversational and UI context. References to the user-visible paired or split pane, its session, its activity or status, or a collaborator the user opened resolve to Clay's Split Worker and the appropriate partner tool. Internal Sub-agents are a distinct execution mechanism, not a lexical category; use them only when the user clearly intends internal or background parallel delegation rather than the visible paired session. When ambiguous and a visible pair exists, prefer the visible Split Worker. If the ambiguity would materially change where work runs, ask a concise clarification instead of guessing. Use send_to_partner to delegate concrete bounded work to the Split Worker. The human may also message or stop the Split Worker directly; treat that intervention as authoritative. Use close_partner immediately when the human asks to close, dismiss, or remove the Split Worker pane; it preserves the session history. A completed Split Worker turn leaves the Split Worker session available for more work. Use interrupt_partner when execution must stop or change direction but the pair should remain open; its work is partial and unverified until you review it. If review or user feedback requires corrections to the Split Worker's implementation, delegate a follow-up turn to that Split Worker instead of editing the Split Worker-owned files yourself. If the Split Worker is no longer available, keep the work in the visible Split Worker flow and use send_to_partner again after the stale pair is removed; never substitute a background Sub-agent. If a non-waiting delegation finishes later, Clay pushes the result back and resumes you automatically; use read_partner only when you need an interim status check. Integrate and verify the final outcome. Do not search the project for implementations of these tools, and do not delegate work that must be performed sequentially in this same session.";
     } else if (!group && !ctx.isMate) {
-      pairPrompt = "When the user asks you to open or use a visible Worker, call send_to_partner directly. Clay will create the paired Worker session and open it in the right pane automatically before delivering the task. Do not ask the user to start split mode and do not use a background sub-agent as a substitute for a visible Worker.";
+      pairPrompt = "Infer the user's intended target from conversational and UI context. References to a user-visible paired or split pane, its session, its activity or status, or a collaborator the user wants opened resolve to Clay's Split Worker and its partner tools. Internal Sub-agents are a distinct execution mechanism, not a lexical category; use them only when the user clearly intends internal or background parallel delegation rather than a visible paired session. When ambiguity would materially change where work runs, ask a concise clarification instead of guessing. When the user intends a visible collaborator, call send_to_partner directly; Clay will create the paired Split Worker session and open it in the right pane automatically before delivering the task. Do not ask the user to start split mode and do not use a background Sub-agent as a substitute for a visible Split Worker.";
     }
     return [pairPrompt, workerProposal.getSystemPrompt(session)].filter(Boolean).join("\n\n");
   }

package/lib/project-sessions.js

@@ -75,6 +75,7 @@ function attachSessions(ctx) {
   var sendToSessionOthers = ctx.sendToSessionOthers;
   var opts = ctx.opts;
   var usersModule = ctx.usersModule;
+  var getProjectAccess = ctx.getProjectAccess || function () { return { visibility: "public" }; };
   var userPresence = ctx.userPresence;
   var pushModule = ctx.pushModule;
   var getSessionForWs = ctx.getSessionForWs;
@@ -85,6 +86,60 @@ function attachSessions(ctx) {
   var onProcessingChanged = ctx.onProcessingChanged;
   var broadcastPresence = ctx.broadcastPresence;
   var adapter = ctx.adapter;
+
+  function ownsSearchSession(ws, session) {
+    if (!session) return false;
+    if (usersModule && typeof usersModule.isMultiUser === "function" && usersModule.isMultiUser()) {
+      return !!(ws && ws._clayUser && usersModule.canAccessSession(ws._clayUser.id, session, getProjectAccess()));
+    }
+    return !session.ownerId;
+  }
+
+  function respondToAskUser(session, msg) {
+    if (!session || !msg || !msg.toolId) return false;
+    var toolId = msg.toolId;
+    var answers = msg.answers || {};
+    var pending = session.pendingAskUser && session.pendingAskUser[toolId];
+    if (!pending) return false;
+    if (pending.mode === "yoke") {
+      try { yoke.userInput.normalizeAnswers(pending.request.questions, answers); }
+      catch (e) { return false; }
+    }
+    delete session.pendingAskUser[toolId];
+    sm.sendAndRecord(session, { type: "ask_user_answered", toolId: toolId, answers: answers });
+    if (pending.mode === "yoke" && typeof pending.respond === "function") {
+      pending.respond(answers);
+    } else if (pending.mode === "mcp") {
+      var answerText = formatAskUserAnswerAsMessage(pending.input, answers);
+      var userMsg = { type: "user_message", text: answerText, askUserAnswer: true };
+      session.history.push(userMsg);
+      sm.appendToSessionFile(session, userMsg);
+      sendToSession(session.localId, userMsg);
+      if (!session.isProcessing) {
+        session.isProcessing = true;
+        onProcessingChanged();
+        session.sentToolResults = {};
+        sendToSession(session.localId, { type: "status", status: "processing" });
+        if (!session.queryInstance && !session.worker) sdk.startQuery(session, answerText, undefined, ensureProjectAccessForSession(session));
+        else sdk.pushMessage(session, answerText);
+      } else {
+        sdk.pushMessage(session, answerText);
+      }
+    } else {
+      pending.resolve({ behavior: "deny", message: formatAskUserAnswerAsMessage(pending.input, answers) });
+    }
+    return true;
+  }
+
+  function cancelPendingAskUser(session, reason) {
+    var pendingMap = session && session.pendingAskUser ? session.pendingAskUser : {};
+    Object.keys(pendingMap).forEach(function (toolId) {
+      var pending = pendingMap[toolId];
+      if (pending && pending.respond && typeof pending.respond.cancel === "function") pending.respond.cancel(reason || "Cancelled");
+      else if (pending && typeof pending.resolve === "function") pending.resolve({ behavior: "deny", message: reason || "Cancelled" });
+    });
+    if (session) session.pendingAskUser = {};
+  }
   var getProjectList = ctx.getProjectList;
   var getProjectCount = ctx.getProjectCount;
   var getScheduleCount = ctx.getScheduleCount;
@@ -821,14 +876,19 @@ function attachSessions(ctx) {
     }
 
     if (msg.type === "search_sessions") {
-      var results = sm.searchSessions(msg.query || "");
+      var results = sm.searchSessions(msg.query || "", function (session) {
+        return ownsSearchSession(ws, session);
+      });
       sendTo(ws, { type: "search_results", query: msg.query || "", results: results });
       return true;
     }
 
     if (msg.type === "search_session_content") {
       var targetSession = msg.id ? sm.sessions.get(msg.id) : getSessionForWs(ws);
-      if (!targetSession) return true;
+      if (!ownsSearchSession(ws, targetSession)) {
+        sendTo(ws, { type: "search_content_results", query: msg.query || "", sessionId: msg.id || null, hits: [], total: 0 });
+        return true;
+      }
       var contentResults = sm.searchSessionContent(targetSession.localId, msg.query || "");
       var searchResp = { type: "search_content_results", query: msg.query || "", sessionId: targetSession.localId, hits: contentResults.hits, total: contentResults.total };
       if (msg.source) searchResp.source = msg.source;
@@ -1256,7 +1316,7 @@ function attachSessions(ctx) {
           session.blocks = {};
           session.sentToolResults = {};
           session.pendingPermissions = {};
-          session.pendingAskUser = {};
+          cancelPendingAskUser(session, "Conversation rewound");
           session.isProcessing = false;
           onProcessingChanged();
 
@@ -1328,53 +1388,7 @@ function attachSessions(ctx) {
 
     if (msg.type === "ask_user_response") {
       var session = getSessionForWs(ws);
-      if (!session) return true;
-      var toolId = msg.toolId;
-      var answers = msg.answers || {};
-      var pending = session.pendingAskUser[toolId];
-      if (!pending) return true;
-      delete session.pendingAskUser[toolId];
-      sm.sendAndRecord(session, { type: "ask_user_answered", toolId: toolId, answers: answers });
-
-      if (pending.mode === "mcp") {
-        // Stateless MCP path: the tool already returned. Inject the user's
-        // answer as a new user message so the conversation continues
-        // naturally on the next turn. This matches how the mate would see
-        // any other user input.
-        var answerText = formatAskUserAnswerAsMessage(pending.input, answers);
-        var userMsg = { type: "user_message", text: answerText };
-        session.history.push(userMsg);
-        sm.appendToSessionFile(session, userMsg);
-        sendToSession(session.localId, userMsg);
-
-        if (!session.isProcessing) {
-          session.isProcessing = true;
-          onProcessingChanged();
-          session.sentToolResults = {};
-          sendToSession(session.localId, { type: "status", status: "processing" });
-          if (!session.queryInstance && !session.worker) {
-            sdk.startQuery(session, answerText, undefined, ensureProjectAccessForSession(session));
-          } else {
-            sdk.pushMessage(session, answerText);
-          }
-        } else {
-          // Turn is still running; queue for the next turn.
-          sdk.pushMessage(session, answerText);
-        }
-      } else {
-        // Claude native AskUserQuestion path (built-in tool, intercepted via
-        // canUseTool). In headless SDK mode the built-in can't render its own
-        // answer UI: resolving "allow" lets it return an EMPTY result, so the
-        // model continues the same turn with no answer ("I don't see an
-        // answer"). Injected user messages also lose the race against that
-        // empty result. Instead, deliver the answer as the tool_result by
-        // denying with the formatted answer text — the SDK surfaces a deny
-        // `message` to the model as the tool result, so the model receives the
-        // user's choice in the same turn. (updatedInput.answers is not read by
-        // the 0.3.x built-in, which is what caused answers to be dropped.)
-        var nativeAnswerText = formatAskUserAnswerAsMessage(pending.input, answers);
-        pending.resolve({ behavior: "deny", message: nativeAnswerText });
-      }
+      if (session) respondToAskUser(session, msg);
       return true;
     }
 
@@ -1443,7 +1457,7 @@ function attachSessions(ctx) {
         session.isProcessing = false;
         onProcessingChanged();
         session.pendingPermissions = {};
-        session.pendingAskUser = {};
+        cancelPendingAskUser(session, "Conversation restarted");
         sm.broadcastSessionList();
         setImmediate(function () {
           if (session.abortController) {
@@ -2011,6 +2025,7 @@ function attachSessions(ctx) {
   return {
     handleSessionsMessage: handleSessionsMessage,
     resolveSessionForView: resolveSessionForView,
+    respondToAskUser: respondToAskUser,
   };
 }
 

package/lib/project-vendor-login.js

@@ -0,0 +1,397 @@
+// Vendor login flow coordinator.
+//
+// Owns the "the vendor CLI is not logged in" recovery path end to end so the
+// client never has to guess. One login terminal per vendor per project is the
+// single source of truth: repeated auth_required events (other sessions, split
+// panes, a burst of 401 retries) re-use that record instead of spawning more
+// terminals.
+//
+// Lifecycle:
+//   vendor_login_start  -> create (or re-use) a PTY running the vendor login
+//                          command, reply with vendor_login_ready
+//   PTY output/exit     -> detect a successful login, restart the vendor's
+//                          YOKE adapter so it re-reads the credential file,
+//                          broadcast auth_refreshed, close the terminal
+//   vendor_login_cancel -> user dismissed the flow; kill the terminal
+//
+// The adapter restart is the actual bug fix: a Codex app-server is a long-lived
+// child process that reads ~/.codex/auth.json once at spawn, so without a
+// restart every query after a successful login keeps hitting 401 and re-arms
+// auth_required forever.
+
+var vendorRegistry = require("./yoke/vendor-registry");
+
+// Login CLIs print a success line and then hand the shell back, so the PTY
+// itself does not exit. Watch the output stream instead. Deliberately narrow:
+// "Successfully logged out" and MCP-server logins must not match.
+var LOGIN_SUCCESS_PATTERNS = [
+  /successfully logged in(?![ \t]+to[ \t]+mcp)/i,
+  /logged in successfully/i,
+  /login successful/i,
+  /successfully authenticated/i,
+  /authentication successful/i,
+  /signed in successfully/i,
+  /signed in with your [a-z ]+ account/i,
+  /you(?:'re| are) (?:now )?(?:logged|signed) in/i,
+];
+
+// Rolling window kept per flow so a success line split across PTY chunks is
+// still matched, without buffering the whole login transcript.
+var OUTPUT_TAIL_MAX = 4096;
+
+// Grace period between detecting success and killing the terminal, so the user
+// actually sees the confirmation line before the modal closes.
+var CLOSE_AFTER_SUCCESS_MS = 2000;
+
+var ANSI_PATTERN = /\x1b\[[0-9;?]*[ -\/]*[@-~]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\r/g;
+
+function stripAnsi(text) {
+  return String(text).replace(ANSI_PATTERN, "");
+}
+
+function looksLikeLoginSuccess(text) {
+  for (var i = 0; i < LOGIN_SUCCESS_PATTERNS.length; i++) {
+    if (LOGIN_SUCCESS_PATTERNS[i].test(text)) return true;
+  }
+  return false;
+}
+
+/**
+ * ctx fields:
+ *   slug, osUsers,
+ *   sm, tm, adapters,
+ *   send, sendTo,
+ *   usersModule,
+ *   getOsUserInfoForWs, getOsUserInfoForLinuxUser, getLinuxUserForSession
+ */
+function attachVendorLogin(ctx) {
+  var slug = ctx.slug;
+  var osUsers = ctx.osUsers;
+
+  var sm = ctx.sm;
+  var tm = ctx.tm;
+  var adapters = ctx.adapters || {};
+
+  var send = ctx.send;
+  var sendTo = ctx.sendTo;
+
+  var usersModule = ctx.usersModule;
+
+  var getOsUserInfoForWs = ctx.getOsUserInfoForWs;
+  var getOsUserInfoForLinuxUser = ctx.getOsUserInfoForLinuxUser;
+  var getLinuxUserForSession = ctx.getLinuxUserForSession;
+
+  // vendor -> flow record. At most one live login terminal per vendor.
+  var _flows = Object.create(null);
+
+  function loginCommandFor(vendor) {
+    var info = vendorRegistry.getVendorInfo(vendor);
+    return (info && info.loginCommand) || "claude login";
+  }
+
+  function vendorDisplayName(vendor) {
+    var info = vendorRegistry.getVendorInfo(vendor);
+    return (info && info.displayName) || vendor || "Vendor";
+  }
+
+  function listFlows() {
+    var result = [];
+    var vendors = Object.keys(_flows);
+    for (var i = 0; i < vendors.length; i++) {
+      var flow = _flows[vendors[i]];
+      result.push({
+        vendor: flow.vendor,
+        terminalId: flow.terminalId,
+        startedAt: flow.startedAt,
+        completed: !!flow.completed,
+      });
+    }
+    return result;
+  }
+
+  function broadcastState() {
+    send({ type: "vendor_login_state", slug: slug, flows: listFlows() });
+  }
+
+  function sendStateTo(ws) {
+    sendTo(ws, { type: "vendor_login_state", slug: slug, flows: listFlows() });
+  }
+
+  function hasTerminalPermission(ws) {
+    if (!ws || !ws._clayUser) return true;
+    if (!usersModule || typeof usersModule.getEffectivePermissions !== "function") return true;
+    var perms = usersModule.getEffectivePermissions(ws._clayUser, osUsers);
+    return !!(perms && perms.terminal);
+  }
+
+  // The login terminal must write credentials to the same HOME the adapter
+  // will read them from. With OS-user isolation the adapter runs as the
+  // *session owner's* Linux user, which is not necessarily the connected
+  // client, so prefer the session identity when the requester is entitled to
+  // it. Without isolation both sides run as the daemon user and this resolves
+  // to null on both paths.
+  function resolveLoginIdentity(ws, msg) {
+    if (!osUsers) return { linuxUser: null, osUserInfo: null };
+
+    var sessionLinuxUser = null;
+    var sessionId = msg && msg.sessionId;
+    if (sessionId && sm && sm.sessions && typeof getLinuxUserForSession === "function") {
+      var session = sm.sessions.get(sessionId);
+      if (session) {
+        var requesterId = ws && ws._clayUser ? ws._clayUser.id : null;
+        var isOwner = !session.ownerId || (requesterId && String(session.ownerId) === String(requesterId));
+        var isAdmin = !!(ws && ws._clayUser && ws._clayUser.role === "admin");
+        if (isOwner || isAdmin) sessionLinuxUser = getLinuxUserForSession(session);
+      }
+    }
+
+    if (sessionLinuxUser && typeof getOsUserInfoForLinuxUser === "function") {
+      return { linuxUser: sessionLinuxUser, osUserInfo: getOsUserInfoForLinuxUser(sessionLinuxUser) };
+    }
+
+    var wsInfo = typeof getOsUserInfoForWs === "function" ? getOsUserInfoForWs(ws) : null;
+    return { linuxUser: wsInfo ? wsInfo.user : null, osUserInfo: wsInfo };
+  }
+
+  function isFlowTerminalAlive(flow) {
+    return !!(flow && typeof flow.terminalId === "number" && tm.has(flow.terminalId));
+  }
+
+  function discardFlow(vendor) {
+    var flow = _flows[vendor];
+    if (!flow) return null;
+    delete _flows[vendor];
+    if (flow.closeTimer) {
+      clearTimeout(flow.closeTimer);
+      flow.closeTimer = null;
+    }
+    return flow;
+  }
+
+  // Kill the PTY and drop it from the sidebar list. `flow.closing` keeps the
+  // terminal's own exit hook from re-entering finalization.
+  function closeFlowTerminal(flow) {
+    if (!flow || typeof flow.terminalId !== "number") return;
+    flow.closing = true;
+    try { tm.close(flow.terminalId); } catch (e) {}
+    send({ type: "term_list", terminals: tm.list() });
+  }
+
+  // Restart the vendor adapter so the next query spawns a process that reads
+  // the credentials the login just wrote. Shared adapter instances (Claude) are
+  // reused by every project, so tearing one down here would kill unrelated
+  // sessions; those runtimes pick up new credentials on their own.
+  function refreshVendorAuth(vendor) {
+    var adapter = adapters[vendor];
+    if (!adapter || typeof adapter.shutdown !== "function") return Promise.resolve(false);
+    if (adapter.shared) {
+      console.log("[vendor-login] " + vendor + " adapter is shared; skipping restart for " + slug);
+      return Promise.resolve(false);
+    }
+    // adapter.shutdown() already fans out to every per-OS-user runtime it
+    // created (shutdownUserRuntimes), so one call covers isolated setups too.
+    return Promise.resolve()
+      .then(function () { return adapter.shutdown(); })
+      .then(function () {
+        console.log("[vendor-login] Restarted " + vendor + " adapter for " + slug + " after login");
+        return true;
+      })
+      .catch(function (err) {
+        console.error("[vendor-login] " + vendor + " adapter restart failed for " + slug + ":",
+          err && err.message ? err.message : err);
+        return false;
+      });
+  }
+
+  function finishFlow(vendor, succeeded) {
+    var flow = _flows[vendor];
+    if (!flow || flow.finishing) return;
+    flow.finishing = true;
+    flow.completed = !!succeeded;
+
+    var refresh = succeeded ? refreshVendorAuth(vendor) : Promise.resolve(false);
+    refresh.then(function (restarted) {
+      discardFlow(vendor);
+      closeFlowTerminal(flow);
+      if (succeeded) {
+        send({ type: "auth_refreshed", slug: slug, vendor: vendor, adapterRestarted: !!restarted });
+      }
+      broadcastState();
+    });
+  }
+
+  function handleFlowOutput(vendor, chunk) {
+    var flow = _flows[vendor];
+    if (!flow || flow.finishing || flow.succeeded) return;
+    flow.outputTail = (flow.outputTail + stripAnsi(chunk)).slice(-OUTPUT_TAIL_MAX);
+    if (!looksLikeLoginSuccess(flow.outputTail)) return;
+
+    flow.succeeded = true;
+    console.log("[vendor-login] Detected successful " + vendor + " login in " + slug);
+    // Let the success line land on screen before the terminal disappears.
+    flow.closeTimer = setTimeout(function () {
+      finishFlow(vendor, true);
+    }, CLOSE_AFTER_SUCCESS_MS);
+    if (flow.closeTimer && typeof flow.closeTimer.unref === "function") flow.closeTimer.unref();
+  }
+
+  // Fires for both a PTY that exited on its own and one the user closed from
+  // the sidebar. Either way the flow is over; refresh auth if the command had
+  // already reported success.
+  function handleFlowExit(vendor) {
+    var flow = _flows[vendor];
+    if (!flow || flow.closing || flow.finishing) return;
+    finishFlow(vendor, !!flow.succeeded);
+  }
+
+  function startFlow(ws, vendor, msg) {
+    var identity = resolveLoginIdentity(ws, msg);
+    var command = loginCommandFor(vendor);
+    var flow = {
+      vendor: vendor,
+      terminalId: null,
+      startedAt: Date.now(),
+      linuxUser: identity.linuxUser,
+      outputTail: "",
+      succeeded: false,
+      finishing: false,
+      closing: false,
+      completed: false,
+      closeTimer: null,
+    };
+    // Registered before create() so the PTY's first output chunk (hooks fire
+    // synchronously from spawn) already finds the record.
+    _flows[vendor] = flow;
+
+    var terminal = null;
+    try {
+      terminal = tm.create(100, 30, identity.osUserInfo, ws, {
+        initialInput: command + "\n",
+        title: vendorDisplayName(vendor) + " login",
+        kind: "vendor-login",
+        onData: function (data) { handleFlowOutput(vendor, data); },
+        onExit: function () { handleFlowExit(vendor); },
+      });
+    } catch (e) {
+      console.error("[vendor-login] Failed to spawn " + vendor + " login terminal in " + slug + ":",
+        e && e.message ? e.message : e);
+    }
+
+    if (!terminal) {
+      delete _flows[vendor];
+      return null;
+    }
+
+    flow.terminalId = terminal.id;
+    tm.attach(terminal.id, ws);
+    send({ type: "term_list", terminals: tm.list() });
+    return flow;
+  }
+
+  function handleVendorLoginMessage(ws, msg) {
+    if (msg.type === "vendor_login_state_request") {
+      sendStateTo(ws);
+      return true;
+    }
+
+    if (msg.type === "vendor_login_cancel") {
+      var cancelVendor = String(msg.vendor || "");
+      var cancelled = discardFlow(cancelVendor);
+      if (cancelled) closeFlowTerminal(cancelled);
+      broadcastState();
+      return true;
+    }
+
+    if (msg.type === "vendor_login_start") {
+      var vendor = String(msg.vendor || "claude");
+      if (!vendorRegistry.getVendorInfo(vendor)) {
+        sendTo(ws, { type: "vendor_login_error", vendor: vendor, error: "Unknown vendor: " + vendor });
+        return true;
+      }
+      if (!hasTerminalPermission(ws)) {
+        sendTo(ws, { type: "vendor_login_error", vendor: vendor, error: "Terminal access is not permitted" });
+        return true;
+      }
+
+      var existing = _flows[vendor];
+      if (existing && !isFlowTerminalAlive(existing)) {
+        // Terminal died without its exit hook clearing the record.
+        discardFlow(vendor);
+        existing = null;
+      }
+
+      if (existing) {
+        // An auto-triggered request (a fresh auth_required from another
+        // session or split pane) must not pop a second prompt; it only learns
+        // that a flow is already running. A deliberate request re-attaches.
+        if (!msg.auto) {
+          tm.attach(existing.terminalId, ws);
+          sendTo(ws, {
+            type: "vendor_login_ready",
+            slug: slug,
+            vendor: vendor,
+            terminalId: existing.terminalId,
+            reused: true,
+          });
+        }
+        sendStateTo(ws);
+        return true;
+      }
+
+      var started = startFlow(ws, vendor, msg);
+      if (!started) {
+        sendTo(ws, {
+          type: "vendor_login_error",
+          vendor: vendor,
+          error: "Cannot create terminal (node-pty not available or limit reached)",
+        });
+        return true;
+      }
+
+      console.log("[vendor-login] Started " + vendor + " login terminal " + started.terminalId + " in " + slug);
+      sendTo(ws, {
+        type: "vendor_login_ready",
+        slug: slug,
+        vendor: vendor,
+        terminalId: started.terminalId,
+        reused: false,
+      });
+      broadcastState();
+      return true;
+    }
+
+    return false;
+  }
+
+  // The sidebar "close terminal" path goes through tm.close() directly, which
+  // fires our exit hook. This is the explicit entry point for callers that
+  // remove a terminal without going through the PTY.
+  function forgetTerminal(terminalId) {
+    var vendors = Object.keys(_flows);
+    for (var i = 0; i < vendors.length; i++) {
+      if (_flows[vendors[i]].terminalId === terminalId) {
+        handleFlowExit(vendors[i]);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  function isLoginTerminal(terminalId) {
+    var vendors = Object.keys(_flows);
+    for (var i = 0; i < vendors.length; i++) {
+      if (_flows[vendors[i]].terminalId === terminalId) return true;
+    }
+    return false;
+  }
+
+  return {
+    handleVendorLoginMessage: handleVendorLoginMessage,
+    sendStateTo: sendStateTo,
+    listFlows: listFlows,
+    forgetTerminal: forgetTerminal,
+    isLoginTerminal: isLoginTerminal,
+  };
+}
+
+module.exports = { attachVendorLogin: attachVendorLogin };