@essentialai/cogent-bridge-bundled 3.23.8 → 3.24.0

package/cogent-bridge.mjs

@@ -26389,8 +26389,8 @@ var init_stdio2 = __esm({
 // src/constants.ts
 import { createRequire } from "node:module";
 function resolveVersion() {
-  if ("3.23.8") {
-    return "3.23.8";
+  if ("3.24.0") {
+    return "3.24.0";
   }
   try {
     const require2 = createRequire(import.meta.url);
@@ -32141,6 +32141,15 @@ var init_ws_client = __esm({
       backoff;
       reconnectTimer = null;
       pollTimer = null;
+      /**
+       * DELIVERY-PATH EVIDENCE. Before 3.23.9 a poll failure was caught and only logger.warn'd, so the
+       * bridge had no idea whether its FALLBACK delivery path worked — and `healthy` could not be
+       * computed honestly because the data did not exist. Captured evidence that nothing reads is the
+       * defect shape this codebase keeps hitting.
+       */
+      lastPollOkAt = null;
+      lastPollError = null;
+      lastWsErrorSticky = null;
       pingTimer = null;
       lastMessageId = null;
       /**
@@ -32219,6 +32228,7 @@ var init_ws_client = __esm({
         this.ws = ws;
         ws.on("open", () => {
           if (generation !== this.connectionGeneration || this.ws !== ws) return;
+          this.lastWsErrorSticky = null;
           this.setState("connected");
           this.backoff.reset();
           this.stopPolling();
@@ -32275,6 +32285,7 @@ var init_ws_client = __esm({
         ws.on("error", (err) => {
           if (generation !== this.connectionGeneration || this.ws !== ws) return;
           this.lastWsError = err.message;
+          this.lastWsErrorSticky = err.message;
           logger.error(`CloudWsClient: WebSocket error: ${err.message}`);
         });
       }
@@ -32338,6 +32349,18 @@ var init_ws_client = __esm({
        * ISO string. Survives reconnects, same as `getLastFrameAt()`.
        * Audit L2.
        */
+      /**
+       * What this bridge's DELIVERY situation actually is — the input `healthy` needs in order to
+       * describe THIS BRIDGE rather than the relay's uptime.
+       */
+      getDeliveryDiagnostics() {
+        return {
+          pollActive: this.pollTimer !== null,
+          lastPollOkAt: this.lastPollOkAt,
+          lastPollError: this.lastPollError,
+          lastWsError: this.lastWsErrorSticky
+        };
+      }
       getLastFrameAtMs() {
         return this.lastFrameAt;
       }
@@ -32474,10 +32497,11 @@ var init_ws_client = __esm({
               this.opts.onMessages(result.messages);
               this.advanceCursor(result.messages[result.messages.length - 1].id);
             }
+            this.lastPollOkAt = Date.now();
+            this.lastPollError = null;
           } catch (err) {
-            logger.warn(
-              `CloudWsClient: Poll failed: ${err instanceof Error ? err.message : String(err)}`
-            );
+            this.lastPollError = err instanceof Error ? err.message : String(err);
+            logger.warn(`CloudWsClient: Poll failed: ${this.lastPollError}`);
           }
         };
         void poll();
@@ -35098,6 +35122,113 @@ var init_auto_relay = __esm({
   }
 });
 
+// src/services/peer-presence.ts
+function autoPresenceEnabled(env = process.env) {
+  const v = env.COGENT_AUTO_PRESENCE;
+  if (v === void 0 || v === "") return true;
+  return !/^(0|false|no|off)$/i.test(v.trim());
+}
+async function restorePresence(deps) {
+  try {
+    if (!deps.isCloudConfigured()) {
+      return { state: "local", restored: false, detail: "local mode \u2014 presence does not apply" };
+    }
+    if (deps.alreadyRegisteredInProcess()) {
+      return { state: "online", restored: false, detail: "registered by this process" };
+    }
+    const creds = await deps.loadCredentials();
+    if (!creds || !creds.endpoint || !creds.sessionId || !creds.token) {
+      return {
+        state: "deferred",
+        restored: false,
+        detail: "no stored channel credentials for this working directory \u2014 join a channel first"
+      };
+    }
+    if (!creds.peerId) {
+      return {
+        state: "deferred",
+        restored: false,
+        detail: "channel credentials exist but name no peer \u2014 nothing was registered here"
+      };
+    }
+    const peerId = creds.peerId;
+    if (deps.peerAlreadyServed(peerId)) {
+      return {
+        state: "online",
+        restored: false,
+        detail: `peer '${peerId}' is already served by a live bridge for this working directory`
+      };
+    }
+    if (!autoPresenceEnabled(deps.env ?? process.env)) {
+      return {
+        state: "offline",
+        restored: false,
+        detail: `peer '${peerId}' is not registered and COGENT_AUTO_PRESENCE is off \u2014 this agent is absent from its channel`
+      };
+    }
+    await deps.goOnline({
+      peerId,
+      endpoint: creds.endpoint,
+      sessionId: creds.sessionId,
+      token: creds.token,
+      cwd: deps.cwd(),
+      // 🔴 THE PEER'S DISPLAY LABEL IS NOT PERSISTED ANYWHERE — only the CHANNEL's is,
+      // in credentials.label (create-session.ts writes `label: data.label`; join-session
+      // writes the resolved channel label). Using that would label the agent after the
+      // channel: a restore once put "paymentorchestrator" beside a sibling called "POFE".
+      // peerId is the one identifier we hold that genuinely names this agent. The
+      // operator's chosen label returns on the next cogent_register_peer, which carries it.
+      label: peerId,
+      // 🔴 WITHOUT THIS THE RESTORE CANNOT RECLAIM ITS OWN PEER. A re-join issues a NEW
+      // token, and AUD-003 ownership is proven by the token that CREATED the peer or by
+      // the secret issued with it. Omitting it means an entry owned by an earlier token
+      // answers PEER_NOT_YOURS and the agent stays offline — precisely the state this
+      // module exists to leave. The secret is in the credential file; send it.
+      peerSecret: creds.peerSecret
+    });
+    return {
+      state: "online",
+      restored: true,
+      peerId,
+      // Says what THIS process did. Whether the relay now lists the peer is the relay's
+      // state, and asserting it from here would be a success nobody measured.
+      detail: `re-registered peer '${peerId}' from stored credentials`
+    };
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return {
+      state: "offline",
+      restored: false,
+      detail: `presence restore failed: ${reason}`
+    };
+  }
+}
+function setPresence(outcome) {
+  lastPresence = outcome;
+}
+function getPresence() {
+  return lastPresence;
+}
+function logPresence(outcome) {
+  if (outcome.state === "online" && outcome.restored) {
+    logger.info(
+      `Presence: offline -> online \u2014 ${outcome.detail}. This agent is addressable on its channel again, and leftover bridges for this checkout are now reapable.`
+    );
+  } else if (outcome.state === "offline") {
+    logger.warn(`Presence: OFFLINE \u2014 ${outcome.detail}.`);
+  } else {
+    logger.debug(`Presence: ${outcome.state} \u2014 ${outcome.detail}.`);
+  }
+}
+var lastPresence;
+var init_peer_presence = __esm({
+  "src/services/peer-presence.ts"() {
+    "use strict";
+    init_logger();
+    lastPresence = null;
+  }
+});
+
 // src/services/heartbeat.ts
 var HeartbeatService, heartbeat;
 var init_heartbeat = __esm({
@@ -35329,8 +35460,10 @@ __export(startup_exports, {
   cloudWsClient: () => cloudWsClient,
   hasPendingLabelResolve: () => hasPendingLabelResolve,
   isCloudMode: () => isCloudMode2,
+  presenceRegisterArgs: () => presenceRegisterArgs,
   reinitCloudBackend: () => reinitCloudBackend,
   resolvePendingLabel: () => resolvePendingLabel,
+  restorePeerPresence: () => restorePeerPresence,
   runPreflights: () => runPreflights,
   runStartup: () => runStartup,
   setInboxNotifier: () => setInboxNotifier,
@@ -35461,6 +35594,58 @@ async function triggerReRegistration() {
     reRegistrationInProgress = false;
   }
 }
+function presenceRegisterArgs(p) {
+  return [
+    p.peerId,
+    p.sessionId,
+    p.cwd,
+    p.label,
+    CLIENT_VERSION,
+    "agent",
+    void 0,
+    // channelSessionId — not tracked on a presence restore
+    void 0,
+    // capabilities — likewise
+    deriveWorkspaceId(p.cwd),
+    p.sessionId,
+    // threadId
+    p.peerSecret
+    // AUD-003 ownership proof — reclaims a peer owned by an earlier token
+  ];
+}
+async function restorePeerPresence() {
+  const outcome = await restorePresence({
+    // The endpoint being a relay URL is what makes presence meaningful. We deliberately do
+    // NOT gate on the active backend being the cloud one: at startup it is still the
+    // deferred FileBackend placeholder, and gating on it made this whole path inert
+    // (measured: "skipped: not-cloud-mode" with valid credentials on disk).
+    isCloudConfigured: () => {
+      const ep = getConfig().COGENT_ENDPOINT;
+      return !!ep && isCloudEndpoint(ep);
+    },
+    alreadyRegisteredInProcess: () => autoRelay.getDiagnostics().registered,
+    peerAlreadyServed: (peerId) => {
+      try {
+        return listLiveBridges(process.cwd(), peerId).some((b) => b.pid !== process.pid);
+      } catch {
+        return false;
+      }
+    },
+    loadCredentials: () => loadCredentials(),
+    cwd: () => process.cwd(),
+    goOnline: async ({ peerId, endpoint, sessionId, token, cwd, label, peerSecret }) => {
+      await reinitCloudBackend(endpoint, sessionId, token);
+      const backend = getBackend();
+      await backend.registerPeer(...presenceRegisterArgs({ peerId, sessionId, cwd, label, peerSecret }));
+      autoRelay.setLocalPeer(peerId, sessionId, cwd, "agent", label, sessionId);
+      if (cloudWsClient) cloudWsClient.setPeerId(peerId);
+      heartbeat.restart();
+    }
+  });
+  setPresence(outcome);
+  logPresence(outcome);
+  return outcome;
+}
 function createCloudWsClient(endpoint, sessionId, token, http, inbox, pollIntervalMs) {
   const client = new CloudWsClient({
     endpoint,
@@ -35712,6 +35897,8 @@ var init_startup = __esm({
     init_cloud();
     init_http_client();
     init_auto_relay();
+    init_peer_presence();
+    init_wake_ownership();
     init_heartbeat();
     init_codex_preflight();
     init_codex_cli();
@@ -37089,6 +37276,18 @@ function registerDeregisterPeerTool(server) {
             logger.warn("failed to clear local mail credentials after deprovision", { error: err });
           }
         }
+        if (removed) {
+          try {
+            const creds = await loadCredentials();
+            if (creds?.peerId === peerId) {
+              const { peerId: _dropped, peerSecret: _secret, ...rest } = creds;
+              await saveCredentials({ ...rest, savedAt: (/* @__PURE__ */ new Date()).toISOString() });
+              logger.info("cleared stored peerId after deregister", { peerId });
+            }
+          } catch (err) {
+            logger.warn("failed to clear stored peerId after deregister", { error: err });
+          }
+        }
         return successResult({
           success: removed,
           message: removed ? `Peer '${peerId}' deregistered` : `Peer '${peerId}' was not registered`
@@ -37111,6 +37310,7 @@ var init_deregister_peer = __esm({
     init_logger();
     init_heartbeat();
     init_mail_credential_store();
+    init_credential_store();
   }
 });
 
@@ -37134,12 +37334,14 @@ function registerHealthCheckTool(server) {
         const backend = getBackend();
         const result = await backend.checkHealth();
         let wsConnected = false;
+        let delivery = null;
         let wsLastFrameAt = null;
         let wsLastFrameAtMs = null;
         try {
           const startup = await Promise.resolve().then(() => (init_startup(), startup_exports));
           if (startup.cloudWsClient) {
             wsConnected = startup.cloudWsClient.isConnected();
+            delivery = startup.cloudWsClient.getDeliveryDiagnostics?.() ?? null;
             wsLastFrameAt = startup.cloudWsClient.getLastFrameAt();
             wsLastFrameAtMs = startup.cloudWsClient.getLastFrameAtMs();
           }
@@ -37177,8 +37379,20 @@ function registerHealthCheckTool(server) {
           }
         }
         const updateAvailable = getLastNudge();
+        const relayHealthy = result.healthy !== false;
+        let deliveryPath = "unknown";
+        if (cloud && delivery) {
+          deliveryPath = wsConnected ? "websocket" : delivery.pollActive && !delivery.lastPollError ? "poll" : "none";
+        } else if (cloud && wsConnected) {
+          deliveryPath = "websocket";
+        }
+        const registered = autoRelay.getDiagnostics().registered;
+        const deliveryBroken = cloud && registered && deliveryPath === "none";
+        const unhealthyReason = deliveryBroken ? `registered as a cloud peer but NO delivery path is working (websocket down${delivery?.lastWsError ? `: ${delivery.lastWsError}` : ""}; poll ${delivery?.lastPollError ? `failing: ${delivery.lastPollError}` : "inactive"}) \u2014 messages addressed to this peer cannot reach it` : null;
         const enriched = {
           ...JSON.parse(JSON.stringify(result)),
+          healthy: relayHealthy && !deliveryBroken,
+          ...unhealthyReason ? { unhealthyReason } : {},
           clientVersion: SERVER_VERSION,
           ...updateAvailable ? { updateAvailable } : {},
           runtimeMode: cloud ? "cloud" : "local",
@@ -37198,9 +37412,26 @@ function registerHealthCheckTool(server) {
             // on HttpBackend; null when the /api/health fetch fails. Keep the
             // key cloud-gated for shape consistency with wsHealth (local mode
             // never has an upstream relay version to report).
-            ...cloud ? { wsHealth, relayVersion } : {}
+            ...cloud ? { wsHealth, relayVersion, deliveryPath, lastWsError: delivery?.lastWsError ?? null } : {}
           },
-          autoRelay: autoRelay.getDiagnostics()
+          autoRelay: autoRelay.getDiagnostics(),
+          // PRESENCE — the agent's own view of whether it is IN its channel, so it can
+          // answer "am I reachable?" without inferring it from transport internals.
+          // "online" registered · "offline" owns a peer but is not registered (nobody can
+          // reach it) · "deferred" never joined · "local" no relay.
+          // services/peer-presence.ts carries the vocabulary and how each state arises.
+          presence: (() => {
+            const p = getPresence();
+            if (!p) {
+              return { state: "unknown", detail: "presence has not been evaluated yet" };
+            }
+            return {
+              state: p.state,
+              restored: p.restored,
+              detail: p.detail,
+              ..."peerId" in p ? { peerId: p.peerId } : {}
+            };
+          })()
         };
         return successResult(enriched);
       } catch (err) {
@@ -37220,6 +37451,7 @@ var init_health_check2 = __esm({
     init_errors4();
     init_logger();
     init_auto_relay();
+    init_peer_presence();
   }
 });
 
@@ -93981,6 +94213,11 @@ async function main() {
       `Preflight error (non-fatal): ${err instanceof Error ? err.message : String(err)}`
     );
   });
+  void restorePeerPresence().catch((err) => {
+    logger.warn(
+      `Presence restore error (non-fatal): ${err instanceof Error ? err.message : String(err)}`
+    );
+  });
   startUpdateCheckLoop(SERVER_VERSION);
   logger.info(
     "Server ready. Tools: cogent_register_peer, cogent_deregister_peer, cogent_send_message, cogent_list_peers, cogent_get_history, cogent_health_check, cogent_create_session, cogent_join_session"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@essentialai/cogent-bridge-bundled",
-  "version": "3.23.8",
+  "version": "3.24.0",
   "description": "Zero-dependency, pre-bundled Cogent MCP bridge — a single self-contained file for fast cold `npx` startup (used by the Codex plugin, whose MCP startup window is short). Functionally identical to @essentialai/cogent-bridge; carries no npm dependencies so `npx` skips dependency install.",
   "type": "module",
   "bin": {