usebeeline 0.1.31 → 0.1.34

package/dist/usebeeline.mjs

@@ -5804,14 +5804,13 @@ var init_self_update = __esm({
       fetchImpl;
       log;
       stageOnly;
-      nextCheckAllowedAt = 0;
       disposed = false;
       applying = false;
       deferredBusyNotice = false;
       lastVerdictLog = "";
       constructor(options) {
         const env = options.env ?? process.env;
-        const numberEnv2 = (name, fallback) => {
+        const numberEnv = (name, fallback) => {
           const raw = env[name];
           if (!raw)
             return fallback;
@@ -5820,8 +5819,7 @@ var init_self_update = __esm({
         };
         this.options = {
           layout: options.layout,
-          checkIntervalMs: options.checkIntervalMs ?? numberEnv2("BEELINE_UPDATE_INTERVAL_MS", 6 * 60 * 6e4),
-          idleTimeoutMs: options.idleTimeoutMs ?? numberEnv2("BEELINE_UPDATE_IDLE_TIMEOUT_MS", 30 * 6e4),
+          idleTimeoutMs: options.idleTimeoutMs ?? numberEnv("BEELINE_UPDATE_IDLE_TIMEOUT_MS", 30 * 6e4),
           idlePollMs: options.idlePollMs ?? 5e3,
           env,
           now: options.now ?? Date.now
@@ -5846,7 +5844,7 @@ var init_self_update = __esm({
           return;
         const now2 = this.options.now();
         const disabled = this.options.env.BEELINE_UPDATE_DISABLE === "1";
-        if (disabled || now2 < this.nextCheckAllowedAt)
+        if (disabled)
           return;
         this.applying = true;
         try {
@@ -18819,6 +18817,7 @@ var AgentChannel = class {
       this.#registeredAt = Date.now();
       this.#registrations += 1;
       this.handlers.onOpen();
+      this.machine.registered();
       for (const listener of [...this.#openListeners]) {
         try {
           listener();
@@ -18890,6 +18889,8 @@ var MachineLink = class {
   link;
   #channels = /* @__PURE__ */ new Map();
   #identity = { releaseVersion: "v0.0.0" };
+  #reconciledOnSocket = false;
+  #pendingRelease;
   random;
   constructor(options) {
     this.options = options;
@@ -18899,11 +18900,15 @@ var MachineLink = class {
       protocols: () => [MACHINE_SOCKET_PROTOCOL],
       factory: options.factory ?? ((url, protocols, socketOptions) => new wrapper_default(url, protocols, socketOptions)),
       onOpen: () => {
+        this.#reconciledOnSocket = false;
+        this.#pendingRelease = void 0;
         for (const channel of this.#channels.values())
           channel.register();
       },
       onMessage: (data) => this.#message(data),
       onClose: () => {
+        this.#reconciledOnSocket = false;
+        this.#pendingRelease = void 0;
         for (const channel of this.#channels.values())
           channel.socketClosed();
       },
@@ -18921,6 +18926,18 @@ var MachineLink = class {
       ...identity.sourceSha ? { sourceSha: identity.sourceSha } : {}
     };
   }
+  /** The first accepted registration follows the server's cached release frame. */
+  registered() {
+    if (this.#reconciledOnSocket)
+      return;
+    this.#reconciledOnSocket = true;
+    this.options.onRegistered?.();
+    if (this.#pendingRelease) {
+      const release = this.#pendingRelease;
+      this.#pendingRelease = void 0;
+      this.#broadcast(release);
+    }
+  }
   /** A later channel for the same agent (an in-process restart) replaces the earlier one. */
   attach(agentId, handlers) {
     return new AgentChannel(this, agentId, handlers);
@@ -18974,13 +18991,19 @@ var MachineLink = class {
       return;
     }
     if (event.type === "helper-release") {
-      for (const channel of this.#channels.values())
-        channel.broadcast(event);
+      if (!this.#reconciledOnSocket)
+        this.#pendingRelease = event;
+      else
+        this.#broadcast(event);
       return;
     }
     if (event.type !== "hello" && event.type !== "force-update")
       this.#logUnknown(event.type);
   }
+  #broadcast(event) {
+    for (const channel of this.#channels.values())
+      channel.broadcast(event);
+  }
 };
 
 // apps/body/dist/agent-sign-in.js
@@ -30549,7 +30572,6 @@ import { createHash as createHash8 } from "node:crypto";
 import { mkdir as mkdir13, rm as rm10, stat as stat8, writeFile as writeFile10 } from "node:fs/promises";
 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 = 5 * 6e4;
 var MAX_HOST_RESTART_STAGGER_MS = 15e3;
 function managedRestartStaggerMs(agentId, desiredRelease, drainDeadlineAt, now2 = Date.now()) {
@@ -30559,7 +30581,6 @@ function managedRestartStaggerMs(agentId, desiredRelease, drainDeadlineAt, now2
 }
 var UPDATE_WORKER_DEADLINE_MS = UPDATE_CONVERGENCE_SLO_MS - 6e4;
 var LOCK_STALE_MS = UPDATE_WORKER_DEADLINE_MS + 5 * 6e4;
-var DEFAULT_UPDATE_INITIAL_DELAY_MS = 0;
 async function withInstallLock(layout, work, options = {}) {
   const now2 = options.now ?? Date.now;
   const lock = resolve16(layout.releasesRoot, ".state", "install.lock");
@@ -30645,8 +30666,9 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
   #now;
   #env;
   #runUpdateWorker;
+  #onWorkerSettled;
   #drainDeadlineMs;
-  #nextUpdateCheckAt;
+  #checkRequested = false;
   #updateCycleDeadlineAt;
   #worker;
   #requested = false;
@@ -30659,8 +30681,8 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
     this.#now = options.now ?? Date.now;
     this.#env = options.env ?? process.env;
     this.#runUpdateWorker = options.runUpdateWorker ?? runManagedUpdateWorkerProcess;
+    this.#onWorkerSettled = options.onWorkerSettled;
     this.#drainDeadlineMs = options.drainDeadlineMs ?? UPDATE_DRAIN_DEADLINE_MS;
-    this.#nextUpdateCheckAt = this.#now() + numberEnv(this.#env, "BEELINE_UPDATE_INITIAL_DELAY_MS", DEFAULT_UPDATE_INITIAL_DELAY_MS);
   }
   static async create(layout, now2 = Date.now, options = {}) {
     const env = options.env ?? process.env;
@@ -30676,7 +30698,11 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
     if (!releaseKey || this.#notifiedReleaseKey === releaseKey)
       return;
     this.#notifiedReleaseKey = releaseKey;
-    this.#nextUpdateCheckAt = 0;
+    this.#checkRequested = true;
+  }
+  /** A fresh socket covers notices missed while disconnected with one manifest read. */
+  reconcileOnConnect() {
+    this.#checkRequested = true;
   }
   /**
    * Return true once the active release differs from the serving release.
@@ -30691,50 +30717,49 @@ var ManagedUpdateHandoff = class _ManagedUpdateHandoff {
   async check() {
     if (this.#requested || !this.#loadedRelease)
       return this.#requested;
-    if (this.#stagedReleaseId)
-      return false;
     const desiredRelease = await activeReleaseId(this.#layout).catch(() => void 0);
     if (desiredRelease && desiredRelease !== this.#loadedRelease) {
       return this.#armRestart(desiredRelease);
     }
-    const state = await readUpdateState(this.#layout);
-    if (state.stagedReleaseId && state.stagedReleaseId !== this.#loadedRelease) {
-      const requestedAt = this.#now();
-      this.#stagedReleaseId = state.stagedReleaseId;
-      this.#restartRequest = {
-        loadedRelease: this.#loadedRelease,
-        desiredRelease: state.stagedReleaseId,
-        drainDeadlineAt: requestedAt + this.#drainDeadlineMs
-      };
-      console.log(`[thin-core] staged update ${state.stagedReleaseId} is waiting for active turns to drain`);
-      return false;
-    }
-    const now2 = this.#now();
-    if (this.#env.BEELINE_UPDATE_DISABLE === "1" || now2 < this.#nextUpdateCheckAt)
+    if (this.#worker)
       return false;
-    this.#nextUpdateCheckAt = now2 + numberEnv(this.#env, "BEELINE_UPDATE_INTERVAL_MS", DEFAULT_UPDATE_INTERVAL_MS);
-    if (!this.#worker) {
+    if (this.#env.BEELINE_UPDATE_DISABLE !== "1" && this.#checkRequested) {
+      this.#checkRequested = false;
+      const now2 = this.#now();
+      const notifiedReleaseKey = this.#notifiedReleaseKey;
       this.#updateCycleDeadlineAt = now2 + this.#drainDeadlineMs;
       this.#worker = withInstallLock(this.#layout, async () => {
         const current = await activeReleaseId(this.#layout).catch(() => void 0);
         if (current && current !== this.#loadedRelease)
           return;
-        const state2 = await readUpdateState(this.#layout);
-        const interval = numberEnv(this.#env, "BEELINE_UPDATE_INTERVAL_MS", DEFAULT_UPDATE_INTERVAL_MS);
-        if (state2.notifiedReleaseKey === this.#notifiedReleaseKey && state2.lastCheckAt !== void 0 && now2 - state2.lastCheckAt < interval)
-          return;
         await this.#runUpdateWorker();
-        if (this.#notifiedReleaseKey) {
+        if (notifiedReleaseKey) {
           await writeUpdateState(this.#layout, {
             ...await readUpdateState(this.#layout),
-            notifiedReleaseKey: this.#notifiedReleaseKey
+            notifiedReleaseKey
           });
         }
       }).catch((error) => {
         console.error(`[thin-core] update worker failed: ${error instanceof Error ? error.message : String(error)}`);
       }).finally(() => {
         this.#worker = void 0;
+        this.#onWorkerSettled?.();
       });
+      return false;
+    }
+    if (this.#stagedReleaseId)
+      return false;
+    const state = await readUpdateState(this.#layout);
+    if (state.stagedReleaseId && state.stagedReleaseId !== this.#loadedRelease) {
+      const requestedAt = this.#now();
+      this.#stagedReleaseId = state.stagedReleaseId;
+      this.#restartRequest = {
+        loadedRelease: this.#loadedRelease,
+        desiredRelease: state.stagedReleaseId,
+        drainDeadlineAt: requestedAt + this.#drainDeadlineMs
+      };
+      console.log(`[thin-core] staged update ${state.stagedReleaseId} is waiting for active turns to drain`);
+      return false;
     }
     return false;
   }
@@ -30823,6 +30848,7 @@ var ManagedUpdateDrain = class {
   #clearTimer;
   #waitLogTimer;
   #resolving;
+  #rerunRequested = false;
   #restarting = false;
   constructor(options) {
     this.#options = options;
@@ -30837,10 +30863,21 @@ var ManagedUpdateDrain = class {
   #resolve() {
     if (this.#restarting)
       return Promise.resolve("restarting");
-    if (this.#resolving)
+    if (this.#resolving) {
+      this.#rerunRequested = true;
       return this.#resolving;
+    }
     this.#resolving = this.#step().finally(() => {
       this.#resolving = void 0;
+      if (this.#rerunRequested) {
+        this.#rerunRequested = false;
+        void this.#resolve().catch((error) => {
+          if (this.#options.failed)
+            this.#options.failed(error);
+          else
+            this.#log(`[thin-core] update drain failed: ${String(error)}`);
+        });
+      }
     });
     return this.#resolving;
   }
@@ -30891,10 +30928,6 @@ 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;
-}
 async function runManagedUpdateWorker() {
   const { beelineInstallLayout: beelineInstallLayout2 } = await Promise.resolve().then(() => (init_self_update(), self_update_exports));
   const layout = beelineInstallLayout2(process.env);
@@ -31014,8 +31047,8 @@ ${import_picocolors.default.dim("Usage:")}
   beeline update --force             Apply even when the comparison is indeterminate
   beeline update --manifest-url <u>  Override the published manifest URL
 
-The supervised daemon also checks automatically (every BEELINE_UPDATE_INTERVAL_MS,
-default 30s) with the same busy gate; BEELINE_UPDATE_DISABLE=1 turns the
+The supervised helper checks the manifest on connection and on release notices,
+then waits for a quiet gap to restart. BEELINE_UPDATE_DISABLE=1 turns the
 automatic path off. \`beeline update\` always works.
 `);
 }
@@ -36061,8 +36094,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;
@@ -49756,7 +49792,6 @@ async function runAgentRuntime(configPath, host, signal) {
       host.notifyReleaseAvailable(`${version}:${sha}`);
       void host.tickUpdate();
     });
-    daemonApi.onLiveOpen(() => void host.tickUpdate());
     core.setInteractiveIdleListener(() => {
       void host.tickUpdate();
     });
@@ -50142,7 +50177,11 @@ async function runMachineHelper(options = {}) {
   const machineKey = () => [...slots.values()].map((slot) => slot.agentId).sort()[0] ?? "helper";
   if (layout) {
     update = await ManagedUpdateHandoff.create(layout, Date.now, {
-      env
+      env,
+      ...options.runUpdateWorker ? { runUpdateWorker: options.runUpdateWorker } : {},
+      onWorkerSettled: () => {
+        void tickUpdate();
+      }
     });
   }
   const recoverManagedRestart = (error) => {
@@ -50188,7 +50227,13 @@ async function runMachineHelper(options = {}) {
     machineLink: (baseUrl) => {
       let link2 = links.get(baseUrl);
       if (!link2) {
-        link2 = new MachineLink({ baseUrl });
+        link2 = new MachineLink({
+          baseUrl,
+          onRegistered: () => {
+            update?.reconcileOnConnect();
+            void tickUpdate();
+          }
+        });
         link2.setHelperIdentity({
           releaseVersion: loadedReleaseIdentity?.version,
           sourceSha: loadedReleaseIdentity?.commit

package/package.json

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