@agentvault/agentvault 0.23.8 → 0.23.10

package/dist/index.js

@@ -64792,7 +64792,7 @@ var init_channel = __esm({
        */
       sendActivitySpan(spanData) {
         if (!this._ws || this._ws.readyState !== WebSocket.OPEN) return;
-        const pluginVersion = true ? "0.23.8" : "0.0.0-dev";
+        const pluginVersion = true ? "0.23.10" : "0.0.0-dev";
         const agentName = this.config.agentName ?? "Agent";
         const resource = {
           "service.name": "agentvault-agent",
@@ -65033,10 +65033,120 @@ var init_channel = __esm({
           this._sessions.delete(convId);
           delete this._persisted.sessions[convId];
         }
+        if (room.mlsGroupId) {
+          try {
+            await deleteMlsState(this.config.dataDir, room.mlsGroupId);
+          } catch {
+          }
+        }
+        this._mlsGroups.delete(roomId);
         delete this._persisted.rooms[roomId];
         await this._persistState();
         this.emit("room_left", { roomId });
       }
+      /**
+       * #629 recurrence fix — reconcile local room state against the server on
+       * connect.
+       *
+       * On disband the server marks each member ``"left"`` and sets
+       * ``room.status="disbanded"`` but sends NO WS event to the agent's bridge, so a
+       * disbanded/left room lingers in local state and replays dead MLS commit
+       * history on every reconnect ("Desired gen in the past" / "invalid ghash tag").
+       * ``GET /rooms`` returns ONLY active rooms the caller is a member of, so any
+       * locally-persisted room ABSENT from it is terminal — prune its MLS state
+       * (file + in-memory group, keyed by roomId), its sessions, and the room entry.
+       *
+       * Fail-safe: a failed fetch / non-ok / non-array response prunes NOTHING, so a
+       * transient error can never over-prune a live room.
+       */
+      async _reconcileRoomsWithServer() {
+        const local = this._persisted?.rooms;
+        if (!local || Object.keys(local).length === 0) return;
+        if (!this._deviceJwt) return;
+        let activeIds;
+        try {
+          const res = await fetch(`${this.config.apiUrl}/api/v1/rooms`, {
+            headers: { Authorization: `Bearer ${this._deviceJwt}` }
+          });
+          if (!res.ok) return;
+          const list = await res.json();
+          if (!Array.isArray(list)) return;
+          activeIds = new Set(
+            list.map((r2) => r2?.id).filter((id) => !!id)
+          );
+        } catch (err) {
+          console.warn(
+            `[SecureChannel] room reconcile skipped (fetch failed, pruning nothing): ${err instanceof Error ? err.message : String(err)}`
+          );
+          return;
+        }
+        const stale = Object.keys(local).filter((rid) => !activeIds.has(rid));
+        if (stale.length === 0) return;
+        for (const rid of stale) {
+          const room = local[rid];
+          if (room?.mlsGroupId) {
+            try {
+              await deleteMlsState(this.config.dataDir, room.mlsGroupId);
+            } catch {
+            }
+          }
+          this._mlsGroups.delete(rid);
+          for (const convId of room?.conversationIds ?? []) {
+            this._sessions.delete(convId);
+            if (this._persisted?.sessions) delete this._persisted.sessions[convId];
+          }
+          delete local[rid];
+        }
+        await this._persistState();
+        console.log(
+          `[SecureChannel] Room reconcile: pruned ${stale.length} disbanded/left room(s) from local state (${stale.map((r2) => r2.slice(0, 8)).join(", ")})`
+        );
+        this.emit("rooms_reconciled", { pruned: stale });
+      }
+      /**
+       * Handle an in-band `{event:"error"}` frame from the server.
+       *
+       * This is an APPLICATION-level error about one resource — it is NOT a
+       * transport fault, and must never be treated as one. When the error names a
+       * dead resource, the correct response is to PRUNE that resource; recycling
+       * the connection would just replay the same doomed write.
+       *
+       * `conversation deleted` (#460/#481) is the server refusing a write to a
+       * shared 1:1 MLS group whose conversations are all closed/deleted. It carries
+       * `group_id` for exactly this purpose. Without the prune, `_persisted.mlsGroups`
+       * is append-only and the 1:1 send path fans out to every entry, so the dead
+       * group takes a rejected write on every message for the life of the agent
+       * (loopita: group c1b1e11a, closed 2026-07-22, still bouncing 3 days later).
+       *
+       * Deliberately NARROW — it prunes only on this exact detail AND only when
+       * `group_id` matches a persisted shared 1:1 group. Unknown ids and other
+       * details prune nothing, so a server-side wording change or a room/A2A group
+       * can never cost us live MLS state. Safe because `closed`/`deleted` are
+       * terminal server-side, and a genuinely new group re-arrives via Welcome.
+       *
+       * Mirrors the #629 room prune: MLS state file, in-memory group, persisted
+       * entry, then persist.
+       */
+      async _handleServerError(payload) {
+        if (payload?.detail !== "conversation deleted") 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;
+        try {
+          await deleteMlsState(this.config.dataDir, mlsGroupId);
+        } catch {
+        }
+        this._mlsGroups.delete(`1to1-group:${gid}`);
+        delete groups[gid];
+        await this._persistState();
+        console.log(
+          `[SecureChannel] Pruned dead shared 1:1 group ${gid.slice(0, 8)} (${mlsGroupId.slice(0, 8)}) \u2014 server reports its conversation deleted`
+        );
+        this.emit("dm_group_pruned", { conversationGroupId: gid, mlsGroupId });
+      }
       /**
        * Return info for all joined rooms.
        */
@@ -66387,6 +66497,9 @@ var init_channel = __esm({
             await this._pullDrDeliveryQueue();
             await this._flushOutboundQueue();
             this._setState("ready");
+            void this._reconcileRoomsWithServer().catch(
+              (err) => console.warn(`[SecureChannel] room reconcile failed (ignored): ${err instanceof Error ? err.message : String(err)}`)
+            );
             if (this.config.enableScanning) {
               this._scanEngine = new ScanEngine();
               await this._fetchScanRules();
@@ -66409,7 +66522,7 @@ var init_channel = __esm({
                 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.8" : "0.0.0-dev"
+                pluginVersion: true ? "0.23.10" : "0.0.0-dev"
               });
               this._telemetryReporter.startAutoFlush(3e4);
             }
@@ -66727,7 +66840,7 @@ var init_channel = __esm({
                     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.8" : "0.0.0-dev"
+                    pluginVersion: true ? "0.23.10" : "0.0.0-dev"
                   });
                   this._telemetryReporter.startAutoFlush(3e4);
                 }
@@ -67037,6 +67150,7 @@ var init_channel = __esm({
             if (data.event === "error") {
               const detail = data.data?.detail || data.detail || "Unknown server error";
               console.error(`[SecureChannel] Server error: ${detail}`);
+              await this._handleServerError(data.data || data);
               this.emit("error", new Error(`Server: ${detail}`));
             }
             if (data.event === "a2a_message_mls") {
@@ -96941,7 +97055,7 @@ var init_index = __esm({
     init_skill_invoker();
     await init_skill_telemetry();
     await init_policy_enforcer();
-    VERSION = true ? "0.23.8" : "0.0.0-dev";
+    VERSION = true ? "0.23.10" : "0.0.0-dev";
   }
 });
 await init_index();