@agentvault/secure-channel 0.4.0 → 0.4.2

package/dist/index.js

@@ -45127,17 +45127,21 @@ var SecureChannel = class extends EventEmitter {
   /**
    * Append a message to persistent history for cross-device replay.
    */
-  _appendHistory(sender, text) {
+  _appendHistory(sender, text, topicId) {
     if (!this._persisted) return;
     if (!this._persisted.messageHistory) {
       this._persisted.messageHistory = [];
     }
     const maxSize = this.config.maxHistorySize ?? 500;
-    this._persisted.messageHistory.push({
+    const entry = {
       sender,
       text,
       ts: (/* @__PURE__ */ new Date()).toISOString()
-    });
+    };
+    if (topicId) {
+      entry.topicId = topicId;
+    }
+    this._persisted.messageHistory.push(entry);
     if (this._persisted.messageHistory.length > maxSize) {
       this._persisted.messageHistory = this._persisted.messageHistory.slice(-maxSize);
     }
@@ -45146,11 +45150,12 @@ var SecureChannel = class extends EventEmitter {
    * Encrypt and send a message to ALL owner devices (fanout).
    * Each session gets the same plaintext encrypted independently.
    */
-  async send(plaintext) {
+  async send(plaintext, options) {
     if (this._state !== "ready" || this._sessions.size === 0 || !this._ws) {
       throw new Error("Channel is not ready");
     }
-    this._appendHistory("agent", plaintext);
+    const topicId = options?.topicId ?? this._persisted?.defaultTopicId;
+    this._appendHistory("agent", plaintext, topicId);
     const messageGroupId = randomUUID();
     for (const [convId, session] of this._sessions) {
       if (!session.activated) {
@@ -45165,7 +45170,8 @@ var SecureChannel = class extends EventEmitter {
             conversation_id: convId,
             header_blob: transport.header_blob,
             ciphertext: transport.ciphertext,
-            message_group_id: messageGroupId
+            message_group_id: messageGroupId,
+            topic_id: topicId
           }
         })
       );
@@ -45189,6 +45195,72 @@ var SecureChannel = class extends EventEmitter {
     }
     this._setState("disconnected");
   }
+  // --- Topic management ---
+  /**
+   * Create a new topic within the conversation group.
+   * Requires the channel to be initialized with a groupId (from activation).
+   */
+  async createTopic(name) {
+    if (!this._persisted?.groupId) {
+      throw new Error("Channel not initialized or groupId unknown");
+    }
+    if (!this._deviceJwt) {
+      throw new Error("Channel not authenticated");
+    }
+    const res = await fetch(`${this.config.apiUrl}/api/v1/topics`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this._deviceJwt}`
+      },
+      body: JSON.stringify({
+        group_id: this._persisted.groupId,
+        name,
+        creator_device_id: this._persisted.deviceId
+      })
+    });
+    if (!res.ok) {
+      const detail = await res.text();
+      throw new Error(`Create topic failed (${res.status}): ${detail}`);
+    }
+    const resp = await res.json();
+    const topic = { id: resp.id, name: resp.name, isDefault: resp.is_default };
+    if (!this._persisted.topics) {
+      this._persisted.topics = [];
+    }
+    this._persisted.topics.push(topic);
+    await this._persistState();
+    return topic;
+  }
+  /**
+   * List all topics in the conversation group.
+   * Requires the channel to be initialized with a groupId (from activation).
+   */
+  async listTopics() {
+    if (!this._persisted?.groupId) {
+      throw new Error("Channel not initialized or groupId unknown");
+    }
+    if (!this._deviceJwt) {
+      throw new Error("Channel not authenticated");
+    }
+    const res = await fetch(
+      `${this.config.apiUrl}/api/v1/topics?group_id=${encodeURIComponent(this._persisted.groupId)}`,
+      {
+        headers: {
+          Authorization: `Bearer ${this._deviceJwt}`
+        }
+      }
+    );
+    if (!res.ok) {
+      const detail = await res.text();
+      throw new Error(`List topics failed (${res.status}): ${detail}`);
+    }
+    const resp = await res.json();
+    const topics = resp.map((t2) => ({ id: t2.id, name: t2.name, isDefault: t2.is_default }));
+    this._persisted.topics = topics;
+    await this._persistState();
+    return topics;
+  }
   // --- Internal lifecycle ---
   async _enroll() {
     this._setState("enrolling");
@@ -45315,6 +45387,15 @@ var SecureChannel = class extends EventEmitter {
         sessions,
         messageHistory: this._persisted.messageHistory ?? []
       };
+      if (conversations.length > 0) {
+        const firstConv = conversations[0];
+        if (firstConv.group_id) {
+          this._persisted.groupId = firstConv.group_id;
+        }
+        if (firstConv.default_topic_id) {
+          this._persisted.defaultTopicId = firstConv.default_topic_id;
+        }
+      }
       await saveState(this.config.dataDir, this._persisted);
       if (this.config.webhookUrl) {
         try {
@@ -45352,6 +45433,14 @@ var SecureChannel = class extends EventEmitter {
   }
   _connect() {
     if (this._stopped) return;
+    if (this._ws) {
+      this._ws.removeAllListeners();
+      try {
+        this._ws.close();
+      } catch {
+      }
+      this._ws = null;
+    }
     this._setState("connecting");
     const wsUrl = this.config.apiUrl.replace(/^http/, "ws");
     const url = `${wsUrl}/api/v1/ws?token=${encodeURIComponent(this._deviceJwt)}&device_id=${this._deviceId}`;
@@ -45436,15 +45525,17 @@ var SecureChannel = class extends EventEmitter {
       return;
     }
     if (messageType === "message") {
-      this._appendHistory("owner", messageText);
+      const topicId = msgData.topic_id;
+      this._appendHistory("owner", messageText, topicId);
       const metadata = {
         messageId: msgData.message_id,
         conversationId: convId,
-        timestamp: msgData.created_at
+        timestamp: msgData.created_at,
+        topicId
       };
       this.emit("message", messageText, metadata);
       this.config.onMessage?.(messageText, metadata);
-      await this._relaySyncToSiblings(convId, session.ownerDeviceId, messageText);
+      await this._relaySyncToSiblings(convId, session.ownerDeviceId, messageText, topicId);
     }
     if (this._persisted) {
       this._persisted.lastMessageTimestamp = msgData.created_at;
@@ -45455,13 +45546,14 @@ var SecureChannel = class extends EventEmitter {
    * Relay an owner's message to all sibling sessions as encrypted sync messages.
    * This allows all owner devices to see messages from any single device.
    */
-  async _relaySyncToSiblings(sourceConvId, senderOwnerDeviceId, messageText) {
+  async _relaySyncToSiblings(sourceConvId, senderOwnerDeviceId, messageText, topicId) {
     if (!this._ws || this._sessions.size <= 1) return;
     const syncPayload = JSON.stringify({
       type: "sync",
       sender: senderOwnerDeviceId,
       text: messageText,
-      ts: (/* @__PURE__ */ new Date()).toISOString()
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      topicId
     });
     for (const [siblingConvId, siblingSession] of this._sessions) {
       if (siblingConvId === sourceConvId) continue;
@@ -45611,11 +45703,13 @@ var SecureChannel = class extends EventEmitter {
             messageText = plaintext;
           }
           if (messageType === "message") {
-            this._appendHistory("owner", messageText);
+            const topicId = msg.topic_id;
+            this._appendHistory("owner", messageText, topicId);
             const metadata = {
               messageId: msg.id,
               conversationId: msg.conversation_id,
-              timestamp: msg.created_at
+              timestamp: msg.created_at,
+              topicId
             };
             this.emit("message", messageText, metadata);
             this.config.onMessage?.(messageText, metadata);
@@ -45632,6 +45726,7 @@ var SecureChannel = class extends EventEmitter {
   }
   _scheduleReconnect() {
     if (this._stopped) return;
+    if (this._reconnectTimer) return;
     const delay = Math.min(
       RECONNECT_BASE_MS * Math.pow(2, this._reconnectAttempt),
       RECONNECT_MAX_MS