jefrichat-mcp 0.49.40 → 0.49.41

package/dist/index.js

@@ -64184,6 +64184,8 @@ import { createHash as createHash7, randomUUID as randomUUID11 } from "node:cryp
 
 // src/terminal-live/hub-protocol.ts
 import { randomUUID as randomUUID8 } from "node:crypto";
+var NativeHubUnavailable = class extends Error {
+};
 function nativeHubRequest(client, operation, payload = {}, timeoutMs = 1e4) {
   const generation = client.generation, requestId = randomUUID8();
   return new Promise((resolve, reject) => {
@@ -64194,7 +64196,7 @@ function nativeHubRequest(client, operation, payload = {}, timeoutMs = 1e4) {
     };
     const closed = () => {
       cleanup();
-      reject(Error("Native hub connection ended; outcome may be unknown"));
+      reject(new NativeHubUnavailable("Native hub connection ended; outcome may be unknown"));
     };
     const answer = (event) => {
       if (event.requestId !== requestId) return;
@@ -64210,12 +64212,12 @@ function nativeHubRequest(client, operation, payload = {}, timeoutMs = 1e4) {
     };
     const timer2 = setTimeout(() => {
       cleanup();
-      reject(Error("Native hub response timed out; do not retry uncertain work"));
+      reject(new NativeHubUnavailable("Native hub response timed out; do not retry uncertain work"));
     }, timeoutMs);
     client.on("native_terminal_result", answer);
     client.on("socket_close", closed);
     try {
-      if (!client.online) throw Error("Native hub is not connected");
+      if (!client.online) throw new NativeHubUnavailable("Native hub is not connected");
       client.sendNativeFrame({ type: "native_terminal", requestId, operation, payload });
     } catch (e) {
       cleanup();
@@ -64231,7 +64233,7 @@ init_state_root();
 import { randomUUID as randomUUID9 } from "node:crypto";
 var LEASE_MS = 5 * 6e4;
 var QUEUE_LIMIT = 64;
-function createTerminalLiveBroker(now = () => Date.now()) {
+function createTerminalLiveBroker(now = () => Date.now(), onStopped) {
   let session;
   let reason = "off";
   let timer2;
@@ -64256,7 +64258,7 @@ function createTerminalLiveBroker(now = () => Date.now()) {
     e.record = r;
     track(r);
   }
-  function stop(why = "off") {
+  function stop(why = "off", recoverable = false) {
     ++serial;
     reason = why;
     const s = session;
@@ -64286,6 +64288,7 @@ function createTerminalLiveBroker(now = () => Date.now()) {
       s.binding.release();
     } catch {
     }
+    onStopped?.(why, recoverable);
   }
   async function refresh(s) {
     if (!current(s)) return;
@@ -64298,7 +64301,7 @@ function createTerminalLiveBroker(now = () => Date.now()) {
           throw Error("expired authority");
         s.authority = authority;
       } catch {
-        if (current(s)) stop("permission unavailable; enable again after verification");
+        if (current(s)) stop("permission unavailable; fresh session verification required", true);
       } finally {
         s.refreshing = void 0;
       }
@@ -64443,6 +64446,7 @@ function createTerminalLiveBroker(now = () => Date.now()) {
         journal,
         // Truthful: armed is not the same as actually listening.
         monitorAttached: adapter2 ? attached : null,
+        monitorLifetime: adapter2?.monitorLifetime?.() ?? null,
         ...adapter2?.reattachable && !attached && adapter2.rearmCommand ? { rearm: adapter2.rearmCommand, note: "No wake can arrive until this command is running again." } : {}
       };
     },
@@ -64704,18 +64708,34 @@ function codexQueueTransport(thread, endpoint) {
 // src/terminal-live/register.ts
 init_monitor();
 function registerTerminalLive(server2, deps) {
-  const broker = createTerminalLiveBroker();
+  let requested;
+  let resetInProgress = false;
+  let recoveryTimer;
+  let recoveryRun;
+  let recoveryAgain = false;
+  let recovering;
+  const broker = createTerminalLiveBroker(void 0, (why, recoverable) => {
+    if (resetInProgress) return;
+    if (recoverable && requested) scheduleRecovery(why);
+    else stop(why);
+  });
   let generation = 0;
   let pending;
   let pendingTimer;
   let bound;
   const releases = /* @__PURE__ */ new Set();
   let unconfirmedRelease = false;
-  const stop = (why = "off") => {
+  let releaseRetryAfter = 0;
+  const resetBinding = (why) => {
     ++generation;
     clearTimeout(pendingTimer);
     pendingTimer = void 0;
-    broker.stop(why);
+    resetInProgress = true;
+    try {
+      broker.stop(why);
+    } finally {
+      resetInProgress = false;
+    }
     const p = pending;
     pending = void 0;
     try {
@@ -64725,6 +64745,111 @@ function registerTerminalLive(server2, deps) {
     }
     bound = void 0;
   };
+  const stop = (why = "off") => {
+    clearTimeout(recoveryTimer);
+    recoveryTimer = void 0;
+    recoveryRun = void 0;
+    recoveryAgain = false;
+    const intent = requested;
+    requested = void 0;
+    recovering = void 0;
+    intent?.detach();
+    resetBinding(why);
+  };
+  const sameSession = (i) => requested === i && deps.currentClient() === i.client && deps.hub() === i.hub && i.client.token === i.token && i.client.identity?.username === i.self && i.client.identity?.owner === i.owner && !getAuto().enabled && !standbyEngaged();
+  function scheduleRecovery(why, delay = 1e3) {
+    const intent = requested;
+    if (!intent) return;
+    if (!sameSession(intent)) {
+      stop("monitor session or identity changed; enable explicitly in the new session");
+      return;
+    }
+    resetBinding(why);
+    recovering = "connection interrupted; monitor requested in this session, awaiting fresh native verification";
+    if (recoveryRun) {
+      recoveryAgain = true;
+      return;
+    }
+    if (recoveryTimer) return;
+    recoveryTimer = setTimeout(() => {
+      recoveryTimer = void 0;
+      void recoverSession(intent);
+    }, delay);
+    recoveryTimer.unref?.();
+  }
+  async function recoverSession(intent) {
+    if (!sameSession(intent)) {
+      if (requested === intent) stop("monitor session or identity changed");
+      return;
+    }
+    if (!intent.registered || !intent.client.online) {
+      scheduleRecovery("waiting for the same session to reconnect", 5e3);
+      return;
+    }
+    const run = {};
+    recoveryRun = run;
+    let retry = false;
+    let delay = 5e3;
+    const connectionGeneration = intent.client.generation;
+    try {
+      await Promise.all([...releases]);
+      if (!sameSession(intent)) {
+        if (requested === intent) stop("monitor session or identity changed");
+        return;
+      }
+      if (!intent.registered || !intent.client.online) throw new NativeHubUnavailable("Session is not registered yet");
+      if (Date.now() < releaseRetryAfter && intent.client.generation === intent.connectionGeneration) {
+        retry = true;
+        delay = Math.max(1e3, releaseRetryAfter - Date.now());
+        return;
+      }
+      await prepare(intent.args, intent);
+      if (requested === intent && pending) recovering = "reconnected; waiting for the native callback in the original conversation";
+    } catch (e) {
+      if (requested !== intent) return;
+      if (sameSession(intent) && (e instanceof NativeHubUnavailable || recoveryAgain || !intent.client.online || intent.client.generation !== connectionGeneration)) retry = true;
+      else stop("monitor recovery refused; inspect status and explicitly enable after resolving the cause");
+    } finally {
+      if (recoveryRun === run) {
+        recoveryRun = void 0;
+        const again = recoveryAgain;
+        recoveryAgain = false;
+        if ((retry || again) && requested === intent) scheduleRecovery("temporary hub unavailability", again ? 1e3 : delay);
+      }
+    }
+  }
+  function rememberSession(intent) {
+    if (requested) return;
+    requested = intent;
+    const lost = () => {
+      intent.registered = false;
+      scheduleRecovery("hub connection interrupted");
+    };
+    const registered = () => {
+      intent.registered = true;
+      if (recovering) scheduleRecovery("same session reconnected");
+    };
+    intent.client.on("socket_close", lost);
+    intent.client.on("registered", registered);
+    intent.detach = () => {
+      intent.client.off("socket_close", lost);
+      intent.client.off("registered", registered);
+    };
+  }
+  const status = () => {
+    const snapshot2 = broker.status();
+    return {
+      ...snapshot2,
+      preparing: !!pending,
+      monitorRequested: !!requested,
+      sessionScoped: true,
+      ...recovering ? { state: recovering, recovery: "same-session native probe; no delivery until verified" } : {},
+      ...snapshot2.monitorLifetime === "capped" ? {
+        persistenceWarning: "This attached watch is time-limited, NOT session-persistent. Do not report persistence as verified.",
+        persistenceInstruction: "If this host's Monitor supports persistent: true, replace ONLY this capped reader with the same watch command plus --persistent AND persistent: true. Otherwise keep re-arming before the cap. Do not start a duplicate reader or change the agent's autonomy."
+      } : {}
+    };
+  };
   const result = (data) => ({ content: [{ type: "text", text: JSON.stringify(data) }] });
   const wrap2 = (fn) => async (args, extra) => {
     const signal = args.action === "off" || args.action === "status" || args.action === "check" ? void 0 : extra?.signal;
@@ -64750,6 +64875,8 @@ function registerTerminalLive(server2, deps) {
     if (!supported(host)) throw Error(`Native preview hosts are ${NATIVE_PILOT_PROFILES.join(" or ")}; set JEFRI_TERMINAL_HOST to the matching local connector host.`);
     if (!c2.identity?.username || !c2.identity.owner || !c2.token) throw Error("A named credential and its owner are required");
     const answer = await credentialProfileDecision(deps.hub(), c2.token);
+    if (answer.lookup.kind === "locked" && /^(network|http_(408|425|429|5\d\d))$/.test(answer.lookup.reason))
+      throw new NativeHubUnavailable("Native credential verification temporarily unavailable");
     const profile = answer.lookup.kind === "profile" ? answer.lookup.profile : null;
     if (!stillCurrent() || profile !== host || !mechanismAllowed(profile, true, "terminal_live", true) || answer.verifiedAt === null || !credentialProfileDecisionCurrent(answer))
       throw Error("Native live refused: the current connection needs a verified credential for this terminal host. Check its identity, hub and connection; changing autonomy will not repair a credential mismatch.");
@@ -64774,27 +64901,26 @@ function registerTerminalLive(server2, deps) {
       };
     }
     if (args.action === "status") return {
-      ...broker.status(),
-      preparing: !!pending,
+      ...status(),
       hub: deps.hub(),
       username: deps.currentClient()?.identity?.username ?? null,
       autonomyEnabled: getAuto().enabled,
       scope: "owner-side DMs and groups; experimental; current interactive session must stay open; no 10k certification"
     };
     if (args.action === "check") {
-      const c3 = deps.currentClient();
-      if (!c3?.online) throw Error("Select and connect a Jefri identity in THIS session first: use jefri_whoami to verify username and hub, and jefri_be if unassigned. Do not take over another session without the user's approval.");
-      const hub2 = deps.hub(), token2 = c3.token, connectionGeneration2 = c3.generation;
-      const self2 = c3.identity?.username, owner3 = c3.identity?.owner, attempt2 = generation;
-      const stillCurrent = () => attempt2 === generation && deps.currentClient() === c3 && deps.hub() === hub2 && c3.online && c3.token === token2 && c3.generation === connectionGeneration2 && c3.identity?.username === self2 && c3.identity?.owner === owner3;
-      const authority = await verifyAuthority(c3, stillCurrent);
+      const c2 = deps.currentClient();
+      if (!c2?.online) throw Error("Select and connect a Jefri identity in THIS session first: use jefri_whoami to verify username and hub, and jefri_be if unassigned. Do not take over another session without the user's approval.");
+      const hub = deps.hub(), token = c2.token, connectionGeneration = c2.generation;
+      const self = c2.identity?.username, owner2 = c2.identity?.owner, attempt = generation;
+      const stillCurrent = () => attempt === generation && deps.currentClient() === c2 && deps.hub() === hub && c2.online && c2.token === token && c2.generation === connectionGeneration && c2.identity?.username === self && c2.identity?.owner === owner2;
+      const authority = await verifyAuthority(c2, stillCurrent);
       if (host === "codex_local") await checkCodexQueue();
       if (!stillCurrent() || !credentialProfileDecisionCurrent(authority)) throw Error("Native binding superseded during preflight");
       const auto = getAuto(), standby = standbyEngaged(), nativeActive = broker.active() || !!pending;
       return {
         state: "preflight only; no settings changed",
-        hub: hub2,
-        username: self2,
+        hub,
+        username: self,
         host,
         hubEligible: true,
         canPrepare: !auto.enabled && !standby && !nativeActive,
@@ -64808,6 +64934,10 @@ function registerTerminalLive(server2, deps) {
       };
     }
     if (args.action === "recover") return broker.recover(args.cursor, args.localCursor);
+    if (requested) throw Error("Monitor is already requested in this session; inspect status or turn it off before preparing again");
+    return prepare(args);
+  }));
+  async function prepare(args, recoveryIntent) {
     if (args.confirmPreview !== true) throw Error("Explicit user opt-in required: confirmPreview:true");
     if (host === "codex_local" && !deps.env.JEFRI_TERMINAL_THREAD_ID && !args.threadId)
       throw Error("Codex needs its exact live thread: run `printenv CODEX_THREAD_ID` in THIS session and pass it as threadId (or set JEFRI_TERMINAL_THREAD_ID before launching). A name, --last or a stale id is refused.");
@@ -64815,6 +64945,8 @@ function registerTerminalLive(server2, deps) {
     if (broker.active() || pending) throw Error("Turn native live off before preparing a new binding");
     const attempt = ++generation;
     const c2 = await deps.ensureClient();
+    if (recoveryIntent && (!sameSession(recoveryIntent) || c2 !== recoveryIntent.client))
+      throw Error("Monitor recovery session changed");
     const hub = deps.hub();
     const self = c2.identity?.username, owner2 = c2.identity?.owner;
     if (!self || !owner2 || !c2.token) throw Error("A named credential and its owner are required");
@@ -64834,6 +64966,7 @@ function registerTerminalLive(server2, deps) {
             return true;
           } catch {
             unconfirmedRelease = true;
+            releaseRetryAfter = Date.now() + 65e3;
             return false;
           }
         })();
@@ -64884,6 +65017,7 @@ function registerTerminalLive(server2, deps) {
           await activation;
           activated = true;
           unconfirmedRelease = false;
+          releaseRetryAfter = 0;
           if (!current()) {
             await releaseHub();
             throw Error("Native binding superseded");
@@ -64899,6 +65033,7 @@ function registerTerminalLive(server2, deps) {
           host,
           target: t.target,
           ready: () => t.ready(),
+          monitorLifetime: () => !t.ready() ? "detached" : t.monitorDescriptor && !t.sessionWatch?.() ? "capped" : "session",
           reattachable: t.reattachable,
           ...t.monitorDescriptor ? { rearmCommand: deps.monitorCommand(t.monitorDescriptor) } : {},
           notify: (wake) => t.emit(claimPrompt(wake, self)),
@@ -64918,10 +65053,24 @@ function registerTerminalLive(server2, deps) {
         }
       };
       const nonce = randomUUID11();
-      pending = { nonce, until: Date.now() + 12e4, binding, transport: t };
+      const intent = recoveryIntent ?? {
+        client: c2,
+        hub,
+        token,
+        self,
+        owner: owner2,
+        connectionGeneration,
+        registered: true,
+        args: { confirmPreview: true, replyMode, ...host === "codex_local" ? { threadId: deps.env.JEFRI_TERMINAL_THREAD_ID || args.threadId } : {} },
+        detach() {
+        }
+      };
+      pending = { nonce, until: recoveryIntent ? Infinity : Date.now() + 12e4, binding, transport: t, intent };
       bound = { hub, token };
-      pendingTimer = setTimeout(() => stop("native probe expired; nothing armed"), 12e4);
-      pendingTimer.unref();
+      if (!recoveryIntent) {
+        pendingTimer = setTimeout(() => stop("native probe expired; nothing armed"), 12e4);
+        pendingTimer.unref();
+      }
       await t.emit(probePrompt(nonce, self));
       if (!current()) throw Error("Native binding superseded");
       return {
@@ -64966,13 +65115,16 @@ function registerTerminalLive(server2, deps) {
         warning: "This tests transport only, not busy/approval/reconnect safety or broad release readiness."
       };
     } catch (e) {
-      if (attempt === generation) stop("native preparation failed");
+      if (attempt === generation) {
+        if (recoveryIntent) resetBinding("native recovery preparation failed");
+        else stop("native preparation failed");
+      }
       transport?.close();
       lock2.release();
       lock2.close();
       throw e;
     }
-  }));
+  }
   server2.registerTool("jefri_terminal_ready", {
     title: "Confirm native terminal wake",
     description: "Transport callback only: use the nonce delivered through the native channel/queue/monitor in THIS conversation. Do not guess it or copy it between sessions. This completes the user's explicit preview opt-in.",
@@ -64990,7 +65142,10 @@ function registerTerminalLive(server2, deps) {
       p.binding.release();
       throw e;
     }
-    return { ...broker.status(), scope: "Same-owner agents and group text with tmux sender/routing rules. Native callback verified; actual host acceptance remains unverified. Host must stay running." };
+    p.intent.connectionGeneration = p.intent.client.generation;
+    rememberSession(p.intent);
+    recovering = void 0;
+    return { ...status(), scope: "Same-owner agents and group text with tmux sender/routing rules. Native callback verified; actual host acceptance remains unverified. Host must stay running. Monitor ON lasts only in this MCP session; reconnects require a fresh native callback, never a saved global ON setting." };
   }));
   server2.registerTool("jefri_terminal_claim", {
     title: "Claim native terminal delivery",
@@ -65004,14 +65159,14 @@ function registerTerminalLive(server2, deps) {
   }, wrap2(({ wake, text: text5 }) => broker.reply(wake, text5)));
   return {
     stop,
-    active: () => broker.active() || !!pending,
+    active: () => broker.active() || !!pending || !!requested,
     reject(hub, token) {
-      if (bound?.hub === hub && bound.token === token) stop("credential rejected");
+      if (bound?.hub === hub && bound.token === token || requested?.hub === hub && requested.token === token) stop("credential rejected");
     },
     offer: broker.offer,
     cancelGroup: broker.cancelGroup,
     unresolvedGroup: broker.unresolvedGroup,
-    status: broker.status
+    status
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jefrichat-mcp",
-  "version": "0.49.40",
+  "version": "0.49.41",
   "engines": {
     "node": ">=22.13"
   },