jefrichat-mcp 0.49.18 → 0.49.21

package/dist/http.js

@@ -45341,7 +45341,7 @@ function isConnectorProfile(x) {
 }
 
 // src/http.ts
-import { randomUUID as randomUUID4 } from "node:crypto";
+import { randomUUID as randomUUID5 } from "node:crypto";
 
 // src/session-auth.ts
 import { createHash, timingSafeEqual } from "node:crypto";
@@ -61114,8 +61114,32 @@ function connectErrorFromEvent(ev) {
   if (ev?.minVersion) err.minVersion = ev.minVersion;
   return err;
 }
+function terminalConnectionCode(ev) {
+  if (ev.code) return [
+    "auth",
+    "auth_failed",
+    "authentication_failed",
+    "invalid_token",
+    "ACP_AUTH_FAILED",
+    "upgrade_required",
+    "taken_over",
+    "superseded"
+  ].includes(ev.code) ? ev.code : null;
+  return /^(?:authentication failed|invalid or expired (?:Jefri Chat )?token)(?:\b|$)/i.test(ev.message ?? "") ? "auth" : null;
+}
 var JefriClient = class _JefriClient {
   ws;
+  recoveryEnabled = false;
+  registeredSocket;
+  retireRecoverySocket;
+  recoveryRegisterTimer;
+  get registeredRecoveryEnabled() {
+    return this.recoveryEnabled;
+  }
+  get connectionStatus() {
+    if (this.terminalCode || this.closing) return "stopped";
+    return this.online ? "online" : this.hasConnected ? "reconnecting" : "connecting";
+  }
   handlers = /* @__PURE__ */ new Map();
   /** Why the client stopped reconnecting: "auth" | "upgrade_required" | "taken_over". */
   terminalCode = null;
@@ -61143,6 +61167,14 @@ var JefriClient = class _JefriClient {
    *  so pre-0.49 SDKs stop via their /auth/i match. */
   noteTerminalError(ev) {
     if (ev?.event !== "error") return;
+    if (this.recoveryEnabled) {
+      const code3 = terminalConnectionCode(ev);
+      if (code3) {
+        this.authFailed = true;
+        this.terminalCode = code3;
+      }
+      return;
+    }
     if (/auth/i.test(ev.message ?? "") || ev.code === "upgrade_required" || ev.code === "taken_over" || ev.code === "superseded") {
       this.authFailed = true;
       this.terminalCode = ev.code ?? "auth";
@@ -61238,6 +61270,8 @@ var JefriClient = class _JefriClient {
    *  "offline" honestly instead of claiming an agent can be reached and then
    *  failing on send. */
   get online() {
+    if (this.recoveryEnabled)
+      return !this.closing && !this.authFailed && !!this.ws && this.ws.readyState === wrapper_default.OPEN && this.registeredSocket === this.ws;
     return this.hasConnected && !this.closing && this.ws?.readyState === this.ws?.OPEN;
   }
   constructor(server2) {
@@ -61246,6 +61280,7 @@ var JefriClient = class _JefriClient {
   static async connect(opts = {}) {
     const server2 = (opts.server ?? "https://jefrichat.com").replace(/\/$/, "");
     const client = new _JefriClient(server2);
+    client.recoveryEnabled = opts.registeredRecovery === true;
     let token = opts.token;
     if (!token) {
       const res = await fetch(`${server2}/api/agents`, {
@@ -61285,7 +61320,9 @@ var JefriClient = class _JefriClient {
         fn();
       };
       onReg = () => finish(resolve);
-      onErr = (ev) => finish(() => reject(connectErrorFromEvent(ev)));
+      onErr = (ev) => finish(() => reject(
+        client.recoveryEnabled && !ev?.code && !terminalConnectionCode(ev) ? new Error(ev?.message ?? "hub rejected the connection") : connectErrorFromEvent(ev)
+      ));
       const regTimeoutMs = typeof process !== "undefined" && Number(process.env?.JEFRI_REGISTER_TIMEOUT_MS) || 8e3;
       timer = setTimeout(
         () => finish(() => reject(new Error("timed out waiting for the hub to register the connection"))),
@@ -61312,11 +61349,47 @@ var JefriClient = class _JefriClient {
     return client;
   }
   openSocket() {
+    if (this.recoveryEnabled) {
+      this.retireRecoverySocket?.();
+      this.registeredSocket = void 0;
+    }
     const wsUrl = this.server.replace(/^http/, "ws") + `/ws`;
     this.ws = new wrapper_default(wsUrl, { headers: this.socketHeaders() });
+    const ws = this.ws;
+    const current = () => !this.recoveryEnabled || this.ws === ws && !this.closing && !this.authFailed;
     return new Promise((resolve, reject) => {
       let settled = false;
+      let registrationTimer;
+      const clearRegistrationTimer = () => {
+        clearTimeout(registrationTimer);
+        if (this.recoveryRegisterTimer === registrationTimer) this.recoveryRegisterTimer = void 0;
+        registrationTimer = void 0;
+      };
+      if (this.recoveryEnabled) {
+        const timeoutMs = Number(process.env.JEFRI_REGISTER_TIMEOUT_MS) || 8e3;
+        registrationTimer = setTimeout(() => {
+          if (!current() || this.registeredSocket === ws) return;
+          if (!settled) {
+            settled = true;
+            reject(new Error("timed out waiting for the hub to register the connection"));
+          }
+          ws.terminate();
+        }, timeoutMs);
+        this.recoveryRegisterTimer = registrationTimer;
+        this.retireRecoverySocket = () => {
+          clearRegistrationTimer();
+          if (!settled) {
+            settled = true;
+            reject(new Error("connection attempt cancelled"));
+          }
+          ws.removeAllListeners();
+          ws.on("error", () => {
+          });
+          ws.terminate();
+        };
+      }
       this.ws.on("open", () => {
+        if (!current()) return;
         this.startPing();
         this.emit("socket_open", {});
         try {
@@ -61332,17 +61405,28 @@ var JefriClient = class _JefriClient {
         }
       });
       this.ws.on("error", (e) => {
+        if (this.recoveryEnabled && this.ws !== ws) return;
         if (!settled) {
           settled = true;
           reject(e);
         }
       });
       this.ws.on("close", () => {
+        if (this.recoveryEnabled) {
+          clearRegistrationTimer();
+          if (this.ws !== ws) return;
+          this.registeredSocket = void 0;
+          if (!settled) {
+            settled = true;
+            reject(new Error("connection closed before opening"));
+          }
+        }
         this.stopPing();
         this.emit("socket_close", {});
         if (this.hasConnected && !this.closing && !this.authFailed) this.scheduleReconnect();
       });
       this.ws.on("message", (data) => {
+        if (!current()) return;
         let ev;
         try {
           ev = JSON.parse(data.toString());
@@ -61350,6 +61434,10 @@ var JefriClient = class _JefriClient {
           return;
         }
         if (ev.event === "registered") {
+          if (this.recoveryEnabled) {
+            this.registeredSocket = ws;
+            clearRegistrationTimer();
+          }
           this.identity = ev.identity;
           this.generation = typeof ev.generation === "string" ? ev.generation : null;
           const rev = ev.identity?.statusRev;
@@ -61358,6 +61446,14 @@ var JefriClient = class _JefriClient {
           this.reconnectAttempts = 0;
         }
         this.noteTerminalError(ev);
+        if (this.recoveryEnabled && this.authFailed) {
+          clearRegistrationTimer();
+          this.registeredSocket = void 0;
+          this.stopPing();
+          if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+          this.reconnectTimer = void 0;
+          ws.close();
+        }
         this.notePresenceAck(ev);
         this.emit(ev.event, ev);
         this.emit("*", ev);
@@ -61373,14 +61469,17 @@ var JefriClient = class _JefriClient {
   // triggers the existing reconnect.
   startPing() {
     this.stopPing();
+    const ws = this.ws;
+    const current = () => !this.recoveryEnabled || this.ws === ws && !this.closing && !this.authFailed;
     this.isAlive = true;
     try {
       this.ws.on("pong", () => {
-        this.isAlive = true;
+        if (current()) this.isAlive = true;
       });
     } catch {
     }
     this.pingTimer = setInterval(() => {
+      if (!current()) return;
       if (this.ws.readyState !== this.ws.OPEN) return;
       if (!this.isAlive) {
         try {
@@ -61470,6 +61569,12 @@ var JefriClient = class _JefriClient {
     this.dispatch(event, payload, this.handlers.get(event) ?? []);
   }
   send(ev) {
+    if (this.recoveryEnabled && !this.online) {
+      if (this.terminalCode)
+        throw new Error(`Jefri Chat connection stopped (${this.terminalCode}) \u2014 not reconnecting automatically; check this desktop session's connection`);
+      if (this.closing) throw new Error("Jefri Chat connection closed \u2014 restart this desktop connector");
+      throw new Error("Jefri Chat hub connection is not registered yet (reconnecting) \u2014 try again after registration");
+    }
     if (!this.ws || this.ws.readyState !== this.ws.OPEN)
       throw new Error("not connected to the Jefri Chat hub (reconnecting) \u2014 try again in a moment");
     this.ws.send(JSON.stringify(ev));
@@ -61625,6 +61730,11 @@ var JefriClient = class _JefriClient {
   }
   close() {
     this.closing = true;
+    if (this.recoveryEnabled) {
+      this.registeredSocket = void 0;
+      clearTimeout(this.recoveryRegisterTimer);
+      this.recoveryRegisterTimer = void 0;
+    }
     this.stopPing();
     if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
     this.reconnectTimer = void 0;
@@ -61908,6 +62018,55 @@ async function readCapped(stream, maxBytes, deadline) {
   return Buffer.concat(chunks);
 }
 
+// src/send-confirmed.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+var SEND_CONFIRM_TIMEOUT_MS = 8e3;
+function sendConfirmed(client, target, text5, opts = {}) {
+  const clientId = opts.clientId ?? randomUUID3();
+  const timeoutMs = opts.timeoutMs ?? SEND_CONFIRM_TIMEOUT_MS;
+  return new Promise((resolve) => {
+    let settled = false;
+    const finish = (out) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      clearInterval(linkCheck);
+      client.off("reply_ack", onAck);
+      client.off("error", onErr);
+      resolve(out);
+    };
+    const onAck = (ev) => {
+      if (ev?.replyId !== clientId) return;
+      finish({ outcome: "sent", hubMessageId: String(ev.messageId ?? "") });
+    };
+    const onErr = (ev) => {
+      if (ev?.replyId !== clientId) return;
+      finish({
+        outcome: "rejected",
+        reason: String(ev.message ?? "the hub refused the message"),
+        ...typeof ev.code === "string" ? { code: ev.code } : {},
+        ...typeof ev.status === "number" ? { status: ev.status } : {}
+      });
+    };
+    const timer = setTimeout(
+      () => finish({ outcome: "ambiguous", reason: `no answer from the hub within ${Math.round(timeoutMs / 1e3)}s \u2014 check history before retrying` }),
+      timeoutMs
+    );
+    const linkCheck = setInterval(() => {
+      if (client.online === false) finish({ outcome: "ambiguous", reason: "the hub connection dropped before it answered \u2014 check history before retrying" });
+    }, 250);
+    client.on("reply_ack", onAck);
+    client.on("error", onErr);
+    try {
+      if (target.groupId) client.groupMessage(target.groupId, text5, { clientId });
+      else if (target.to) client.message(target.to, text5, { clientId });
+      else return finish({ outcome: "rejected", reason: "need `to` or `groupId`" });
+    } catch (e) {
+      finish({ outcome: "rejected", reason: e?.message ?? "send failed" });
+    }
+  });
+}
+
 // src/hosts.ts
 function aggregateFreshHosts(sessions2, poolKey, now, freshMs) {
   const hosts = /* @__PURE__ */ new Set();
@@ -62491,7 +62650,7 @@ function withConfigMutex(path3, fn) {
 }
 
 // src/run-reporter.ts
-import { randomUUID as randomUUID3 } from "node:crypto";
+import { randomUUID as randomUUID4 } from "node:crypto";
 import np6 from "node:path";
 var RUN_HEARTBEAT_MS = 3e4;
 var safeUser = (u) => (u || "unknown").replace(/[^a-zA-Z0-9_.-]/g, "_");
@@ -62505,7 +62664,7 @@ var RunReporter = class {
     this.replyDeadlineMs = deps.replyDeadlineMs ?? REPLY_DEADLINE_MS;
   }
   deps;
-  sessionId = randomUUID3();
+  sessionId = randomUUID4();
   runs = /* @__PURE__ */ new Map();
   replies = /* @__PURE__ */ new Map();
   /** Unacknowledged run frames, keyed `${runId}:${seq}`, in send order. */
@@ -62666,7 +62825,7 @@ var RunReporter = class {
   /** Mint the id and journal the run BEFORE the caller spawns anything. */
   startRun(meta) {
     if (!this.started) throw new Error("run reporter not started \u2014 the session marker must be established before any autonomous work");
-    const runId = randomUUID3();
+    const runId = randomUUID4();
     const startedAt = this.now();
     const st = { runId, seq: 0, meta, startedAt, epoch: this.deps.workEpoch(), durable: true, ended: false };
     const seq = this.nextSeq(st);
@@ -62752,7 +62911,7 @@ var RunReporter = class {
    *  finalization verdict, or the cancel path. `onSettled` fires exactly once. */
   queueReply(runId, target, text5, onSettled) {
     if (!this.started) throw new Error("run reporter not started");
-    const replyId = randomUUID3();
+    const replyId = randomUUID4();
     const createdAt = this.now();
     const epoch = this.deps.workEpoch();
     const groupGen = target.groupId ? this.deps.groupGenOf?.(target.groupId) : void 0;
@@ -64592,12 +64751,16 @@ async function uploadFileHttp(c, serverUrl, target, fileName, mime, bytes, capti
   if (caption) params.set("caption", caption);
   const headers = { Authorization: `Bearer ${c.token}`, "Content-Type": mime };
   if (idem2) headers["idempotency-key"] = idem2;
+  const desktop = !isStateless(c) && c.registeredRecoveryEnabled;
   let res;
   try {
     res = await fetch(`${hub}/api/files?${params.toString()}`, {
       method: "POST",
       headers,
-      body: Buffer.from(bytes)
+      body: Buffer.from(bytes),
+      // Same payload-scaled allowance as the SDK upload path. This covers the
+      // response body too; a silent hub must not hang this Desktop tool forever.
+      ...desktop ? { signal: AbortSignal.timeout(Math.ceil(3e4 + bytes.length / 20)) } : {}
     });
   } catch (e) {
     const err = new Error(`upload failed: ${e?.message ?? e}`);
@@ -64610,6 +64773,10 @@ async function uploadFileHttp(c, serverUrl, target, fileName, mime, bytes, capti
     if (res.status >= 500) err.jefriAmbiguous = true;
     throw err;
   }
+  if (desktop) {
+    const receipt = await res.json().catch(() => null);
+    if (receipt?.ok !== true) throw new Error("upload response did not confirm delivery");
+  }
 }
 var shq = (s) => `'${String(s).replace(/'/g, "'\\''")}'`;
 var CAP = {
@@ -65138,9 +65305,12 @@ ${e?.message ?? e}`);
     async () => {
       const unbound = await ctx.identityStatus?.();
       if (unbound) return ok3(unbound);
-      return withClient(
-        async (c) => ok3(`You are "${c.identity.displayName}" (@${safeHandle(c.identity.username)}) on Jefri Chat at ${ctx.serverUrl}, status: online.`)
-      );
+      return withClient(async (c) => {
+        const desktop = !isStateless(c) && c.registeredRecoveryEnabled;
+        const status = desktop ? c.connectionStatus : "online";
+        const reason = desktop && c.terminalCode ? ` Connection stopped: ${c.terminalCode}; automatic reconnection is disabled.` : "";
+        return ok3(`You are "${c.identity.displayName}" (@${safeHandle(c.identity.username)}) on Jefri Chat at ${ctx.serverUrl}, status: ${status}.${reason}`);
+      });
     }
   );
   server2.registerTool(
@@ -65283,6 +65453,12 @@ Use jefri_agent_apps with agent=<name> to see its live app + active state.`,
           return failAmbiguous(`Message send failed: ${e?.message ?? e}.`);
         }
       }
+      if (c.registeredRecoveryEnabled) {
+        const sent = await sendConfirmed(c, { to }, text5);
+        if (sent.outcome === "rejected") return fail(`Message rejected: ${sent.reason}`);
+        if (sent.outcome === "ambiguous") return failAmbiguous(sent.reason);
+        return ok3(`Sent to @${safeHandle(to)}: "${text5}"`);
+      }
       const r = await confirmWrite(c, () => c.message(to, text5));
       if (r.error) return fail(`Message rejected: ${r.error}`);
       return ok3(`Sent to @${safeHandle(to)}: "${text5}"`);
@@ -65664,7 +65840,7 @@ ${lines.join("\n")}`
         return ok3(`Sent \u{1F4CE} ${name} (${MB(rawBytes.length)} MB) to @${safeHandle(to)}${caption ? ` \u2014 "${caption}"` : ""}`);
       }
       const fileIdem = retryKey(extra, fileSendIdemParts(to, { path: path3, fileUrl, fileName }, name));
-      if (rawBytes.length > WS_SAFE_FILE_BYTES || fileIdem) {
+      if (c.registeredRecoveryEnabled || rawBytes.length > WS_SAFE_FILE_BYTES || fileIdem) {
         try {
           await uploadFileHttp(c, ctx.serverUrl, { to }, name, mime, rawBytes, caption, fileIdem);
         } catch (e2) {
@@ -65715,7 +65891,7 @@ ${lines.join("\n")}`
         return ok3(`Sent \u{1F4C4} ${fileName} (${MB(contentBytes.length)} MB) to @${safeHandle(to)}${caption ? ` \u2014 "${caption}"` : ""}`);
       }
       const textIdem = retryKey(extra, ["file", to, fileName, createHash2("sha256").update(contentBytes).digest("hex")]);
-      if (contentBytes.length > WS_SAFE_FILE_BYTES || textIdem) {
+      if (c.registeredRecoveryEnabled || contentBytes.length > WS_SAFE_FILE_BYTES || textIdem) {
         try {
           await uploadFileHttp(c, ctx.serverUrl, { to }, fileName, mime, contentBytes, caption, textIdem);
         } catch (e2) {
@@ -66414,6 +66590,12 @@ Or just upload ${fname} from the agent's page in the web app.`
           return failAmbiguous(`Group post failed: ${e?.message ?? e}.`);
         }
       }
+      if (c.registeredRecoveryEnabled) {
+        const sent = await sendConfirmed(c, { groupId }, text5);
+        if (sent.outcome === "rejected") return fail(`Couldn't post to the group: ${sent.reason}`);
+        if (sent.outcome === "ambiguous") return failAmbiguous(sent.reason);
+        return ok3("Posted to the group.");
+      }
       const r = await confirmWrite(c, () => c.groupMessage(groupId, text5));
       if (r.error) return fail(`Couldn't post to the group: ${r.error}`);
       return ok3(`Posted to the group.`);
@@ -66485,7 +66667,7 @@ Or just upload ${fname} from the agent's page in the web app.`
         return ok3(`Sent \u{1F4CE} ${name} (${MB(rawBytes.length)} MB) to the group.`);
       }
       const fileIdem = retryKey(extra, fileSendIdemParts(groupId, { path: path3, fileUrl, fileName }, name));
-      if (rawBytes.length > WS_SAFE_FILE_BYTES || fileIdem) {
+      if (c.registeredRecoveryEnabled || rawBytes.length > WS_SAFE_FILE_BYTES || fileIdem) {
         try {
           await uploadFileHttp(c, ctx.serverUrl, { groupId }, name, mime, rawBytes, caption, fileIdem);
         } catch (e2) {
@@ -67690,7 +67872,7 @@ var statefulPost = async (req, res) => {
       }
     };
     const transport = new StreamableHTTPServerTransport({
-      sessionIdGenerator: () => randomUUID4(),
+      sessionIdGenerator: () => randomUUID5(),
       onsessioninitialized: (sid) => {
         if (pooled.closed) {
           try {
@@ -67734,7 +67916,7 @@ var statefulPost = async (req, res) => {
       const sid = transport.sessionId;
       if (sid) closeSession(sid, "client closed");
     };
-    const reservation = "init:" + randomUUID4();
+    const reservation = "init:" + randomUUID5();
     pooled.refs.add(reservation);
     try {
       await mcp.connect(transport);