@agentvault/claude-bridge 0.3.0 → 0.3.2

package/dist/bridge.d.ts

@@ -9,13 +9,30 @@ export interface RoomMessage {
 export interface MessageMeta {
     roomId?: string;
 }
+/** #392 room hush (advisory) — emitted by SecureChannel from the backend's
+ *  `room_hushed` event. ``hushedUntil`` is an ISO string, or null when cleared. */
+export interface RoomHushed {
+    roomId: string;
+    hushedUntil: string | null;
+}
 export interface RoomChannel {
     on(ev: "room_message", cb: (e: RoomMessage) => void): unknown;
     on(ev: "message", cb: (text: string, metadata: MessageMeta) => void): unknown;
+    on(ev: "room_hushed", cb: (e: RoomHushed) => void): unknown;
     on(ev: "error", cb: (err: unknown) => void): unknown;
     sendToRoom(roomId: string, text: string): Promise<void>;
     send(text: string): Promise<void>;
 }
+/**
+ * #392 cooperative quiet: tracks per-room hush windows so the native agent holds
+ * (does not room_say) while the owner has hushed the room. Advisory — the agent
+ * cooperates; the hard backstops are owner mute / remove (enforced server-side).
+ */
+export declare class RoomHushState {
+    private until;
+    set(roomId: string, hushedUntilIso: string | null): void;
+    isHushed(roomId: string, now?: number): boolean;
+}
 export interface RoomSession {
     /** `reply` is the immutable reply sink captured for THIS message (see
      *  ActiveTarget.snapshotReply) — the session invokes it when Claude answers. */

package/dist/index.js

@@ -66743,6 +66743,19 @@ var init_channel = __esm({
                 }
               });
             }
+            if (data.event === "room_hushed") {
+              this.emit("room_hushed", {
+                roomId: data.data?.room_id,
+                hushedUntil: data.data?.hushed_until ?? null
+              });
+            }
+            if (data.event === "room_advisory") {
+              this.emit("room_advisory", {
+                roomId: data.data?.room_id,
+                kind: data.data?.kind,
+                message: data.data?.message
+              });
+            }
             if (data.event === "policy_blocked") {
               this.emit("policy_blocked", data.data);
             }
@@ -68497,6 +68510,21 @@ ${messageText}`;
               return;
             }
           }
+          if (welcomeRoomId && this._persisted) {
+            await this._registerRoomFromWelcome(
+              welcomeRoomId,
+              groupId,
+              mgr,
+              data.room_name
+            );
+            this._pendingMlsKpBundle = void 0;
+            await releaseA2ASyncLock(this.config.dataDir, `room-kp-${groupId}`).catch(() => {
+            });
+            console.log(
+              `[SecureChannel] Registered room ${welcomeRoomId.slice(0, 8)} from unmatched Welcome (epoch=${mgr.epoch})`
+            );
+            return;
+          }
           const a2aChannelId = data.a2a_channel_id;
           for (const [channelId, entry] of Object.entries(this._persisted?.a2aChannels ?? {})) {
             if (entry.mlsGroupId === groupId || channelId === a2aChannelId) {
@@ -68553,6 +68581,33 @@ ${messageText}`;
           throw err;
         }
       }
+      /**
+       * Self-bootstrap a room entry + MLS group mapping from a Welcome whose room is
+       * not yet persisted. Happens when we were added to an EXISTING room and the
+       * `room_joined` that registers the room raced behind (or was lost relative to)
+       * the Welcome. Without a room entry the Welcome room-match loop can't match, and
+       * every subsequent room message is dropped with "No room found for MLS group".
+       * Mirrors the A2A self-bootstrap fallback. The backend now also sends the new
+       * device its own `room_joined` (PR #412); this is defense-in-depth for the race
+       * where that delivery is missed. A later `room_joined` enriches name/members.
+       */
+      async _registerRoomFromWelcome(roomId, groupId, mgr, roomName) {
+        if (!this._persisted) return;
+        if (!this._persisted.rooms) this._persisted.rooms = {};
+        const existing = this._persisted.rooms[roomId];
+        this._persisted.rooms[roomId] = {
+          roomId,
+          name: existing?.name ?? (roomName ?? ""),
+          conversationIds: existing?.conversationIds ?? [],
+          members: existing?.members ?? [],
+          mlsGroupId: groupId,
+          lastMlsMessageTs: existing?.lastMlsMessageTs
+        };
+        this._mlsGroups.set(roomId, mgr);
+        await saveMlsState(this.config.dataDir, groupId, JSON.stringify(mgr.exportState()));
+        await this._persistState();
+        await this._applyBufferedMlsCommits(groupId, mgr);
+      }
       /**
        * Pull pending MLS messages from the delivery queue and process them.
        * Called on WS connect, on mls_delivery ping, and every 30s heartbeat.
@@ -131587,6 +131642,23 @@ var PersistentClaudeSession = class {
 };
 
 // src/bridge.ts
+var RoomHushState = class {
+  until = /* @__PURE__ */ new Map();
+  set(roomId, hushedUntilIso) {
+    if (!roomId) return;
+    if (!hushedUntilIso) {
+      this.until.delete(roomId);
+      return;
+    }
+    const t7 = new Date(hushedUntilIso).getTime();
+    if (Number.isNaN(t7)) return;
+    this.until.set(roomId, t7);
+  }
+  isHushed(roomId, now = Date.now()) {
+    const t7 = this.until.get(roomId);
+    return t7 !== void 0 && now < t7;
+  }
+};
 var ActiveTarget = class {
   target = null;
   setRoom(roomId) {
@@ -131654,8 +131726,19 @@ function wireBridge(channel, session, target, opts = {}) {
     const msg = err instanceof Error ? err.message : String(err);
     log(`channel error (auto-reconnecting): ${msg}`);
   });
+  const hush = new RoomHushState();
+  channel.on("room_hushed", (e7) => {
+    hush.set(e7.roomId, e7.hushedUntil);
+    log(
+      e7.hushedUntil ? `room ${e7.roomId.slice(0, 8)} hushed until ${e7.hushedUntil} \u2014 holding` : `room ${e7.roomId.slice(0, 8)} hush cleared`
+    );
+  });
   channel.on("room_message", (e7) => {
     if (opts.roomFilter && e7.roomId !== opts.roomFilter) return;
+    if (hush.isHushed(e7.roomId)) {
+      log(`inbound from ${e7.senderName} in ${e7.roomId.slice(0, 8)} \u2014 room hushed, holding (not replying)`);
+      return;
+    }
     log(`inbound from ${e7.senderName} in ${e7.roomId.slice(0, 8)}`);
     target.setRoom(e7.roomId);
     session.push(`[${e7.senderName}]: ${e7.plaintext}`, target.snapshotReply(channel, log));

package/package.json

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