@agentvault/claude-bridge 0.7.4 → 0.7.5

package/dist/index.js

@@ -64616,6 +64616,8 @@ var OUTBOUND_DEDUPE_WINDOW_MS;
 var OUTBOUND_DEDUPE_MAX_SUPPRESS_MS;
 var OUTBOUND_DEDUPE_MAX;
 var OUTBOUND_DEDUPE_TYPES;
+var RETRY_CANDIDATE_TTL_MS;
+var RETRY_CANDIDATE_MAX;
 var SecureChannel;
 var init_channel = __esm2({
   async "src/channel.ts"() {
@@ -64653,6 +64655,8 @@ var init_channel = __esm2({
     OUTBOUND_DEDUPE_MAX_SUPPRESS_MS = 15e3;
     OUTBOUND_DEDUPE_MAX = 256;
     OUTBOUND_DEDUPE_TYPES = /* @__PURE__ */ new Set(["text", "status_alert", "artifact", "attachment"]);
+    RETRY_CANDIDATE_TTL_MS = 6e4;
+    RETRY_CANDIDATE_MAX = 32;
     SecureChannel = class _SecureChannel extends EventEmitter {
       constructor(config22) {
         super();
@@ -64772,6 +64776,20 @@ var init_channel = __esm2({
        * single delivery. In-memory only (short window; no cross-restart persistence needed).
        */
       _recentDeliveries = /* @__PURE__ */ new Map();
+      /**
+       * Last outbound plaintext per MLS group id (#732), so a message refused with
+       * `unknown group` can be resent once the map is reconciled.
+       *
+       * PLAINTEXT, not the frame: the refused frame's `payload` is ciphertext
+       * encrypted to a group that no longer exists, so replaying those bytes into
+       * the replacement group would store something nobody can decrypt. The retry
+       * has to encrypt again, which means keeping what was encrypted.
+       *
+       * In-memory only, TTL-bounded, and consumed on first use — this exists for
+       * the ~50ms between a frame reaching the socket and the server refusing it,
+       * not as a durable outbox (that is #688's dead-letter).
+       */
+      _retryCandidates = /* @__PURE__ */ new Map();
       _scanEngine = null;
       _scanRuleSetVersion = 0;
       _telemetryReporter = null;
@@ -64871,13 +64889,21 @@ var init_channel = __esm2({
        * Non-fatal: a transient network error or 5xx keeps the current JWT and
        * relies on the next reconnect. Terminal failures (401/403) surface via
        * the `auth_failed` event so callers can prompt the user to recover.
+       *
+       * Returns TRUE when the credentials are terminally dead. #743: the caller
+       * MUST NOT go on to open a WebSocket in that case — the server has already
+       * told us this credential can never be served, and connecting anyway is what
+       * produced `ws_guard action=denylist` on repeat in prod (device 0e87ff50, a
+       * hard-deleted device, ~12/hour). The verdict is returned explicitly rather
+       * than read back off `_authFailedThisSession`, whose lifetime is reset per
+       * connect and is easy to get subtly wrong.
        */
       async _maybeReissueDeviceJwt() {
         const jwt22 = this._persisted?.deviceJwt ?? this._deviceJwt;
-        if (!jwt22) return;
+        if (!jwt22) return false;
         const exp = this._decodeJwtExp(jwt22);
         const nowSec = Math.floor(Date.now() / 1e3);
-        if (exp - nowSec >= 30 * 86400) return;
+        if (exp - nowSec >= 30 * 86400) return false;
         try {
           const resp = await fetch(`${this.config.apiUrl}/api/v1/auth/reissue`, {
             method: "POST",
@@ -64897,7 +64923,7 @@ var init_channel = __esm2({
             } else {
               console.warn("[SecureChannel] reissue returned 200 but no device_jwt in response");
             }
-            return;
+            return false;
           }
           if (resp.status === 401 || resp.status === 403) {
             console.warn(`[SecureChannel] reissue rejected (${resp.status}); credentials need attention`);
@@ -64905,12 +64931,13 @@ var init_channel = __esm2({
             const reason = resp.status === 401 ? "device_jwt_expired" : "device_revoked";
             await this._postAuthFailedToBackend(reason);
             this.emit("auth_failed", { reason });
-            return;
+            return true;
           }
           console.warn(`[SecureChannel] reissue ${resp.status}; keeping current jwt`);
         } catch (err) {
           console.warn("[SecureChannel] reissue network error; keeping current jwt:", err);
         }
+        return false;
       }
       /**
        * Wraps `fetch` for authenticated AV REST endpoints with reactive device-JWT
@@ -65396,7 +65423,9 @@ var init_channel = __esm2({
           }
           scanStatus = scanResult.status;
         }
-        this._appendHistory("agent", plaintext, topicId);
+        if (!options?.isResend) {
+          this._appendHistory("agent", plaintext, topicId);
+        }
         const roomConvIds = /* @__PURE__ */ new Set();
         if (this._persisted?.rooms) {
           for (const room of Object.values(this._persisted.rooms)) {
@@ -65410,6 +65439,7 @@ var init_channel = __esm2({
         let sentCount = 0;
         const pendingWsSends = [];
         const sentSharedGroupIds = /* @__PURE__ */ new Set();
+        const addressedMlsGroupIds = [];
         if (this._persisted?.mlsGroups && this._state === "ready" && this._ws) {
           const targetSharedGid = targetConvId ? this._sessionGroupIds?.get(targetConvId) : void 0;
           for (const [gid, entry] of Object.entries(this._persisted.mlsGroups)) {
@@ -65435,6 +65465,7 @@ var init_channel = __esm2({
               if (this._persisted?.hubAddress) payload.hub_address = this._persisted.hubAddress;
               if (this._persisted?.hubId) payload.sender_hub_id = this._persisted.hubId;
               pendingWsSends.push(JSON.stringify({ event: "message_mls", data: payload }));
+              addressedMlsGroupIds.push(entry.mlsGroupId);
               sentSharedGroupIds.add(gid);
               sentCount++;
               console.log(`[SecureChannel] Shared MLS group send for group ${gid.slice(0, 8)} (${entry.mlsGroupId.slice(0, 8)})`);
@@ -65487,6 +65518,7 @@ var init_channel = __esm2({
                   data: payload
                 })
               );
+              addressedMlsGroupIds.push(mlsGroupId);
               if (convGroupId) sentSharedGroupIds.add(convGroupId);
             } else {
               const encrypted = session.ratchet.encrypt(plaintext);
@@ -65572,6 +65604,7 @@ var init_channel = __esm2({
               if (this._persisted?.hubAddress) payload.hub_address = this._persisted.hubAddress;
               if (this._persisted?.hubId) payload.sender_hub_id = this._persisted.hubId;
               pendingWsSends.push(JSON.stringify({ event: "message_mls", data: payload }));
+              addressedMlsGroupIds.push(resolvedMlsGroupId);
               sentCount++;
               if (mlsOnlyConvGroupId) sentSharedGroupIds.add(mlsOnlyConvGroupId);
               console.log(`[SecureChannel] MLS-only send for conv ${mlsConvId.slice(0, 8)} (no DR session)`);
@@ -65587,6 +65620,28 @@ var init_channel = __esm2({
         for (const frame of pendingWsSends) {
           this._ws.send(frame);
         }
+        if (!options?.isResend) {
+          for (const mlsGroupId of addressedMlsGroupIds) {
+            this._rememberRetryCandidate(mlsGroupId, plaintext, options);
+          }
+        }
+      }
+      /**
+       * Retain one outbound plaintext against the MLS group it was sent to (#732).
+       * Evicts expired entries, then the oldest, so the map cannot grow unbounded
+       * on an agent that sends steadily and is never refused.
+       */
+      _rememberRetryCandidate(mlsGroupId, plaintext, options) {
+        const now = Date.now();
+        for (const [k2, v22] of this._retryCandidates) {
+          if (now - v22.ts > RETRY_CANDIDATE_TTL_MS) this._retryCandidates.delete(k2);
+        }
+        this._retryCandidates.set(mlsGroupId, { plaintext, options, ts: now });
+        while (this._retryCandidates.size > RETRY_CANDIDATE_MAX) {
+          const oldest = this._retryCandidates.keys().next().value;
+          if (!oldest) break;
+          this._retryCandidates.delete(oldest);
+        }
       }
       /**
        * Send a typing indicator to all owner devices.
@@ -65614,7 +65669,7 @@ var init_channel = __esm2({
        */
       sendActivitySpan(spanData) {
         if (!this._ws || this._ws.readyState !== WebSocket2.OPEN) return;
-        const pluginVersion = true ? "0.23.14" : "0.0.0-dev";
+        const pluginVersion = true ? "0.23.17" : "0.0.0-dev";
         const agentName = this.config.agentName ?? "Agent";
         const resource = {
           "service.name": "agentvault-agent",
@@ -65959,13 +66014,20 @@ var init_channel = __esm2({
        * entry, then persist.
        */
       async _handleServerError(payload) {
-        if (payload?.detail !== "conversation deleted") return;
+        const detail = payload?.detail;
+        if (detail !== "conversation deleted" && detail !== "unknown group") return;
         const mlsGroupId = payload.group_id;
         if (!mlsGroupId) return;
         const groups = this._persisted?.mlsGroups;
         if (!groups) return;
         const gid = Object.keys(groups).find((k2) => groups[k2]?.mlsGroupId === mlsGroupId);
         if (!gid) return;
+        if (detail === "unknown group") {
+          const changed = await this._reconcileConversationGroups(gid, mlsGroupId);
+          if (changed) await this._retryAfterReconcile(mlsGroupId);
+          return;
+        }
+        this._retryCandidates.delete(mlsGroupId);
         try {
           await deleteMlsState(this.config.dataDir, mlsGroupId);
         } catch {
@@ -65978,6 +66040,120 @@ var init_channel = __esm2({
         );
         this.emit("dm_group_pruned", { conversationGroupId: gid, mlsGroupId });
       }
+      /**
+       * Re-resolve the conversation→group map from the server (#719).
+       *
+       * `_persisted.conversationGroupIds` and `_persisted.groupId` are built ONCE,
+       * in `_activate()`, from the activation response. `_activate` runs at
+       * enrollment and never again, so when the owner deletes a conversation and a
+       * new one is created the agent keeps addressing the OLD group forever.
+       * Nothing reconciled it — not restart (the stale map is reloaded from disk),
+       * not reconnect, not the heartbeat.
+       *
+       * wren, 2026-07-31: `groupId` 53798dd2 had no `mls_groups` row while three
+       * ACTIVE conversations sat on 99faf707. Inbound worked, every reply was
+       * refused `unknown group` and dropped. Silent since 2026-07-02 — the #460
+       * fan-out was spraying all 12 known groups, so a live one always got hit.
+       *
+       * Best-effort and conservative, mirroring `_refreshRoomRoster`: on any
+       * failure the existing map is kept. The prune is NARROW — only the group the
+       * server named, and only once the server has positively reported an active
+       * conversation on some other group. Absence of data is never treated as
+       * evidence of deletion.
+       *
+       * Returns TRUE only when the PRIMARY group pointer actually moved, which is
+       * the signal #732's resend is gated on. Deliberately narrower than "anything
+       * in the map changed": if some other group went stale we cannot tell which
+       * conversation replaced it, and delivering a reply to the wrong counterparty
+       * is strictly worse than losing it.
+       */
+      async _reconcileConversationGroups(staleGid, staleMlsGroupId) {
+        const jwt22 = this._deviceJwt ?? this._persisted?.deviceJwt;
+        if (!jwt22 || !this._persisted) return false;
+        let rows;
+        try {
+          const res = await fetch(`${this.config.apiUrl}/api/v1/conversations`, {
+            headers: { Authorization: `Bearer ${jwt22}` }
+          });
+          if (!res.ok) return false;
+          rows = await res.json();
+        } catch (err) {
+          console.warn("[SecureChannel] Conversation re-resolve failed:", err);
+          return false;
+        }
+        if (!Array.isArray(rows)) return false;
+        const mine = rows.filter(
+          (r22) => r22?.agent_device_id === this._deviceId && r22?.status === "active" && typeof r22?.group_id === "string" && typeof r22?.id === "string"
+        );
+        if (mine.length === 0) return false;
+        const before = this._persisted.groupId;
+        this._sessionGroupIds = new Map(mine.map((r22) => [r22.id, r22.group_id]));
+        this._persisted.conversationGroupIds = Object.fromEntries(this._sessionGroupIds);
+        const primary = mine.find((r22) => r22.id === this._persisted.primaryConversationId) ?? mine[0];
+        this._persisted.groupId = primary.group_id;
+        this._persisted.primaryConversationId = primary.id;
+        const liveGroupIds = new Set(mine.map((r22) => r22.group_id));
+        if (!liveGroupIds.has(staleGid)) {
+          try {
+            await deleteMlsState(this.config.dataDir, staleMlsGroupId);
+          } catch {
+          }
+          this._mlsGroups.delete(`1to1-group:${staleGid}`);
+          delete this._persisted.mlsGroups?.[staleGid];
+          this.emit("dm_group_pruned", {
+            conversationGroupId: staleGid,
+            mlsGroupId: staleMlsGroupId
+          });
+        }
+        await this._persistState();
+        console.log(
+          `[SecureChannel] Re-resolved conversation groups after 'unknown group' ${staleMlsGroupId.slice(0, 8)}: primary group ${String(before).slice(0, 8)} \u2192 ${this._persisted.groupId.slice(0, 8)} (${mine.length} active conversation(s))`
+        );
+        return this._persisted.groupId !== before && before === staleGid;
+      }
+      /**
+       * Resend the message that a now-reconciled `unknown group` refusal killed (#732).
+       *
+       * Called ONLY after `_reconcileConversationGroups` reported that the primary
+       * group pointer moved off the refused group, so there is exactly one sensible
+       * destination: the conversation the reconcile settled on.
+       *
+       * The candidate is consumed BEFORE the resend, not after — one attempt is the
+       * bound, and that must hold even if the resend itself throws. A retry that
+       * re-armed on failure would turn a persistent refusal into an infinite loop,
+       * which is a worse failure than the dropped message it set out to fix.
+       *
+       * The resend is always TARGETED, never a broadcast: the original send may
+       * have fanned out to several groups of which only one was refused, and
+       * re-broadcasting would duplicate the message in all the others.
+       */
+      async _retryAfterReconcile(staleMlsGroupId) {
+        const candidate = this._retryCandidates.get(staleMlsGroupId);
+        this._retryCandidates.delete(staleMlsGroupId);
+        if (!candidate) return;
+        if (Date.now() - candidate.ts > RETRY_CANDIDATE_TTL_MS) {
+          console.warn(
+            `[deliver] delivery_result=LOST group=${staleMlsGroupId.slice(0, 8)} reason=retry-window-expired`
+          );
+          return;
+        }
+        const conversationId = this._persisted?.primaryConversationId;
+        if (!conversationId) return;
+        try {
+          await this.send(candidate.plaintext, {
+            ...candidate.options,
+            conversationId,
+            isResend: true
+          });
+          console.log(
+            `[deliver] delivery_result=RESENT group=${staleMlsGroupId.slice(0, 8)} \u2192 ${String(this._persisted?.groupId).slice(0, 8)} conv=${conversationId.slice(0, 8)}`
+          );
+        } catch (err) {
+          console.error(
+            `[deliver] delivery_result=LOST group=${staleMlsGroupId.slice(0, 8)} reason=resend-failed detail=${err instanceof Error ? err.message : String(err)}`
+          );
+        }
+      }
       /**
        * Return info for all joined rooms.
        */
@@ -66350,7 +66526,7 @@ var init_channel = __esm2({
             });
           }
           const targetLabel = resolved.kind === "owner" ? "owner" : `${resolved.kind}:${resolved.id?.slice(0, 8)}...`;
-          console.log(`[deliver] target=${targetLabel} content=${content.type} result=ok`);
+          console.log(`[deliver] target=${targetLabel} content=${content.type} result=sent`);
           if (dedupeKey) {
             try {
               const now = Date.now();
@@ -67244,13 +67420,12 @@ var init_channel = __esm2({
             sessions,
             messageHistory: this._persisted.messageHistory ?? []
           };
-          if (conversations.length > 0) {
-            const firstConv = conversations[0];
-            if (firstConv.group_id) {
-              this._persisted.groupId = firstConv.group_id;
+          if (primary) {
+            if (primary.group_id) {
+              this._persisted.groupId = primary.group_id;
             }
-            if (firstConv.default_topic_id) {
-              this._persisted.defaultTopicId = firstConv.default_topic_id;
+            if (primary.default_topic_id) {
+              this._persisted.defaultTopicId = primary.default_topic_id;
             }
           }
           this._sessionGroupIds = /* @__PURE__ */ new Map();
@@ -67312,7 +67487,13 @@ var init_channel = __esm2({
           this._ws = null;
         }
         this._setState("connecting");
-        await this._maybeReissueDeviceJwt();
+        if (await this._maybeReissueDeviceJwt()) {
+          console.warn(
+            "[SecureChannel] credentials are terminally dead \u2014 aborting connect (no WS attempt)"
+          );
+          this._setState("error");
+          return;
+        }
         const wsUrl = this.config.apiUrl.replace(/^http/, "ws");
         const url22 = `${wsUrl}/api/v1/ws?token=${encodeURIComponent(this._deviceJwt)}&device_id=${this._deviceId}`;
         const ws = new WebSocket2(url22);
@@ -67353,7 +67534,7 @@ var init_channel = __esm2({
                 agentVersion: this.config.agentVersion ?? "0.0.0",
                 // __AV_VERSION__ is injected by esbuild from package.json at build time.
                 // Falls back to "0.0.0-dev" in non-bundled contexts (tests).
-                pluginVersion: true ? "0.23.14" : "0.0.0-dev"
+                pluginVersion: true ? "0.23.17" : "0.0.0-dev"
               });
               this._telemetryReporter.startAutoFlush(3e4);
             }
@@ -67422,7 +67603,12 @@ var init_channel = __esm2({
           try {
             const data = JSON.parse(raw.toString());
             if (data.event && data.event !== "ping" && data.event !== "typing") {
-              console.log(`[SecureChannel] WS event: ${data.event} conv=${(data.conversation_id || data.data?.conversation_id || "").toString().slice(0, 8)}`);
+              const d22 = data.data ?? {};
+              const conv = (data.conversation_id || d22.conversation_id || "").toString();
+              const parts = [`conv=${conv.slice(0, 8)}`];
+              if (d22.group_id) parts.push(`group=${String(d22.group_id).slice(0, 8)}`);
+              if (d22.detail) parts.push(`detail=${d22.detail}`);
+              console.log(`[SecureChannel] WS event: ${data.event} ${parts.join(" ")}`);
             }
             if (data.event === "ping") {
               ws.send(JSON.stringify({ event: "pong" }));
@@ -67671,7 +67857,7 @@ var init_channel = __esm2({
                     agentVersion: this.config.agentVersion ?? "0.0.0",
                     // __AV_VERSION__ is injected by esbuild from package.json at build time.
                     // Falls back to "0.0.0-dev" in non-bundled contexts (tests).
-                    pluginVersion: true ? "0.23.14" : "0.0.0-dev"
+                    pluginVersion: true ? "0.23.17" : "0.0.0-dev"
                   });
                   this._telemetryReporter.startAutoFlush(3e4);
                 }
@@ -67980,6 +68166,10 @@ var init_channel = __esm2({
             }
             if (data.event === "error") {
               const detail = data.data?.detail || data.detail || "Unknown server error";
+              const rejectedGroup = String(data.data?.group_id ?? "").slice(0, 8);
+              console.error(
+                `[deliver] delivery_result=REJECTED group=${rejectedGroup || "unknown"} detail=${detail}`
+              );
               console.error(`[SecureChannel] Server error: ${detail}`);
               await this._handleServerError(data.data || data);
               this.emit("error", new Error(`Server: ${detail}`));
@@ -69066,10 +69256,10 @@ ${messageText}`;
                 await mlsGroup.processCommit(commitBytes);
                 await saveMlsState(this.config.dataDir, groupId, JSON.stringify(mlsGroup.exportState()));
                 console.log(`[SecureChannel] MLS commit processed for room ${roomId.slice(0, 8)} (epoch=${mlsGroup.epoch})`);
+                this._mlsCommitFailCounts.delete(roomId);
               } catch (err) {
                 await this._onCommitFailure(roomId, groupId, err, `room ${roomId.slice(0, 8)}`);
               }
-              this._mlsCommitFailCounts.delete(roomId);
             } else {
               this._bufferMlsCommit(groupId, epoch, data);
               console.log(`[SecureChannel] Buffered MLS commit for room ${roomId.slice(0, 8)} (epoch=${epoch}, group not initialized)`);
@@ -69086,10 +69276,10 @@ ${messageText}`;
                 await mlsGroup.processCommit(commitBytes);
                 await saveMlsState(this.config.dataDir, groupId, JSON.stringify(mlsGroup.exportState()));
                 console.log(`[SecureChannel] MLS commit processed for A2A ${chId.slice(0, 8)} (epoch=${mlsGroup.epoch})`);
+                this._mlsCommitFailCounts.delete(`a2a:${chId}`);
               } catch (err) {
                 await this._onCommitFailure(`a2a:${chId}`, groupId, err, `A2A ${chId.slice(0, 8)}`);
               }
-              this._mlsCommitFailCounts.delete(`a2a:${chId}`);
             } else {
               this._bufferMlsCommit(groupId, epoch, data);
               console.log(`[SecureChannel] Buffered MLS commit for A2A ${chId.slice(0, 8)} (epoch=${epoch}, group not initialized)`);
@@ -70959,7 +71149,7 @@ ${messageText}`;
           return;
         }
         this._authFailedThisSession = true;
-        const authReason = data?.reason === "device_jwt_expired" ? "device_jwt_expired" : "device_revoked";
+        const authReason = data?.reason ?? "device_revoked";
         console.warn(
           `[SecureChannel] connection_rejected (reason=${data?.reason ?? "unknown"}, retryable=false) \u2014 terminal; surfacing auth_failed`
         );
@@ -71123,6 +71313,14 @@ function terminalReenrollMessage(agentName, reason) {
   const who = agentName ? `[${agentName}] ` : "";
   return `${who}device is no longer valid (${reason}) \u2014 it was revoked or replaced. Re-enroll with a fresh token from AgentVault; the old credentials are dead. This agent will stop reconnecting.`;
 }
+function formatChannelError(err) {
+  const msg = String(err);
+  const rejection = /Server: (.+)$/.exec(msg);
+  if (rejection) {
+    return `[AgentVault] DELIVERY FAILED \u2014 the server refused this frame: ${rejection[1]}. The connection survives; this message was dropped and nothing retries it.`;
+  }
+  return `[AgentVault] channel error (non-fatal to the connection): ${msg}`;
+}
 function attachLifecycle(channel, opts = {}) {
   const log = opts.log ?? (() => {
   });
@@ -71323,7 +71521,7 @@ var init_openclaw_plugin = __esm2({
             });
             _channels.set(account.accountId, channel);
             channel.on("error", (err) => {
-              _log?.(`[AgentVault] channel error (non-fatal): ${String(err)}`);
+              _log?.(formatChannelError(err));
             });
             attachLifecycle(channel, {
               agentName: account.agentName,
@@ -97520,7 +97718,7 @@ var init_index = __esm2({
     init_skill_invoker();
     await init_skill_telemetry();
     await init_policy_enforcer();
-    VERSION = true ? "0.23.14" : "0.0.0-dev";
+    VERSION = true ? "0.23.17" : "0.0.0-dev";
   }
 });
 await init_index();
@@ -133784,7 +133982,7 @@ async function main() {
       "[bridge] warning: passing the invite token on the command line is visible to other local users via 'ps'. Prefer: AV_INVITE_TOKEN=\u2026 npx @agentvault/claude-bridge"
     );
   }
-  console.error(`[bridge] version: ${true ? "0.7.4" : "dev"}`);
+  console.error(`[bridge] version: ${true ? "0.7.5" : "dev"}`);
   console.error(`[bridge] data dir: ${cfg.dataDir} (${cfg.dataDirSource})`);
   console.error(`[bridge] workspace: ${cfg.workspaceDir} \xB7 permissions: ${cfg.permissionMode} \xB7 enclave dir fenced`);
   if (cfg.armRoom) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentvault/claude-bridge",
-  "version": "0.7.4",
+  "version": "0.7.5",
   "type": "module",
   "description": "AgentVault Claude Bridge \u2014 daemon for bridging a Claude agent into secure E2E-encrypted AgentVault 1:1 direct messages and rooms.",
   "main": "dist/index.js",