jefrichat-mcp 0.48.8 → 0.48.10

package/dist/http.js

@@ -98,7 +98,7 @@ var require_depd = __commonJS({
       var site = callSiteLocation(stack[1]);
       var file = site[0];
       function deprecate(message) {
-        log2.call(deprecate, message);
+        log3.call(deprecate, message);
       }
       deprecate._file = file;
       deprecate._ignored = isignored(namespace);
@@ -127,7 +127,7 @@ var require_depd = __commonJS({
       var str = process.env.TRACE_DEPRECATION || "";
       return containsNamespace(str, namespace);
     }
-    function log2(message, site) {
+    function log3(message, site) {
       var haslisteners = eehaslisteners(process, "deprecation");
       if (!haslisteners && this._ignored) {
         return;
@@ -267,7 +267,7 @@ var require_depd = __commonJS({
         "message",
         "site",
         '"use strict"\nreturn function (' + args + ") {log.call(deprecate, message, site)\nreturn fn.apply(this, arguments)\n}"
-      )(fn, log2, this, message, site);
+      )(fn, log3, this, message, site);
       return deprecatedfn;
     }
     function wrapproperty(obj, prop, message) {
@@ -292,13 +292,13 @@ var require_depd = __commonJS({
       var set = descriptor.set;
       if (typeof get === "function") {
         descriptor.get = function getter() {
-          log2.call(deprecate, message, site);
+          log3.call(deprecate, message, site);
           return get.apply(this, arguments);
         };
       }
       if (typeof set === "function") {
         descriptor.set = function setter() {
-          log2.call(deprecate, message, site);
+          log3.call(deprecate, message, site);
           return set.apply(this, arguments);
         };
       }
@@ -1135,7 +1135,7 @@ var require_debug = __commonJS({
 var require_browser = __commonJS({
   "../../node_modules/.pnpm/debug@2.6.9/node_modules/debug/src/browser.js"(exports, module) {
     exports = module.exports = require_debug();
-    exports.log = log2;
+    exports.log = log3;
     exports.formatArgs = formatArgs;
     exports.save = save;
     exports.load = load;
@@ -1183,7 +1183,7 @@ var require_browser = __commonJS({
       });
       args.splice(lastC, 0, c);
     }
-    function log2() {
+    function log3() {
       return "object" === typeof console && console.log && Function.prototype.apply.call(console.log, console, arguments);
     }
     function save(namespaces) {
@@ -1224,7 +1224,7 @@ var require_node = __commonJS({
     var util2 = __require("util");
     exports = module.exports = require_debug();
     exports.init = init;
-    exports.log = log2;
+    exports.log = log3;
     exports.formatArgs = formatArgs;
     exports.save = save;
     exports.load = load;
@@ -1275,7 +1275,7 @@ var require_node = __commonJS({
         args[0] = (/* @__PURE__ */ new Date()).toUTCString() + " " + name + " " + args[0];
       }
     }
-    function log2() {
+    function log3() {
       return stream.write(util2.format.apply(util2, arguments) + "\n");
     }
     function save(namespaces) {
@@ -27279,11 +27279,11 @@ var require_core = __commonJS({
     Ajv2.ValidationError = validation_error_1.default;
     Ajv2.MissingRefError = ref_error_1.default;
     exports.default = Ajv2;
-    function checkOptions(checkOpts, options, msg, log2 = "error") {
+    function checkOptions(checkOpts, options, msg, log3 = "error") {
       for (const key in checkOpts) {
         const opt = key;
         if (opt in options)
-          this.logger[log2](`${msg}: option ${key}. ${checkOpts[opt]}`);
+          this.logger[log3](`${msg}: option ${key}. ${checkOpts[opt]}`);
       }
     }
     function getSchEnv(keyRef) {
@@ -33549,7 +33549,7 @@ for (const [k, v] of snapshot) {
 
 // src/http.ts
 import http from "node:http";
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 
 // src/session-auth.ts
 import { createHash, timingSafeEqual } from "node:crypto";
@@ -49051,7 +49051,7 @@ var wrapper_default = import_websocket.default;
 import fs from "node:fs";
 import os from "node:os";
 import path2 from "node:path";
-import { webcrypto } from "node:crypto";
+import { webcrypto, randomUUID as randomUUID2 } from "node:crypto";
 
 // ../../node_modules/.pnpm/bail@2.0.2/node_modules/bail/index.js
 function bail(error2) {
@@ -60649,6 +60649,234 @@ function groupConversationId(groupId) {
   return "group:" + groupId;
 }
 
+// ../sdk/src/http-client.ts
+import { randomUUID } from "node:crypto";
+function idem(key) {
+  return { "idempotency-key": key || `sdk-${randomUUID()}` };
+}
+var JefriHttpError = class extends Error {
+  constructor(message, status, body) {
+    super(message);
+    this.status = status;
+    this.body = body;
+    this.name = "JefriHttpError";
+  }
+  status;
+  body;
+  /** The hub's machine-readable state field, when it sent one. */
+  get state() {
+    return this.body?.state;
+  }
+};
+var UnsupportedOverHttp = class extends Error {
+  constructor(what, why) {
+    super(`${what} is not available without a live connection \u2014 ${why}`);
+    this.name = "UnsupportedOverHttp";
+  }
+};
+var DEFAULT_TIMEOUT_MS = 3e4;
+var JefriHttpClient = class {
+  base;
+  /** Discriminant for callers that accept either client: `stateless` is true
+   *  here and absent on the socket client, so shared code can branch without
+   *  instanceof (which breaks across duplicated package instances). */
+  stateless = true;
+  /** PUBLIC, like JefriClient.token: the connector's HTTP upload/download
+   *  helpers authenticate raw fetches with it. */
+  token;
+  f;
+  timeoutMs;
+  /** Populated by whoami(); mirrors JefriClient.identity for callers that read it. */
+  identity = null;
+  constructor(opts) {
+    this.base = opts.server.replace(/\/+$/, "");
+    this.token = opts.token;
+    this.f = opts.fetchImpl ?? fetch;
+    const t = Number(opts.timeoutMs);
+    this.timeoutMs = Number.isFinite(t) && t > 0 ? t : DEFAULT_TIMEOUT_MS;
+  }
+  async call(method, path3, body, query, extraHeaders) {
+    const url = new URL(this.base + path3);
+    for (const [k, v] of Object.entries(query ?? {})) if (v !== void 0 && v !== "") url.searchParams.set(k, v);
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), this.timeoutMs);
+    let res;
+    try {
+      res = await this.f(url.toString(), {
+        method,
+        signal: ac.signal,
+        headers: {
+          authorization: `Bearer ${this.token}`,
+          ...body !== void 0 ? { "content-type": "application/json" } : {},
+          ...extraHeaders ?? {}
+        },
+        ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+      });
+    } catch (e) {
+      clearTimeout(timer);
+      if (e?.name === "AbortError") throw new Error(`${method} ${path3} timed out after ${this.timeoutMs}ms`);
+      throw e;
+    }
+    let text5;
+    try {
+      text5 = await res.text();
+    } catch (e) {
+      if (e?.name === "AbortError") throw new Error(`${method} ${path3} timed out after ${this.timeoutMs}ms reading the body`);
+      throw e;
+    } finally {
+      clearTimeout(timer);
+    }
+    let parsed = null;
+    try {
+      parsed = text5 ? JSON.parse(text5) : null;
+    } catch {
+    }
+    if (!res.ok) {
+      throw new JefriHttpError(parsed?.error ?? `${method} ${path3} failed with ${res.status}`, res.status, parsed);
+    }
+    return parsed;
+  }
+  // --- identity ------------------------------------------------------------
+  /** /api/me answers `{ identity, online }`, NOT a bare Identity — unwrapping is
+   *  the caller's job and getting it wrong is silent: every field reads as
+   *  undefined and the object still looks like an Identity. Caught by running
+   *  this against the real hub; a stubbed test would have returned whatever
+   *  shape the stub was written to expect. */
+  async whoami() {
+    const body = await this.call("GET", "/api/me");
+    const me = body?.identity ?? body;
+    if (!me?.username) throw new Error("unexpected /api/me response shape");
+    this.identity = me;
+    return me;
+  }
+  // --- reads ---------------------------------------------------------------
+  identities() {
+    return this.call("GET", "/api/identities");
+  }
+  groups() {
+    return this.call("GET", "/api/groups");
+  }
+  inbox(since) {
+    return this.call("GET", "/api/inbox", void 0, { since });
+  }
+  search(query) {
+    return this.call("GET", "/api/search", void 0, { q: query });
+  }
+  history(conversationId, before) {
+    return this.call("GET", "/api/history", void 0, { conversationId, before });
+  }
+  // --- writes --------------------------------------------------------------
+  /** Sends carry an idempotency key.
+   *
+   *  The hub persists the key in the SAME transaction as the message, so a retry
+   *  is exactly-once rather than at-least-once. This matters far more for a
+   *  stateless client than a socket one: a timed-out or connection-reset POST
+   *  gives no evidence of whether the send landed, and the natural response — retry
+   *  — is precisely what produces duplicates during a deployment.
+   *
+   *  Callers may pass their own key when a retry must reuse it; otherwise one is
+   *  minted per call. */
+  message(to, content3, idempotencyKey) {
+    return this.call("POST", "/api/messages", { to, content: content3 }, void 0, idem(idempotencyKey));
+  }
+  groupMessage(groupId, content3, idempotencyKey) {
+    return this.call("POST", "/api/messages", { groupId, content: content3 }, void 0, idem(idempotencyKey));
+  }
+  /** DECLARE a status — a user-level choice that hits every connection the
+   *  identity holds. The returned status is the SETTLED one, which may differ
+   *  from the request if another lease outvoted it. */
+  presence(status) {
+    return this.call("POST", "/api/presence", { status });
+  }
+  /** KEEPALIVE — "still here", declaring nothing. This is the call for a timer.
+   *  Heartbeating through presence("online") instead is a declaration on a
+   *  timer, and it silently undoes an appear-offline chosen elsewhere.
+   *
+   *  REJECTS (409, "signed off") when the identity has signed off: the beat was
+   *  refused and no lease exists, so the timer should STOP and the client must
+   *  declare a presence to resume. The refusal used to arrive as ok:true with a
+   *  full TTL — a lease lifetime that did not exist. */
+  async heartbeat() {
+    try {
+      return await this.call("POST", "/api/presence", { keepalive: true });
+    } catch (e) {
+      if (e instanceof JefriHttpError && e.status === 409 && e.state === "signedOff")
+        return { ok: false, state: "signedOff", status: String(e.body?.status ?? "offline"), expiresInMs: 0 };
+      throw e;
+    }
+  }
+  addFriend(to) {
+    return this.call("POST", "/api/friends/request", { to });
+  }
+  /** Upload and deliver a file. The hub's raw-body route takes the bytes
+   *  directly, so there is no base64 round-trip. */
+  async sendFile(target, fileName, mime, bytes, idempotencyKey) {
+    const url = new URL(this.base + "/api/files");
+    if (target.to) url.searchParams.set("to", target.to);
+    if (target.groupId) url.searchParams.set("groupId", target.groupId);
+    url.searchParams.set("fileName", fileName);
+    if (target.caption) url.searchParams.set("caption", target.caption);
+    const uploadTimeout = Math.max(this.timeoutMs, 3e4 + bytes.length / 20);
+    const ac = new AbortController();
+    const timer = setTimeout(() => ac.abort(), uploadTimeout);
+    let res;
+    try {
+      res = await this.f(url.toString(), {
+        method: "POST",
+        signal: ac.signal,
+        headers: {
+          authorization: `Bearer ${this.token}`,
+          "content-type": mime || "application/octet-stream",
+          ...idem(idempotencyKey)
+        },
+        body: bytes
+      });
+    } catch (e) {
+      clearTimeout(timer);
+      if (e?.name === "AbortError") throw new Error(`file upload timed out after ${Math.round(uploadTimeout)}ms`);
+      throw e;
+    }
+    let text5;
+    try {
+      text5 = await res.text();
+    } catch (e) {
+      if (e?.name === "AbortError") throw new Error(`file upload timed out after ${Math.round(uploadTimeout)}ms reading the response`);
+      throw e;
+    } finally {
+      clearTimeout(timer);
+    }
+    if (!res.ok) {
+      let msg = `upload failed with ${res.status}`;
+      try {
+        msg = JSON.parse(text5)?.error ?? msg;
+      } catch {
+      }
+      throw new Error(msg);
+    }
+    return text5 ? JSON.parse(text5) : null;
+  }
+  // --- deliberately unsupported -------------------------------------------
+  /** Realtime delivery needs a socket. A stateless caller polls /api/inbox. */
+  on() {
+    throw new UnsupportedOverHttp("Realtime events", "this client holds no socket; poll the inbox instead");
+  }
+  off() {
+    throw new UnsupportedOverHttp("Realtime events", "this client holds no socket; poll the inbox instead");
+  }
+  /** E2E sends are excluded until key custody is durable — see the file header.
+   *  Throwing names the reason so the next person does not "fix" it by wiring the
+   *  call through and shipping unreadable ciphertext. */
+  privateMessage() {
+    throw new UnsupportedOverHttp("End-to-end encrypted send", "private keys are not durably held; use the stateful connector");
+  }
+  privateGroupMessage() {
+    throw new UnsupportedOverHttp("End-to-end encrypted send", "private keys are not durably held; use the stateful connector");
+  }
+  /** Nothing to close — kept so callers can treat both clients alike. */
+  close() {
+  }
+};
+
 // ../sdk/src/index.ts
 var subtle = webcrypto.subtle;
 var enc = new TextEncoder();
@@ -60659,6 +60887,9 @@ var b64 = (bytes) => Buffer.from(bytes instanceof Uint8Array ? bytes : new Uint8
 var fromB64 = (s) => new Uint8Array(Buffer.from(s, "base64"));
 var safeName = (s) => s.replace(/[^a-zA-Z0-9_.-]/g, "_");
 var canonicalJwk = (jwk) => JSON.stringify({ crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk.y });
+function newDeclId() {
+  return "d-" + randomUUID2();
+}
 var JefriAuthError = class extends Error {
   code = "ACP_AUTH_FAILED";
   constructor(message = "invalid or expired Jefri Chat token") {
@@ -60682,8 +60913,52 @@ var JefriClient = class _JefriClient {
   // heartbeat: did we get a pong since the last ping?
   hasConnected = false;
   // armed for auto-reconnect only after the hub `registered` us
-  lastPresence = "online";
-  // re-announce this on reconnect
+  /** UNACKNOWLEDGED presence intent, or null. Set by presence(), cleared when
+   *  the hub's own presence_update for this identity confirms the declaration
+   *  landed. Null on reconnect means: send nothing and let the hub's persisted
+   *  answer stand.
+   *
+   *  Acknowledgment is the point, and it is what the first fix missed: a value
+   *  kept after delivery means "ever declared", not "pending" — so a client
+   *  that once declared away kept re-asserting it on every reconnect for the
+   *  life of the process, stomping whatever a newer device had chosen since.
+   *  The same stale-overwrite, one level down. */
+  pendingPresence = null;
+  /** The id minted for the pending declaration. Its ECHO on a presence_update
+   *  is the only genuine acknowledgment — see notePresenceAck. */
+  pendingDeclId = null;
+  /** The self statusRev BASELINE captured when the pending declaration was made.
+   *  An ack must be CAUSALLY newer than this — the audit reproduced a delayed
+   *  rev-9 event spending intent declared at a rev-10 baseline, after which the
+   *  server had already moved on. Identity + status matching alone cannot order
+   *  events; the revision can. */
+  pendingBaselineRev = 0;
+  /** Highest revision seen for our own status, from registered and from our own
+   *  presence_update events. */
+  selfStatusRev = 0;
+  /** Would a reconnect re-send a presence frame? True only while a declaration
+   *  is UNACKNOWLEDGED. Exposed for tests: the wire behaviour needs a live hub,
+   *  but the rule is checkable without one. */
+  wouldReassertPresence() {
+    return this.pendingPresence !== null;
+  }
+  /** The acknowledgment that turns "pending" back into nothing: the hub
+   *  broadcasts presence_update to the declaring identity too, so our own
+   *  username carrying our pending status means the declaration LANDED — and
+   *  re-asserting it on a later reconnect would stomp whatever a newer device
+   *  declares afterwards. A METHOD, not inline in the socket handler, so tests
+   *  drive the rule production runs instead of a copy of it — a test-local
+   *  re-implementation of this exact logic passed with the real clearing
+   *  deleted, which is how the previous round's test enshrined the bug. */
+  notePresenceAck(ev) {
+    if (ev?.event !== "presence_update" || ev.username !== this.identity?.username) return;
+    if (typeof ev.rev === "number" && ev.rev > this.selfStatusRev) this.selfStatusRev = ev.rev;
+    if (this.pendingPresence === null) return;
+    if (this.pendingDeclId !== null && ev.declId === this.pendingDeclId) {
+      this.pendingPresence = null;
+      this.pendingDeclId = null;
+    }
+  }
   clientInfo;
   // handshake, re-sent on reconnect
   /** Is the hub socket usable RIGHT NOW?
@@ -60778,7 +61053,8 @@ var JefriClient = class _JefriClient {
       this.ws.on("open", () => {
         this.startPing();
         try {
-          this.ws.send(JSON.stringify({ type: "presence", status: this.lastPresence }));
+          if (this.pendingPresence !== null)
+            this.ws.send(JSON.stringify({ type: "presence", status: this.pendingPresence, declId: this.pendingDeclId ?? void 0 }));
           if (this.clientInfo)
             this.ws.send(JSON.stringify({ type: "client_info", ...this.clientInfo }));
         } catch {
@@ -60807,12 +61083,15 @@ var JefriClient = class _JefriClient {
         }
         if (ev.event === "registered") {
           this.identity = ev.identity;
+          const rev = ev.identity?.statusRev;
+          if (typeof rev === "number" && rev > this.selfStatusRev) this.selfStatusRev = rev;
           this.hasConnected = true;
           this.reconnectAttempts = 0;
         }
         if (ev.event === "error" && /auth/i.test(ev.message ?? "")) {
           this.authFailed = true;
         }
+        this.notePresenceAck(ev);
         this.emit(ev.event, ev);
         this.emit("*", ev);
       });
@@ -60901,8 +61180,10 @@ var JefriClient = class _JefriClient {
   }
   // --- actions -------------------------------------------------------------
   presence(status) {
-    this.lastPresence = status;
-    this.send({ type: "presence", status });
+    this.pendingPresence = status;
+    this.pendingBaselineRev = this.selfStatusRev;
+    this.pendingDeclId = newDeclId();
+    this.send({ type: "presence", status, declId: this.pendingDeclId });
   }
   message(to, content3) {
     this.send({ type: "message", to, content: content3 });
@@ -61232,6 +61513,29 @@ var JefriClient = class _JefriClient {
 };
 var serveDir = path2.join(os.homedir(), ".acp", "serve");
 
+// src/stateless-presence.ts
+var log = (...a) => console.error("[jefrichat-mcp-http]", ...a);
+async function statelessPresenceBringUp(acp) {
+  try {
+    const hb = await acp.heartbeat();
+    if (hb.state === "signedOff") await acp.presence("online");
+  } catch (e) {
+    log("stateless presence bring-up failed (will retry on sweep):", e?.message ?? e);
+  }
+}
+async function statelessSweepBeat(acp, pool, onAuthRevoked) {
+  if (pool.closed || pool.hbSignedOff) return;
+  try {
+    const hb = await acp.heartbeat();
+    if (hb.state === "signedOff") pool.hbSignedOff = true;
+  } catch (e) {
+    if (e instanceof JefriHttpError && (e.status === 401 || e.status === 403)) {
+      onAuthRevoked();
+      return;
+    }
+  }
+}
+
 // src/conn-pool.ts
 function attachRef(c, id) {
   if (c.closed) return false;
@@ -61705,6 +62009,27 @@ var debateJobs = /* @__PURE__ */ new Map();
 var DEBATE_SEQ_TTL_MS = 10 * 60 * 1e3;
 
 // src/tools.ts
+var isStateless = (c) => c.stateless === true;
+async function confirmWrite(c, fire) {
+  if (isStateless(c)) {
+    try {
+      await fire();
+      return {};
+    } catch (e2) {
+      return { error: e2?.message ?? String(e2) };
+    }
+  }
+  const err = waitFor(c, "error", () => true, 800);
+  fire();
+  const e = await err;
+  return e ? { error: e.message } : {};
+}
+async function fetchHistory(c, convId) {
+  if (isStateless(c)) return c.history(convId);
+  const p = waitFor(c, "history", (e) => e.conversationId === convId, 4e3);
+  c.history(convId);
+  return p;
+}
 var MIME = {
   ".jpg": "image/jpeg",
   ".jpeg": "image/jpeg",
@@ -62040,7 +62365,7 @@ function saveWatermark() {
 }
 function registerAcpTools(server2, ctx) {
   const ENABLE_E2E = process.env.JEFRI_ENABLE_E2E === "true";
-  const e2eServer = ENABLE_E2E ? server2 : { registerTool: () => void 0 };
+  const e2eServer = ENABLE_E2E && !ctx.stateless ? server2 : { registerTool: () => void 0 };
   const withClient = async (fn) => {
     try {
       const c = await ctx.ensureClient();
@@ -62158,10 +62483,8 @@ Use jefri_agent_apps with agent=<name> to see its live app + active state.`);
       }
     },
     async ({ to, text: text5 }) => withClient(async (c) => {
-      const err = waitFor(c, "error", () => true, 800);
-      c.message(to, text5);
-      const e = await err;
-      if (e) return fail(`Message rejected: ${e.message}`);
+      const r = await confirmWrite(c, () => c.message(to, text5));
+      if (r.error) return fail(`Message rejected: ${r.error}`);
       return ok3(`Sent to @${to}: "${text5}"`);
     })
   );
@@ -62176,8 +62499,9 @@ Use jefri_agent_apps with agent=<name> to see its live app + active state.`);
       }
     },
     async ({ to, text: text5 }) => withClient(async (c) => {
-      const err = waitFor(c, "error", () => true, 800);
-      await c.privateMessage(to, text5);
+      const sc = c;
+      const err = waitFor(sc, "error", () => true, 800);
+      await sc.privateMessage(to, text5);
       const e = await err;
       if (e) return fail(`Private message rejected: ${e.message}`);
       return ok3(`Sent private E2E message to @${to}.`);
@@ -62234,8 +62558,9 @@ ${fp}`);
       } else {
         return fail("provide a local file `path` (or `dataUrl` + `fileName`)");
       }
-      await c.privateFile(to, name, mime, url);
-      if (caption) await c.privateMessage(to, caption);
+      const sc = c;
+      await sc.privateFile(to, name, mime, url);
+      if (caption) await sc.privateMessage(to, caption);
       return ok3(`Sent private E2E file to @${to}.`);
     })
   );
@@ -62250,8 +62575,9 @@ ${fp}`);
       }
     },
     async ({ groupId, text: text5 }) => withClient(async (c) => {
-      const err = waitFor(c, "error", () => true, 800);
-      await c.privateGroupMessage(groupId, text5);
+      const sc = c;
+      const err = waitFor(sc, "error", () => true, 800);
+      await sc.privateGroupMessage(groupId, text5);
       const e = await err;
       if (e) return fail(`Private group message rejected: ${e.message}`);
       return ok3(`Sent private E2E group message.`);
@@ -62366,9 +62692,9 @@ ${psCmd}
         return fail("provide a local file `path`, a `dataUrl` + `fileName`, or a public `fileUrl`");
       }
       const rawBytes = Buffer.from(url.split(",")[1] ?? "", "base64");
-      if (rawBytes.length > WS_SAFE_FILE_BYTES) {
-        if (rawBytes.length > MAX_UPLOAD_BYTES)
-          return fail(`${name} is ${MB(rawBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
+      if (rawBytes.length > MAX_UPLOAD_BYTES)
+        return fail(`${name} is ${MB(rawBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
+      if (isStateless(c) || rawBytes.length > WS_SAFE_FILE_BYTES) {
         try {
           await uploadFileHttp(c, ctx.serverUrl, { to }, name, mime, rawBytes, caption);
         } catch (e2) {
@@ -62400,9 +62726,9 @@ ${psCmd}
       const known = mimeOf(fileName);
       const mime = known === "application/octet-stream" ? "text/plain" : known;
       const contentBytes = Buffer.from(content3, "utf8");
-      if (contentBytes.length > WS_SAFE_FILE_BYTES) {
-        if (contentBytes.length > MAX_UPLOAD_BYTES)
-          return fail(`That content is ${MB(contentBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
+      if (contentBytes.length > MAX_UPLOAD_BYTES)
+        return fail(`That content is ${MB(contentBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
+      if (isStateless(c) || contentBytes.length > WS_SAFE_FILE_BYTES) {
         try {
           await uploadFileHttp(c, ctx.serverUrl, { to }, fileName, mime, contentBytes, caption);
         } catch (e2) {
@@ -62533,9 +62859,7 @@ ${psCmd}
       if (!from && !groupId) return fail("Give `from` (a username, for a DM) or `groupId` (for a group file).");
       const convId = groupId ? groupConversationId(groupId) : dmConversationId(c.identity.username, from);
       const where = groupId ? "this group" : `@${from}`;
-      const p = waitFor(c, "history", (e) => e.conversationId === convId, 4e3);
-      c.history(convId);
-      const res = await p;
+      const res = await fetchHistory(c, convId);
       const files = (res?.messages ?? []).filter((m) => m.kind === "file");
       if (!files.length) return fail(`No files in ${where} yet.`);
       const match = fileName ? [...files].reverse().find((m) => m.fileName === fileName || m.fileName?.includes(fileName)) : files[files.length - 1];
@@ -62572,10 +62896,8 @@ It downloads the file to your machine (current folder unless you set a path). Fi
       inputSchema: { to: external_exports.string().describe("username to connect with") }
     },
     async ({ to }) => withClient(async (c) => {
-      const err = waitFor(c, "error", () => true, 800);
-      c.addFriend(to);
-      const e = await err;
-      if (e) return fail(`Request rejected: ${e.message}`);
+      const r = await confirmWrite(c, () => c.addFriend(to));
+      if (r.error) return fail(`Request rejected: ${r.error}`);
       return ok3(`\u{1F91D} Connection request sent to @${to}. They (or their owner) must approve before you can message.`);
     })
   );
@@ -62871,10 +63193,8 @@ Or just upload ${fname} from the agent's page in the web app.`
       }
     },
     async ({ groupId, text: text5 }) => withClient(async (c) => {
-      const err = waitFor(c, "error", () => true, 800);
-      c.groupMessage(groupId, text5);
-      const e = await err;
-      if (e) return fail(`Couldn't post to the group: ${e.message}`);
+      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.`);
     })
   );
@@ -62934,9 +63254,9 @@ Or just upload ${fname} from the agent's page in the web app.`
         return fail("provide a local file `path`, a `dataUrl` + `fileName`, or a public `fileUrl`");
       }
       const rawBytes = Buffer.from(url.split(",")[1] ?? "", "base64");
-      if (rawBytes.length > WS_SAFE_FILE_BYTES) {
-        if (rawBytes.length > MAX_UPLOAD_BYTES)
-          return fail(`${name} is ${MB(rawBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
+      if (rawBytes.length > MAX_UPLOAD_BYTES)
+        return fail(`${name} is ${MB(rawBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
+      if (isStateless(c) || rawBytes.length > WS_SAFE_FILE_BYTES) {
         try {
           await uploadFileHttp(c, ctx.serverUrl, { groupId }, name, mime, rawBytes, caption);
         } catch (e2) {
@@ -62967,9 +63287,7 @@ Or just upload ${fname} from the agent's page in the web app.`
       if (!other && !groupId) return fail("Give `with` (a username, for a DM) or `groupId` (for a group).");
       const convId = groupId ? groupConversationId(groupId) : dmConversationId(c.identity.username, other);
       const label = groupId ? "this group" : `@${other}`;
-      const p = waitFor(c, "history", (e) => e.conversationId === convId);
-      c.history(convId);
-      const res = await p;
+      const res = await fetchHistory(c, convId);
       const msgs = (res?.messages ?? []).slice(-(limit ?? 20));
       if (!msgs.length) return ok3(`No messages yet in ${label}.`);
       const lines = await Promise.all(msgs.map(async (m) => {
@@ -63000,10 +63318,14 @@ Or just upload ${fname} from the agent's page in the web app.`
       inputSchema: { query: external_exports.string() }
     },
     async ({ query }) => withClient(async (c) => {
-      const res = waitFor(c, "search_results", () => true);
-      c.search(query);
-      const e = await res;
-      const results = e?.results ?? [];
+      let results;
+      if (isStateless(c)) {
+        results = (await c.search(query))?.results ?? [];
+      } else {
+        const res = waitFor(c, "search_results", () => true);
+        c.search(query);
+        results = (await res)?.results ?? [];
+      }
       if (!results.length) return ok3(`No agents matched "${query}".`);
       return ok3(
         results.map((r) => `\u2022 @${r.username} \u2014 ${r.displayName} (${r.status})${r.owner ? ` \xB7 by @${r.owner}` : ""} \xB7 ${r.tags.join(", ")}`).join("\n")
@@ -63020,7 +63342,8 @@ Or just upload ${fname} from the agent's page in the web app.`
       }
     },
     async ({ status }) => withClient(async (c) => {
-      c.presence(status);
+      const r = await confirmWrite(c, () => c.presence(status));
+      if (r.error) return fail(`Couldn't set status: ${r.error}`);
       return ok3(`Status set to ${status}.`);
     })
   );
@@ -63212,7 +63535,8 @@ function sweepIdleSessions(map3) {
 // src/http.ts
 var HUB = process.env.JEFRI_SERVER ?? "http://localhost:4000";
 var PORT = Number(process.env.MCP_HTTP_PORT ?? 4001);
-var log = (...a) => console.error("[jefrichat-mcp-http]", ...a);
+var STATELESS = process.env.JEFRI_STATELESS === "true";
+var log2 = (...a) => console.error("[jefrichat-mcp-http]", ...a);
 var sessions = /* @__PURE__ */ new Map();
 var HOST_FRESH_MS = Number(process.env.MCP_HOST_FRESH_MS ?? 10 * 60 * 1e3);
 var hubPool = createKeyedPool();
@@ -63247,7 +63571,7 @@ function closeSession(sid, reason) {
     if (detachRef(pooled, sid)) teardownPool(s.poolKey, pooled, "last session gone");
     else if (s.host) announcePoolHosts(s.poolKey, pooled);
   }
-  log(`session ${sid.slice(0, 8)}\u2026 closed (${reason}) (${sessions.size} active)`);
+  log2(`session ${sid.slice(0, 8)}\u2026 closed (${reason}) (${sessions.size} active)`);
 }
 function teardownPool(poolKey, pooled, reason) {
   pooled.closed = true;
@@ -63256,9 +63580,10 @@ function teardownPool(poolKey, pooled, reason) {
     pooled.acp.close();
   } catch {
   }
-  log(`hub connection ${poolKey.slice(0, 8)}\u2026 closed (${reason})`);
+  log2(`hub connection ${poolKey.slice(0, 8)}\u2026 closed (${reason})`);
 }
 function announcePoolHosts(poolKey, pooled) {
+  if (STATELESS) return;
   const joined = aggregateFreshHosts(sessions.values(), poolKey, Date.now(), HOST_FRESH_MS);
   if (joined === pooled.lastHosts) return;
   pooled.lastHosts = joined;
@@ -63273,6 +63598,12 @@ function closePool(poolKey, reason) {
 }
 async function acquirePooledConn(token, poolKey) {
   return hubPool.acquire(poolKey, async () => {
+    if (STATELESS) {
+      const acp2 = new JefriHttpClient({ server: HUB, token });
+      await acp2.whoami();
+      await statelessPresenceBringUp(acp2);
+      return { acp: acp2, inbox: [], refs: /* @__PURE__ */ new Set(), closed: false };
+    }
     const acp = await JefriClient.connect({ server: HUB, token, status: "online" });
     const inbox = [];
     if (acp.identity) attachInbox(acp, inbox, acp.identity.username);
@@ -63299,7 +63630,10 @@ setInterval(() => {
     if (seenPools.has(s.poolKey)) continue;
     seenPools.add(s.poolKey);
     const pooled = hubPool.get(s.poolKey);
-    if (pooled) announcePoolHosts(s.poolKey, pooled);
+    if (!pooled) continue;
+    announcePoolHosts(s.poolKey, pooled);
+    if (STATELESS)
+      void statelessSweepBeat(pooled.acp, pooled, () => closePool(s.poolKey, "auth revoked"));
   }
   for (const [ip, e] of initHits) {
     if (now > e.resetAt) initHits.delete(ip);
@@ -63358,6 +63692,7 @@ var health = (_req, res) => res.status(draining ? 503 : 200).json({
   draining,
   service: "jefrichat-mcp-http",
   hub: HUB,
+  stateless: STATELESS,
   sessions: sessions.size
 });
 app.get("/health", health);
@@ -63397,6 +63732,14 @@ app.post("/mcp", async (req, res) => {
     }
     return;
   }
+  if (draining && !sessionId && isInitializeRequest(req.body)) {
+    res.setHeader("retry-after", "1");
+    return res.status(503).json({
+      jsonrpc: "2.0",
+      error: { code: -32e3, message: "server is shutting down \u2014 retry; another instance will accept this session" },
+      id: null
+    });
+  }
   if (!sessionId && isInitializeRequest(req.body)) {
     if (initRateLimited(req)) {
       res.status(429).json({
@@ -63420,7 +63763,7 @@ app.post("/mcp", async (req, res) => {
     try {
       pooled = await acquirePooledConn(token, poolKey);
     } catch (e) {
-      if (e instanceof JefriAuthError || e?.code === "ACP_AUTH_FAILED") {
+      if (e instanceof JefriAuthError || e?.code === "ACP_AUTH_FAILED" || e instanceof JefriHttpError && (e.status === 401 || e.status === 403)) {
         res.status(401).json({
           jsonrpc: "2.0",
           error: {
@@ -63434,6 +63777,10 @@ app.post("/mcp", async (req, res) => {
       res.status(502).json({ jsonrpc: "2.0", error: { code: -32002, message: `Hub unreachable: ${e?.message ?? e}` }, id: null });
       return;
     }
+    if (STATELESS && pooled.hbSignedOff) {
+      pooled.hbSignedOff = false;
+      void statelessPresenceBringUp(pooled.acp);
+    }
     const acp = pooled.acp;
     if (!acp.identity) {
       closePool(poolKey, "no identity");
@@ -63445,7 +63792,7 @@ app.post("/mcp", async (req, res) => {
       return;
     }
     const mcp = new McpServer({ name: "jefrichat", version: "0.1.0" });
-    registerAcpTools(mcp, { ensureClient: async () => acp, inbox: pooled.inbox, serverUrl: HUB, local: false });
+    registerAcpTools(mcp, { ensureClient: async () => acp, inbox: pooled.inbox, serverUrl: HUB, local: false, stateless: STATELESS });
     let mySid;
     mcp.server.oninitialized = () => {
       try {
@@ -63457,14 +63804,14 @@ app.post("/mcp", async (req, res) => {
       }
     };
     const transport = new StreamableHTTPServerTransport({
-      sessionIdGenerator: () => randomUUID(),
+      sessionIdGenerator: () => randomUUID3(),
       onsessioninitialized: (sid) => {
         if (pooled.closed) {
           try {
             transport.close?.();
           } catch {
           }
-          log(`session ${sid.slice(0, 8)}\u2026 refused (connection torn down during init)`);
+          log2(`session ${sid.slice(0, 8)}\u2026 refused (connection torn down during init)`);
           return;
         }
         const meName = acp.identity.username;
@@ -63489,19 +63836,19 @@ app.post("/mcp", async (req, res) => {
             transport.close?.();
           } catch {
           }
-          log(`session ${sid.slice(0, 8)}\u2026 refused (connection torn down during init)`);
+          log2(`session ${sid.slice(0, 8)}\u2026 refused (connection torn down during init)`);
           return;
         }
         sessions.set(sid, { transport, acp, lastActive: Date.now(), tokenHash: sha256(token), inflight: 0, poolKey });
         mySid = sid;
-        log(`session ${sid.slice(0, 8)}\u2026 open as @${acp.identity.username} (${sessions.size} active, ${pooled.refs.size} on this connection)`);
+        log2(`session ${sid.slice(0, 8)}\u2026 open as @${acp.identity.username} (${sessions.size} active, ${pooled.refs.size} on this connection)`);
       }
     });
     transport.onclose = () => {
       const sid = transport.sessionId;
       if (sid) closeSession(sid, "client closed");
     };
-    const reservation = "init:" + randomUUID();
+    const reservation = "init:" + randomUUID3();
     pooled.refs.add(reservation);
     try {
       await mcp.connect(transport);

package/dist/index.js

@@ -26890,7 +26890,7 @@ var wrapper_default = import_websocket.default;
 import fs from "node:fs";
 import os from "node:os";
 import path2 from "node:path";
-import { webcrypto } from "node:crypto";
+import { webcrypto, randomUUID } from "node:crypto";
 
 // ../../node_modules/.pnpm/bail@2.0.2/node_modules/bail/index.js
 function bail(error2) {
@@ -38625,6 +38625,9 @@ var b64 = (bytes) => Buffer.from(bytes instanceof Uint8Array ? bytes : new Uint8
 var fromB64 = (s) => new Uint8Array(Buffer.from(s, "base64"));
 var safeName = (s) => s.replace(/[^a-zA-Z0-9_.-]/g, "_");
 var canonicalJwk = (jwk) => JSON.stringify({ crv: jwk.crv, kty: jwk.kty, x: jwk.x, y: jwk.y });
+function newDeclId() {
+  return "d-" + randomUUID();
+}
 var JefriAuthError = class extends Error {
   code = "ACP_AUTH_FAILED";
   constructor(message = "invalid or expired Jefri Chat token") {
@@ -38648,8 +38651,52 @@ var JefriClient = class _JefriClient {
   // heartbeat: did we get a pong since the last ping?
   hasConnected = false;
   // armed for auto-reconnect only after the hub `registered` us
-  lastPresence = "online";
-  // re-announce this on reconnect
+  /** UNACKNOWLEDGED presence intent, or null. Set by presence(), cleared when
+   *  the hub's own presence_update for this identity confirms the declaration
+   *  landed. Null on reconnect means: send nothing and let the hub's persisted
+   *  answer stand.
+   *
+   *  Acknowledgment is the point, and it is what the first fix missed: a value
+   *  kept after delivery means "ever declared", not "pending" — so a client
+   *  that once declared away kept re-asserting it on every reconnect for the
+   *  life of the process, stomping whatever a newer device had chosen since.
+   *  The same stale-overwrite, one level down. */
+  pendingPresence = null;
+  /** The id minted for the pending declaration. Its ECHO on a presence_update
+   *  is the only genuine acknowledgment — see notePresenceAck. */
+  pendingDeclId = null;
+  /** The self statusRev BASELINE captured when the pending declaration was made.
+   *  An ack must be CAUSALLY newer than this — the audit reproduced a delayed
+   *  rev-9 event spending intent declared at a rev-10 baseline, after which the
+   *  server had already moved on. Identity + status matching alone cannot order
+   *  events; the revision can. */
+  pendingBaselineRev = 0;
+  /** Highest revision seen for our own status, from registered and from our own
+   *  presence_update events. */
+  selfStatusRev = 0;
+  /** Would a reconnect re-send a presence frame? True only while a declaration
+   *  is UNACKNOWLEDGED. Exposed for tests: the wire behaviour needs a live hub,
+   *  but the rule is checkable without one. */
+  wouldReassertPresence() {
+    return this.pendingPresence !== null;
+  }
+  /** The acknowledgment that turns "pending" back into nothing: the hub
+   *  broadcasts presence_update to the declaring identity too, so our own
+   *  username carrying our pending status means the declaration LANDED — and
+   *  re-asserting it on a later reconnect would stomp whatever a newer device
+   *  declares afterwards. A METHOD, not inline in the socket handler, so tests
+   *  drive the rule production runs instead of a copy of it — a test-local
+   *  re-implementation of this exact logic passed with the real clearing
+   *  deleted, which is how the previous round's test enshrined the bug. */
+  notePresenceAck(ev) {
+    if (ev?.event !== "presence_update" || ev.username !== this.identity?.username) return;
+    if (typeof ev.rev === "number" && ev.rev > this.selfStatusRev) this.selfStatusRev = ev.rev;
+    if (this.pendingPresence === null) return;
+    if (this.pendingDeclId !== null && ev.declId === this.pendingDeclId) {
+      this.pendingPresence = null;
+      this.pendingDeclId = null;
+    }
+  }
   clientInfo;
   // handshake, re-sent on reconnect
   /** Is the hub socket usable RIGHT NOW?
@@ -38744,7 +38791,8 @@ var JefriClient = class _JefriClient {
       this.ws.on("open", () => {
         this.startPing();
         try {
-          this.ws.send(JSON.stringify({ type: "presence", status: this.lastPresence }));
+          if (this.pendingPresence !== null)
+            this.ws.send(JSON.stringify({ type: "presence", status: this.pendingPresence, declId: this.pendingDeclId ?? void 0 }));
           if (this.clientInfo)
             this.ws.send(JSON.stringify({ type: "client_info", ...this.clientInfo }));
         } catch {
@@ -38773,12 +38821,15 @@ var JefriClient = class _JefriClient {
         }
         if (ev.event === "registered") {
           this.identity = ev.identity;
+          const rev = ev.identity?.statusRev;
+          if (typeof rev === "number" && rev > this.selfStatusRev) this.selfStatusRev = rev;
           this.hasConnected = true;
           this.reconnectAttempts = 0;
         }
         if (ev.event === "error" && /auth/i.test(ev.message ?? "")) {
           this.authFailed = true;
         }
+        this.notePresenceAck(ev);
         this.emit(ev.event, ev);
         this.emit("*", ev);
       });
@@ -38867,8 +38918,10 @@ var JefriClient = class _JefriClient {
   }
   // --- actions -------------------------------------------------------------
   presence(status) {
-    this.lastPresence = status;
-    this.send({ type: "presence", status });
+    this.pendingPresence = status;
+    this.pendingBaselineRev = this.selfStatusRev;
+    this.pendingDeclId = newDeclId();
+    this.send({ type: "presence", status, declId: this.pendingDeclId });
   }
   message(to, content3) {
     this.send({ type: "message", to, content: content3 });
@@ -40488,6 +40541,27 @@ async function runOnceForMessage(m) {
 }
 
 // src/tools.ts
+var isStateless = (c2) => c2.stateless === true;
+async function confirmWrite(c2, fire) {
+  if (isStateless(c2)) {
+    try {
+      await fire();
+      return {};
+    } catch (e2) {
+      return { error: e2?.message ?? String(e2) };
+    }
+  }
+  const err = waitFor(c2, "error", () => true, 800);
+  fire();
+  const e = await err;
+  return e ? { error: e.message } : {};
+}
+async function fetchHistory2(c2, convId) {
+  if (isStateless(c2)) return c2.history(convId);
+  const p = waitFor(c2, "history", (e) => e.conversationId === convId, 4e3);
+  c2.history(convId);
+  return p;
+}
 var MIME = {
   ".jpg": "image/jpeg",
   ".jpeg": "image/jpeg",
@@ -40826,7 +40900,7 @@ function saveWatermark() {
 }
 function registerAcpTools(server2, ctx) {
   const ENABLE_E2E = process.env.JEFRI_ENABLE_E2E === "true";
-  const e2eServer = ENABLE_E2E ? server2 : { registerTool: () => void 0 };
+  const e2eServer = ENABLE_E2E && !ctx.stateless ? server2 : { registerTool: () => void 0 };
   const withClient = async (fn) => {
     try {
       const c2 = await ctx.ensureClient();
@@ -40944,10 +41018,8 @@ Use jefri_agent_apps with agent=<name> to see its live app + active state.`);
       }
     },
     async ({ to, text: text5 }) => withClient(async (c2) => {
-      const err = waitFor(c2, "error", () => true, 800);
-      c2.message(to, text5);
-      const e = await err;
-      if (e) return fail(`Message rejected: ${e.message}`);
+      const r = await confirmWrite(c2, () => c2.message(to, text5));
+      if (r.error) return fail(`Message rejected: ${r.error}`);
       return ok3(`Sent to @${to}: "${text5}"`);
     })
   );
@@ -40962,8 +41034,9 @@ Use jefri_agent_apps with agent=<name> to see its live app + active state.`);
       }
     },
     async ({ to, text: text5 }) => withClient(async (c2) => {
-      const err = waitFor(c2, "error", () => true, 800);
-      await c2.privateMessage(to, text5);
+      const sc = c2;
+      const err = waitFor(sc, "error", () => true, 800);
+      await sc.privateMessage(to, text5);
       const e = await err;
       if (e) return fail(`Private message rejected: ${e.message}`);
       return ok3(`Sent private E2E message to @${to}.`);
@@ -41020,8 +41093,9 @@ ${fp}`);
       } else {
         return fail("provide a local file `path` (or `dataUrl` + `fileName`)");
       }
-      await c2.privateFile(to, name, mime, url);
-      if (caption) await c2.privateMessage(to, caption);
+      const sc = c2;
+      await sc.privateFile(to, name, mime, url);
+      if (caption) await sc.privateMessage(to, caption);
       return ok3(`Sent private E2E file to @${to}.`);
     })
   );
@@ -41036,8 +41110,9 @@ ${fp}`);
       }
     },
     async ({ groupId, text: text5 }) => withClient(async (c2) => {
-      const err = waitFor(c2, "error", () => true, 800);
-      await c2.privateGroupMessage(groupId, text5);
+      const sc = c2;
+      const err = waitFor(sc, "error", () => true, 800);
+      await sc.privateGroupMessage(groupId, text5);
       const e = await err;
       if (e) return fail(`Private group message rejected: ${e.message}`);
       return ok3(`Sent private E2E group message.`);
@@ -41152,9 +41227,9 @@ ${psCmd}
         return fail("provide a local file `path`, a `dataUrl` + `fileName`, or a public `fileUrl`");
       }
       const rawBytes = Buffer.from(url.split(",")[1] ?? "", "base64");
-      if (rawBytes.length > WS_SAFE_FILE_BYTES) {
-        if (rawBytes.length > MAX_UPLOAD_BYTES)
-          return fail(`${name} is ${MB(rawBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
+      if (rawBytes.length > MAX_UPLOAD_BYTES)
+        return fail(`${name} is ${MB(rawBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
+      if (isStateless(c2) || rawBytes.length > WS_SAFE_FILE_BYTES) {
         try {
           await uploadFileHttp(c2, ctx.serverUrl, { to }, name, mime, rawBytes, caption);
         } catch (e2) {
@@ -41186,9 +41261,9 @@ ${psCmd}
       const known = mimeOf(fileName);
       const mime = known === "application/octet-stream" ? "text/plain" : known;
       const contentBytes = Buffer.from(content3, "utf8");
-      if (contentBytes.length > WS_SAFE_FILE_BYTES) {
-        if (contentBytes.length > MAX_UPLOAD_BYTES)
-          return fail(`That content is ${MB(contentBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
+      if (contentBytes.length > MAX_UPLOAD_BYTES)
+        return fail(`That content is ${MB(contentBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
+      if (isStateless(c2) || contentBytes.length > WS_SAFE_FILE_BYTES) {
         try {
           await uploadFileHttp(c2, ctx.serverUrl, { to }, fileName, mime, contentBytes, caption);
         } catch (e2) {
@@ -41319,9 +41394,7 @@ ${psCmd}
       if (!from && !groupId) return fail("Give `from` (a username, for a DM) or `groupId` (for a group file).");
       const convId = groupId ? groupConversationId(groupId) : dmConversationId(c2.identity.username, from);
       const where = groupId ? "this group" : `@${from}`;
-      const p = waitFor(c2, "history", (e) => e.conversationId === convId, 4e3);
-      c2.history(convId);
-      const res = await p;
+      const res = await fetchHistory2(c2, convId);
       const files = (res?.messages ?? []).filter((m) => m.kind === "file");
       if (!files.length) return fail(`No files in ${where} yet.`);
       const match = fileName ? [...files].reverse().find((m) => m.fileName === fileName || m.fileName?.includes(fileName)) : files[files.length - 1];
@@ -41358,10 +41431,8 @@ It downloads the file to your machine (current folder unless you set a path). Fi
       inputSchema: { to: external_exports.string().describe("username to connect with") }
     },
     async ({ to }) => withClient(async (c2) => {
-      const err = waitFor(c2, "error", () => true, 800);
-      c2.addFriend(to);
-      const e = await err;
-      if (e) return fail(`Request rejected: ${e.message}`);
+      const r = await confirmWrite(c2, () => c2.addFriend(to));
+      if (r.error) return fail(`Request rejected: ${r.error}`);
       return ok3(`\u{1F91D} Connection request sent to @${to}. They (or their owner) must approve before you can message.`);
     })
   );
@@ -41657,10 +41728,8 @@ Or just upload ${fname} from the agent's page in the web app.`
       }
     },
     async ({ groupId, text: text5 }) => withClient(async (c2) => {
-      const err = waitFor(c2, "error", () => true, 800);
-      c2.groupMessage(groupId, text5);
-      const e = await err;
-      if (e) return fail(`Couldn't post to the group: ${e.message}`);
+      const r = await confirmWrite(c2, () => c2.groupMessage(groupId, text5));
+      if (r.error) return fail(`Couldn't post to the group: ${r.error}`);
       return ok3(`Posted to the group.`);
     })
   );
@@ -41720,9 +41789,9 @@ Or just upload ${fname} from the agent's page in the web app.`
         return fail("provide a local file `path`, a `dataUrl` + `fileName`, or a public `fileUrl`");
       }
       const rawBytes = Buffer.from(url.split(",")[1] ?? "", "base64");
-      if (rawBytes.length > WS_SAFE_FILE_BYTES) {
-        if (rawBytes.length > MAX_UPLOAD_BYTES)
-          return fail(`${name} is ${MB(rawBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
+      if (rawBytes.length > MAX_UPLOAD_BYTES)
+        return fail(`${name} is ${MB(rawBytes.length)} MB, over the ${Math.round(MAX_UPLOAD_BYTES / 1024 / 1024)} MB limit.`);
+      if (isStateless(c2) || rawBytes.length > WS_SAFE_FILE_BYTES) {
         try {
           await uploadFileHttp(c2, ctx.serverUrl, { groupId }, name, mime, rawBytes, caption);
         } catch (e2) {
@@ -41753,9 +41822,7 @@ Or just upload ${fname} from the agent's page in the web app.`
       if (!other && !groupId) return fail("Give `with` (a username, for a DM) or `groupId` (for a group).");
       const convId = groupId ? groupConversationId(groupId) : dmConversationId(c2.identity.username, other);
       const label = groupId ? "this group" : `@${other}`;
-      const p = waitFor(c2, "history", (e) => e.conversationId === convId);
-      c2.history(convId);
-      const res = await p;
+      const res = await fetchHistory2(c2, convId);
       const msgs = (res?.messages ?? []).slice(-(limit ?? 20));
       if (!msgs.length) return ok3(`No messages yet in ${label}.`);
       const lines = await Promise.all(msgs.map(async (m) => {
@@ -41786,10 +41853,14 @@ Or just upload ${fname} from the agent's page in the web app.`
       inputSchema: { query: external_exports.string() }
     },
     async ({ query }) => withClient(async (c2) => {
-      const res = waitFor(c2, "search_results", () => true);
-      c2.search(query);
-      const e = await res;
-      const results = e?.results ?? [];
+      let results;
+      if (isStateless(c2)) {
+        results = (await c2.search(query))?.results ?? [];
+      } else {
+        const res = waitFor(c2, "search_results", () => true);
+        c2.search(query);
+        results = (await res)?.results ?? [];
+      }
       if (!results.length) return ok3(`No agents matched "${query}".`);
       return ok3(
         results.map((r) => `\u2022 @${r.username} \u2014 ${r.displayName} (${r.status})${r.owner ? ` \xB7 by @${r.owner}` : ""} \xB7 ${r.tags.join(", ")}`).join("\n")
@@ -41806,7 +41877,8 @@ Or just upload ${fname} from the agent's page in the web app.`
       }
     },
     async ({ status }) => withClient(async (c2) => {
-      c2.presence(status);
+      const r = await confirmWrite(c2, () => c2.presence(status));
+      if (r.error) return fail(`Couldn't set status: ${r.error}`);
       return ok3(`Status set to ${status}.`);
     })
   );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jefrichat-mcp",
-  "version": "0.48.8",
+  "version": "0.48.10",
   "description": "Jefri Chat connector — join the Jefri Chat network (WhatsApp for AI agents) from any MCP client (Claude, Codex, Cursor, …).",
   "type": "module",
   "bin": {