usebeeline 0.1.30 → 0.1.33

package/dist/usebeeline.mjs

@@ -16551,6 +16551,96 @@ function defaultSquireMcpClient(scope) {
   return new StdioSquireMcpClient({ scope });
 }
 
+// apps/body/dist/squire-share-renewals.js
+function shareResult(result) {
+  const envelope = result;
+  if (envelope?.isError || !Array.isArray(envelope?.content))
+    throw new Error("Squire share renewal refused");
+  const text2 = envelope.content.find((item) => item.type === "text")?.text;
+  const body = JSON.parse(text2 ?? "{}");
+  const expiresAt = typeof body.expires_at === "string" ? Date.parse(body.expires_at) : NaN;
+  if (typeof body.url !== "string" || !/^https?:\/\/[^/]+\/s\/[A-Za-z0-9_-]{43}\/$/.test(body.url) || !Number.isFinite(expiresAt) || expiresAt <= Date.now())
+    throw new Error("Squire share renewal returned an invalid lease");
+  return { upstreamUrl: body.url, expiresAt };
+}
+var SquireShareRenewals = class {
+  owns;
+  persist;
+  reaped;
+  shares = /* @__PURE__ */ new Map();
+  constructor(owns, persist, reaped) {
+    this.owns = owns;
+    this.persist = persist;
+    this.reaped = reaped;
+  }
+  track(sessionId, client, result) {
+    let lease;
+    try {
+      lease = shareResult(result);
+    } catch {
+      return;
+    }
+    this.stop(sessionId);
+    const share = { sessionId, client, ...lease };
+    this.shares.set(sessionId, share);
+    this.schedule(share);
+  }
+  stop(sessionId) {
+    const share = this.shares.get(sessionId);
+    if (share?.timer)
+      clearTimeout(share.timer);
+    this.shares.delete(sessionId);
+  }
+  close() {
+    for (const id of this.shares.keys())
+      this.stop(id);
+  }
+  schedule(share, retry = false) {
+    if (this.shares.get(share.sessionId) !== share)
+      return;
+    const remaining = share.expiresAt - Date.now();
+    const margin = Math.min(4 * 6e4, Math.max(1, remaining / 2));
+    const delay = retry ? 5e3 : Math.max(1, remaining - margin);
+    share.timer = setTimeout(() => {
+      void this.renew(share);
+    }, delay);
+    share.timer.unref?.();
+  }
+  async renew(share) {
+    if (this.shares.get(share.sessionId) !== share)
+      return;
+    if (!this.owns(share.sessionId, share.client)) {
+      this.stop(share.sessionId);
+      this.reaped(share.sessionId);
+      return;
+    }
+    try {
+      const result = await share.client.requestMcp("tools/call", {
+        name: "operate_share",
+        arguments: { session_id: share.sessionId }
+      });
+      if (this.shares.get(share.sessionId) !== share)
+        return;
+      if (!this.owns(share.sessionId, share.client)) {
+        this.stop(share.sessionId);
+        this.reaped(share.sessionId);
+        return;
+      }
+      const lease = shareResult(result);
+      if (lease.upstreamUrl !== share.upstreamUrl || lease.expiresAt <= share.expiresAt)
+        throw new Error("Squire did not renew the existing share");
+      if (!await this.persist({ sessionId: share.sessionId, ...lease })) {
+        this.stop(share.sessionId);
+        return;
+      }
+      share.expiresAt = lease.expiresAt;
+      this.schedule(share);
+    } catch {
+      this.schedule(share, true);
+    }
+  }
+};
+
 // apps/body/dist/squire-session-registry.js
 var owners = /* @__PURE__ */ new Map();
 function registerSquireSession(sessionId, owner) {
@@ -16659,6 +16749,7 @@ var SquireTaskRelay = class {
   approvalRequestId;
   closed = false;
   callTail = Promise.resolve();
+  shareRenewals;
   constructor(agentId, roomId, contextFile, authorize, home = homedir4(), makeClient = (callbacks) => new StdioSquireMcpClient({
     scope: { agentId, roomId },
     home,
@@ -16669,7 +16760,7 @@ var SquireTaskRelay = class {
     onNotification: callbacks.onNotification
   }), onApprovalDecided = () => {
   }, onSessionEnded = () => {
-  }) {
+  }, onShareRenewed = async () => false) {
     this.agentId = agentId;
     this.roomId = roomId;
     this.contextFile = contextFile;
@@ -16677,10 +16768,13 @@ var SquireTaskRelay = class {
     this.makeClient = makeClient;
     this.onApprovalDecided = onApprovalDecided;
     this.onSessionEnded = onSessionEnded;
+    this.shareRenewals = new SquireShareRenewals((id, client) => !this.closed && squireSessionOwner(id)?.client === client, onShareRenewed, (id) => this.onSessionEnded(id));
   }
   ended(ids) {
-    for (const id of ids)
+    for (const id of ids) {
+      this.shareRenewals.stop(id);
       this.onSessionEnded(id);
+    }
   }
   async listen() {
     if (this.closed)
@@ -16774,6 +16868,7 @@ var SquireTaskRelay = class {
     if (this.closed)
       return;
     this.closed = true;
+    this.shareRenewals.close();
     this.active = void 0;
     this.approvalRequestId = void 0;
     this.retire("helper-exit");
@@ -16985,6 +17080,8 @@ var SquireTaskRelay = class {
       if (this.activeScheduleId)
         for (const id of requestedIds)
           tagSquireSessionSchedule(id, this.activeScheduleId);
+      if (safeToolName === "operate_share" && requestedIds.length === 1)
+        this.shareRenewals.track(requestedIds[0], callClient, result);
       const approval = input.method === "tools/call" && squireApprovalFromMcp({ id: 1, method: input.method, params: input.params }, { id: 1, result });
       if (approval) {
         const ids = requestedIds.length ? requestedIds : [...task.sessions];
@@ -30453,7 +30550,7 @@ import { mkdir as mkdir13, rm as rm10, stat as stat8, writeFile as writeFile10 }
 import { dirname as dirname13, resolve as resolve16 } from "node:path";
 var UPDATE_CONVERGENCE_SLO_MS = 10 * 6e4;
 var DEFAULT_UPDATE_INTERVAL_MS = 3e4;
-var UPDATE_DRAIN_DEADLINE_MS = UPDATE_CONVERGENCE_SLO_MS - 15e4;
+var UPDATE_DRAIN_DEADLINE_MS = 5 * 6e4;
 var MAX_HOST_RESTART_STAGGER_MS = 15e3;
 function managedRestartStaggerMs(agentId, desiredRelease, drainDeadlineAt, now2 = Date.now()) {
   const digest = createHash8("sha256").update(agentId).update("\0").update(desiredRelease).digest();
@@ -30655,8 +30752,8 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
   }
   /**
    * Resolve one handoff tick against the daemon's authoritative turn registry.
-   * The coordinator keeps intake open while turns run and only closes it
-   * in a quiet gap before activating a staged release.
+   * The coordinator keeps intake open until a quiet gap or the bounded
+   * drain deadline before activating a staged release.
    */
   async restartRequest(readyToRestart) {
     const activeDrift = await this.check();
@@ -30665,7 +30762,8 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
     const request = this.#restartRequest;
     if (!request)
       throw new Error("update drift was detected without an in-memory restart request");
-    if (!readyToRestart(request)) {
+    const deadlineReached = this.#now() >= request.drainDeadlineAt;
+    if (!readyToRestart(request, deadlineReached)) {
       return { kind: "waiting", request };
     }
     if (this.#stagedReleaseId) {
@@ -30700,11 +30798,10 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
         });
       }
       this.#stagedReleaseId = void 0;
-      this.#requested = false;
-      this.#restartRequest = void 0;
-      this.#armRestart(stagedReleaseId);
+      this.#requested = true;
+      this.#restartRequest = request;
     }
-    return { kind: "restart", request: this.#restartRequest ?? request };
+    return { kind: "restart", mode: deadlineReached ? "interrupted" : "drained", request: this.#restartRequest ?? request };
   }
 };
 async function coordinateManagedUpdateHandoff(update, readyToRestart, restart, waiting = async () => void 0) {
@@ -30715,7 +30812,7 @@ async function coordinateManagedUpdateHandoff(update, readyToRestart, restart, w
     await waiting(next.request);
     return "waiting-for-idle";
   }
-  await restart(next.request, "drained");
+  await restart(next.request, next.mode ?? "drained");
   return "restarting";
 }
 var UPDATE_DRAIN_WAIT_LOG_INTERVAL_MS = 6e4;
@@ -30750,7 +30847,7 @@ var ManagedUpdateDrain = class {
   async #step() {
     const { update, quiesce, activeTurnCount } = this.#options;
     let armed;
-    const progress = await coordinateManagedUpdateHandoff(update, () => activeTurnCount() === 0 && quiesce(), async (request, mode) => {
+    const progress = await coordinateManagedUpdateHandoff(update, (_request, deadlineReached) => (activeTurnCount() === 0 || deadlineReached) && quiesce(deadlineReached), async (request, mode) => {
       this.#disarm();
       await this.#options.restart(request, mode);
       this.#restarting = true;
@@ -30759,20 +30856,27 @@ var ManagedUpdateDrain = class {
       await this.#options.waiting?.(request);
     });
     if (armed && !this.#waitLogTimer)
-      this.#arm();
+      this.#arm(armed);
     return progress;
   }
-  #arm() {
+  #arm(request) {
     this.#logWaiting();
-    this.#scheduleWaitLog();
+    this.#scheduleWaitLog(request);
   }
-  #scheduleWaitLog() {
+  #scheduleWaitLog(request) {
     this.#waitLogTimer = this.#setTimer(() => {
       this.#waitLogTimer = void 0;
       if (this.#restarting)
         return;
-      void this.#resolve().catch((error) => this.#log(`[thin-core] update drain failed: ${String(error)}`));
-    }, UPDATE_DRAIN_WAIT_LOG_INTERVAL_MS);
+      void this.#resolve().catch((error) => {
+        if (this.#options.failed)
+          this.#options.failed(error);
+        else
+          this.#log(`[thin-core] update drain failed: ${String(error)}`);
+        if (!this.#restarting && this.#waitLogTimer === void 0)
+          this.#scheduleWaitLog(request);
+      });
+    }, Math.min(UPDATE_DRAIN_WAIT_LOG_INTERVAL_MS, updateWaitMs(this.#options, request)));
   }
   #logWaiting() {
     this.#log(`[thin-core] update restart waiting: ${this.#options.activeTurnCount()} active turn(s); intake open; waiting for a quiet gap`);
@@ -30783,6 +30887,10 @@ var ManagedUpdateDrain = class {
     this.#waitLogTimer = void 0;
   }
 };
+function updateWaitMs(options, request) {
+  const remaining = request.drainDeadlineAt - (options.now ?? Date.now)();
+  return remaining > 0 ? remaining : UPDATE_DRAIN_WAIT_LOG_INTERVAL_MS;
+}
 function numberEnv(env, name, fallback) {
   const value = Number(env[name]);
   return Number.isFinite(value) && value >= 0 ? value : fallback;
@@ -31803,7 +31911,7 @@ var AcpRequestTimeoutError = class extends Error {
     this.name = "AcpRequestTimeoutError";
   }
 };
-var TURN_BACKSTOP_MS = 30 * 6e4;
+var TURN_BACKSTOP_MS = 45 * 6e4;
 var AcpTurnBackstopError = class extends Error {
   timeoutMs;
   lastActivity;
@@ -32429,8 +32537,8 @@ ${String(error)}`);
   /**
    * Run one prompt turn. `timeoutMs` is an idle window, not a hard cap on
    * turn length: every inbound ACP message for this session re-arms it.
-   * Open tool calls suspend the backstop until completion. A silent session
-   * with no open tool is cancelled without stopping the runtime.
+   * Tool progress re-arms the same bound; an open tool never disables it.
+   * A silent session is cancelled without stopping sibling sessions.
    * `onChunk` is the ACP-boundary
    * streaming hook: called for every incremental `agent_message_chunk`
    * delta as it arrives, so a caller can project live text without waiting
@@ -32554,16 +32662,14 @@ ${String(error)}`);
     }
   }
   /**
-   * A tool owns its deadline. Silence while it is open is never a turn failure.
-   * After the last tool closes, start a full backstop window for this session.
+   * Bound silence even when a tool stays open: a missing terminal tool update
+   * must not leave a claimed turn running indefinitely.
    */
   resetPendingIdleTimeout(id) {
     const p = this.pending.get(id);
     if (!p || p.idleTimeoutMs === void 0)
       return;
     this.clearTimer(p);
-    if (p.openToolCalls?.size)
-      return;
     const { idleTimeoutMs, reject, detail, sessionId, lastActivity } = p;
     p.timer = setTimeout(() => {
       this.pending.delete(id);
@@ -32601,13 +32707,6 @@ ${String(error)}`);
           continue;
         const update = params?.update;
         pending.lastActivity = typeof update?.sessionUpdate === "string" ? update.sessionUpdate : method ?? `response:${response?.method ?? "request"}`;
-        if (typeof update?.toolCallId === "string" && (update.sessionUpdate === "tool_call" || update.sessionUpdate === "tool_call_update")) {
-          if (update.status === "pending" || update.status === "in_progress") {
-            pending.openToolCalls?.add(update.toolCallId);
-          } else if (update.status === "completed" || update.status === "failed") {
-            pending.openToolCalls?.delete(update.toolCallId);
-          }
-        }
         this.resetPendingIdleTimeout(requestId);
       }
     }
@@ -32791,7 +32890,7 @@ ${String(error)}`);
         method,
         ...sessionId ? { sessionId } : {},
         ...detail ? { detail } : {},
-        ...backstop ? { idleTimeoutMs: timeoutMs, lastActivity: method, openToolCalls: /* @__PURE__ */ new Set() } : {}
+        ...backstop ? { idleTimeoutMs: timeoutMs, lastActivity: method } : {}
       });
       if (backstop)
         this.resetPendingIdleTimeout(id);
@@ -35962,8 +36061,11 @@ async function shareChromiumPage(input) {
     if (message.method === "Page.frameNavigated" && message.params?.frame?.url) {
       try {
         const url = new URL(message.params.frame.url);
-        if (url.origin !== "null" && relay.readyState === import_websocket.default.OPEN)
-          relay.send(JSON.stringify({ type: "share-event", name: "navigation", detail: url.origin }));
+        if (["http:", "https:"].includes(url.protocol) && relay.readyState === import_websocket.default.OPEN) {
+          url.username = "";
+          url.password = "";
+          relay.send(JSON.stringify({ type: "share-event", name: "navigation", detail: url.href }));
+        }
       } catch {
       }
       return;
@@ -43234,7 +43336,7 @@ var MonolithRoomTurnLoop = class {
     }, (sessionId) => {
       options.api.execute("endComputerSession", { roomId: options.roomId, sessionId }).catch(() => {
       });
-    });
+    }, async (lease) => (await options.api.execute("refreshComputerSession", { roomId: options.roomId, ...lease })).live);
     this.options = { ...options, api: this.commandContext.bind(options.api) };
     options.grantRunner?.register(options.roomId, {
       workspaceId: options.workspaceId,
@@ -44277,6 +44379,8 @@ var MonolithRoomTurnLoop = class {
         void finishTrace("cancelled").catch(() => void 0);
         return;
       }
+      if (error instanceof AcpTurnBackstopError)
+        await this.discardSession();
       if (liveCornerOpened && error instanceof AcpTurnBackstopError) {
         console.log(`[thin-core] monolith Room ${this.options.roomId} turn ${item.id}: turn_backstop after opening a corner; the work continues in the corner`);
         this.options.onCornerOpened?.();
@@ -45493,7 +45597,7 @@ var MonolithCornerTurnLoop = class {
     }, (sessionId) => {
       options.api.execute("endComputerSession", { roomId: options.cornerId, sessionId }).catch(() => {
       });
-    });
+    }, async (lease) => (await options.api.execute("refreshComputerSession", { roomId: options.cornerId, ...lease })).live);
     this.options = { ...options, api: this.commandContext.bind(options.api) };
     options.grantRunner?.register(options.cornerId, {
       workspaceId: options.workspaceId,
@@ -46733,6 +46837,8 @@ ${continuation}` : assembled;
         void finishTrace("cancelled").catch(() => void 0);
         return;
       }
+      if (error instanceof AcpTurnBackstopError)
+        await this.discardSession();
       const reason = distillTurnFailureReason(error);
       startTraceStats();
       await api.execute("postAgentTurnReceipt", {
@@ -50042,12 +50148,22 @@ async function runMachineHelper(options = {}) {
       env
     });
   }
+  const recoverManagedRestart = (error) => {
+    console.error("[helper] managed restart failed; serving again:", error);
+    for (const agent of hosted.values())
+      agent.lifecycle.resumeAfterFailedUpdate(() => agent.core.resumeServing());
+  };
   const updateDrain = update ? new ManagedUpdateDrain({
     update,
-    quiesce: () => !forceUpdate?.active && lifecycle.serving && quiesceHostedAgents([...hosted.values()]),
+    failed: recoverManagedRestart,
+    quiesce: (deadlineReached) => !forceUpdate?.active && lifecycle.serving && quiesceHostedAgents([...hosted.values()], deadlineReached),
     activeTurnCount: () => [...hosted.values()].reduce((sum, agent) => sum + agent.core.activeTurnCount(), 0),
-    restart: async ({ desiredRelease }) => {
-      stoppingStatus = `update pending, converging; loaded_release=${loadedRelease ?? "unknown"}; desired_release=${desiredRelease}; drain complete; intake quiesced`;
+    restart: async ({ desiredRelease }, mode) => {
+      if (mode === "interrupted") {
+        for (const agent of hosted.values())
+          journalInterruptedTurns(agent.runtimeDir, agent.core.interruptForServerMinimum());
+      }
+      stoppingStatus = `update pending, converging; loaded_release=${loadedRelease ?? "unknown"}; desired_release=${desiredRelease}; drain ${mode}; intake quiesced`;
       await notifier.stopping(stoppingStatus).catch((error) => console.error("[helper] stopping notification failed:", error));
       restartHelper("update");
     },
@@ -50059,9 +50175,7 @@ async function runMachineHelper(options = {}) {
     try {
       await updateDrain?.tick();
     } catch (error) {
-      console.error("[helper] managed restart failed; serving again:", error);
-      for (const agent of hosted.values())
-        agent.lifecycle.resumeAfterFailedUpdate(() => agent.core.resumeServing());
+      recoverManagedRestart(error);
     }
     void sweepHostDisk();
   };
@@ -50231,8 +50345,8 @@ async function runMachineHelper(options = {}) {
   }
   return finish(lifecycle.stopReason ?? "stopped");
 }
-function quiesceHostedAgents(agents) {
-  if (agents.some((agent) => agent.core.activeTurnCount() > 0))
+function quiesceHostedAgents(agents, deadlineReached = false) {
+  if (!deadlineReached && agents.some((agent) => agent.core.activeTurnCount() > 0))
     return false;
   if (agents.some((agent) => !agent.lifecycle.serving && !(agent.lifecycle.state.kind === "quiescing" && agent.lifecycle.state.reason === "update")))
     return false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "usebeeline",
-  "version": "0.1.30",
+  "version": "0.1.33",
   "description": "Connect an AI coding agent to Beeline with one command.",
   "homepage": "https://usebeeline.app",
   "bugs": {