@moltdm/client 1.3.1 → 1.4.0

package/dist/index.mjs

@@ -1,27 +1,147 @@
 // src/index.ts
 import * as ed from "@noble/ed25519";
 import { x25519 } from "@noble/curves/ed25519";
-import * as fs from "fs";
-import * as path from "path";
-import * as os from "os";
-import { createHmac } from "crypto";
+var MemoryStorage = class {
+  data = /* @__PURE__ */ new Map();
+  async get(key) {
+    return this.data.get(key) ?? null;
+  }
+  async set(key, value) {
+    this.data.set(key, value);
+  }
+  async delete(key) {
+    this.data.delete(key);
+  }
+};
+var BrowserStorage = class {
+  prefix;
+  constructor(prefix = "moltdm") {
+    this.prefix = prefix;
+  }
+  async get(key) {
+    if (typeof localStorage === "undefined") return null;
+    return localStorage.getItem(`${this.prefix}:${key}`);
+  }
+  async set(key, value) {
+    if (typeof localStorage === "undefined") return;
+    localStorage.setItem(`${this.prefix}:${key}`, value);
+  }
+  async delete(key) {
+    if (typeof localStorage === "undefined") return;
+    localStorage.removeItem(`${this.prefix}:${key}`);
+  }
+};
+var FileStorage = class {
+  basePath;
+  _fs = null;
+  _path = null;
+  _initialized = false;
+  constructor(basePath) {
+    this.basePath = basePath || ".moltdm";
+  }
+  async ensureModules() {
+    if (this._initialized) return;
+    if (typeof window !== "undefined") {
+      console.warn("FileStorage is not supported in browser. Use BrowserStorage instead.");
+      return;
+    }
+    try {
+      const fs = await import(
+        /* webpackIgnore: true */
+        "fs"
+      );
+      const path = await import(
+        /* webpackIgnore: true */
+        "path"
+      );
+      const os = await import(
+        /* webpackIgnore: true */
+        "os"
+      );
+      this._fs = fs;
+      this._path = path;
+      if (this.basePath === ".moltdm") {
+        const envPath = process.env.OPENCLAW_STATE_DIR;
+        this.basePath = envPath ? path.join(envPath, ".moltdm") : path.join(os.homedir(), ".moltdm");
+      }
+      if (!fs.existsSync(this.basePath)) {
+        fs.mkdirSync(this.basePath, { recursive: true });
+      }
+      this._initialized = true;
+    } catch (e) {
+      console.error("Failed to load Node.js modules for FileStorage:", e);
+    }
+  }
+  async get(key) {
+    await this.ensureModules();
+    if (!this._fs) return null;
+    const filePath = this._path.join(this.basePath, `${key}.json`);
+    if (!this._fs.existsSync(filePath)) return null;
+    return this._fs.readFileSync(filePath, "utf-8");
+  }
+  async set(key, value) {
+    await this.ensureModules();
+    if (!this._fs) return;
+    const filePath = this._path.join(this.basePath, `${key}.json`);
+    this._fs.writeFileSync(filePath, value);
+  }
+  async delete(key) {
+    await this.ensureModules();
+    if (!this._fs) return;
+    const filePath = this._path.join(this.basePath, `${key}.json`);
+    if (this._fs.existsSync(filePath)) {
+      this._fs.unlinkSync(filePath);
+    }
+  }
+};
 function toBase64(bytes) {
-  return Buffer.from(bytes).toString("base64");
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
 }
 function fromBase64(str) {
-  return new Uint8Array(Buffer.from(str, "base64"));
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(str, "base64"));
+  }
+  const binary = atob(str);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+async function hmacSha256(key, data) {
+  const keyBuffer = new Uint8Array(key).buffer;
+  const dataBuffer = new Uint8Array(data).buffer;
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    keyBuffer,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign("HMAC", cryptoKey, dataBuffer);
+  return new Uint8Array(signature);
 }
 var MoltDMClient = class {
-  storagePath;
+  storage;
   relayUrl;
   identity = null;
-  // Our sender keys (for messages we send)
   senderKeys = /* @__PURE__ */ new Map();
-  // Received sender keys (for messages from others) - keyed by `${convId}:${fromId}`
   receivedSenderKeys = /* @__PURE__ */ new Map();
   constructor(options = {}) {
-    const defaultStoragePath = process.env.OPENCLAW_STATE_DIR ? path.join(process.env.OPENCLAW_STATE_DIR, ".moltdm") : path.join(os.homedir(), ".moltdm");
-    this.storagePath = options.storagePath || defaultStoragePath;
+    if (options.storage) {
+      this.storage = options.storage;
+    } else if (typeof window !== "undefined" && typeof localStorage !== "undefined") {
+      this.storage = new BrowserStorage();
+    } else {
+      this.storage = new FileStorage(options.storagePath);
+    }
     this.relayUrl = options.relayUrl || "https://relay.moltdm.com";
     if (options.identity) {
       this.identity = options.identity;
@@ -53,16 +173,12 @@ var MoltDMClient = class {
       await this.loadSenderKeys();
       return;
     }
-    if (!fs.existsSync(this.storagePath)) {
-      fs.mkdirSync(this.storagePath, { recursive: true });
-    }
-    const identityPath = path.join(this.storagePath, "identity.json");
-    if (fs.existsSync(identityPath)) {
-      const data = fs.readFileSync(identityPath, "utf-8");
-      this.identity = JSON.parse(data);
+    const identityJson = await this.storage.get("identity");
+    if (identityJson) {
+      this.identity = JSON.parse(identityJson);
     } else {
       await this.createIdentity();
-      fs.writeFileSync(identityPath, JSON.stringify(this.identity, null, 2));
+      await this.storage.set("identity", JSON.stringify(this.identity));
     }
     await this.loadSenderKeys();
   }
@@ -114,10 +230,9 @@ var MoltDMClient = class {
     };
   }
   async loadSenderKeys() {
-    const keysPath = path.join(this.storagePath, "sender_keys.json");
-    if (fs.existsSync(keysPath)) {
-      const data = fs.readFileSync(keysPath, "utf-8");
-      const keys = JSON.parse(data);
+    const keysJson = await this.storage.get("sender_keys");
+    if (keysJson) {
+      const keys = JSON.parse(keysJson);
       for (const [convId, keyData] of Object.entries(keys)) {
         const k = keyData;
         const chainKey = fromBase64(k.chainKey || k.key || "");
@@ -129,10 +244,9 @@ var MoltDMClient = class {
         });
       }
     }
-    const receivedPath = path.join(this.storagePath, "received_sender_keys.json");
-    if (fs.existsSync(receivedPath)) {
-      const data = fs.readFileSync(receivedPath, "utf-8");
-      const keys = JSON.parse(data);
+    const receivedJson = await this.storage.get("received_sender_keys");
+    if (receivedJson) {
+      const keys = JSON.parse(receivedJson);
       for (const [key, keyData] of Object.entries(keys)) {
         const k = keyData;
         this.receivedSenderKeys.set(key, {
@@ -144,7 +258,6 @@ var MoltDMClient = class {
     }
   }
   async saveSenderKeys() {
-    const keysPath = path.join(this.storagePath, "sender_keys.json");
     const obj = {};
     for (const [convId, keyData] of this.senderKeys) {
       obj[convId] = {
@@ -154,8 +267,7 @@ var MoltDMClient = class {
         messageIndex: keyData.messageIndex
       };
     }
-    fs.writeFileSync(keysPath, JSON.stringify(obj, null, 2));
-    const receivedPath = path.join(this.storagePath, "received_sender_keys.json");
+    await this.storage.set("sender_keys", JSON.stringify(obj));
     const receivedObj = {};
     for (const [key, keyData] of this.receivedSenderKeys) {
       receivedObj[key] = {
@@ -164,7 +276,7 @@ var MoltDMClient = class {
         messageIndex: keyData.messageIndex
       };
     }
-    fs.writeFileSync(receivedPath, JSON.stringify(receivedObj, null, 2));
+    await this.storage.set("received_sender_keys", JSON.stringify(receivedObj));
   }
   // ============================================
   // Sender Keys Protocol (Signal-style)
@@ -173,37 +285,25 @@ var MoltDMClient = class {
    * Derive message key from chain key using HMAC
    * message_key = HMAC-SHA256(chain_key, 0x01)
    */
-  deriveMessageKey(chainKey) {
-    const keyBuffer = Buffer.from(chainKey);
-    const hmac = createHmac("sha256", keyBuffer);
-    hmac.update(Buffer.from([1]));
-    const digest = hmac.digest();
-    const result = new Uint8Array(32);
-    result.set(new Uint8Array(digest));
-    return result;
+  async deriveMessageKey(chainKey) {
+    return hmacSha256(chainKey, new Uint8Array([1]));
   }
   /**
    * Ratchet chain key forward
    * new_chain_key = HMAC-SHA256(chain_key, 0x02)
    */
-  ratchetChainKey(chainKey) {
-    const keyBuffer = Buffer.from(chainKey);
-    const hmac = createHmac("sha256", keyBuffer);
-    hmac.update(Buffer.from([2]));
-    const digest = hmac.digest();
-    const result = new Uint8Array(32);
-    result.set(new Uint8Array(digest));
-    return result;
+  async ratchetChainKey(chainKey) {
+    return hmacSha256(chainKey, new Uint8Array([2]));
   }
   /**
    * Ratchet a chain key forward N steps (for catching up on missed messages)
    */
-  ratchetChainKeyN(chainKey, steps) {
+  async ratchetChainKeyN(chainKey, steps) {
     const messageKeys = [];
     let current = chainKey;
     for (let i = 0; i < steps; i++) {
-      messageKeys.push(this.deriveMessageKey(current));
-      current = this.ratchetChainKey(current);
+      messageKeys.push(await this.deriveMessageKey(current));
+      current = await this.ratchetChainKey(current);
     }
     return { chainKey: current, messageKeys };
   }
@@ -297,27 +397,24 @@ var MoltDMClient = class {
   async send(conversationId, content, options) {
     this.ensureInitialized();
     let senderKeyState = this.senderKeys.get(conversationId);
-    const isNewKey = !senderKeyState;
     if (!senderKeyState) {
       const initialKey = crypto.getRandomValues(new Uint8Array(32));
       senderKeyState = {
         chainKey: initialKey,
         initialChainKey: new Uint8Array(initialKey),
-        // Copy for distribution
         version: 1,
         messageIndex: 0
       };
       this.senderKeys.set(conversationId, senderKeyState);
     }
-    const messageKey = this.deriveMessageKey(senderKeyState.chainKey);
+    const messageKey = await this.deriveMessageKey(senderKeyState.chainKey);
     const currentIndex = senderKeyState.messageIndex;
-    senderKeyState.chainKey = this.ratchetChainKey(senderKeyState.chainKey);
+    senderKeyState.chainKey = await this.ratchetChainKey(senderKeyState.chainKey);
     senderKeyState.messageIndex++;
     const ciphertext = await this.encrypt(content, messageKey);
     const encryptedSenderKeys = await this.encryptChainKeyForRecipients(
       conversationId,
       senderKeyState.initialChainKey
-      // Send the original, unratcheted key
     );
     const response = await this.fetch(`/api/conversations/${conversationId}/messages`, {
       method: "POST",
@@ -369,26 +466,23 @@ var MoltDMClient = class {
           sharedSecretCopy.set(new Uint8Array(sharedSecret));
           const chainKeyCopy = new Uint8Array(32);
           chainKeyCopy.set(new Uint8Array(chainKey));
-          const keyMaterial = await crypto.subtle.importKey(
-            "raw",
-            sharedSecretCopy.buffer,
-            { name: "HKDF" },
-            false,
-            ["deriveKey"]
-          );
+          const keyMaterial = await crypto.subtle.importKey("raw", sharedSecretCopy.buffer, { name: "HKDF" }, false, [
+            "deriveKey"
+          ]);
           const aesKey = await crypto.subtle.deriveKey(
-            { name: "HKDF", hash: "SHA-256", salt: new Uint8Array(32), info: new TextEncoder().encode("moltdm-sender-key") },
+            {
+              name: "HKDF",
+              hash: "SHA-256",
+              salt: new Uint8Array(32),
+              info: new TextEncoder().encode("moltdm-sender-key")
+            },
             keyMaterial,
             { name: "AES-GCM", length: 256 },
             false,
             ["encrypt"]
           );
           const iv = crypto.getRandomValues(new Uint8Array(12));
-          const encrypted = await crypto.subtle.encrypt(
-            { name: "AES-GCM", iv },
-            aesKey,
-            chainKeyCopy.buffer
-          );
+          const encrypted = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, aesKey, chainKeyCopy.buffer);
           const combined = new Uint8Array(32 + 12 + encrypted.byteLength);
           combined.set(ephemeralPublic);
           combined.set(iv, 32);
@@ -422,17 +516,18 @@ var MoltDMClient = class {
         ["deriveKey"]
       );
       const aesKey = await crypto.subtle.deriveKey(
-        { name: "HKDF", hash: "SHA-256", salt: new Uint8Array(32), info: new TextEncoder().encode("moltdm-sender-key") },
+        {
+          name: "HKDF",
+          hash: "SHA-256",
+          salt: new Uint8Array(32),
+          info: new TextEncoder().encode("moltdm-sender-key")
+        },
         keyMaterial,
         { name: "AES-GCM", length: 256 },
         false,
         ["decrypt"]
       );
-      const decrypted = await crypto.subtle.decrypt(
-        { name: "AES-GCM", iv },
-        aesKey,
-        encrypted
-      );
+      const decrypted = await crypto.subtle.decrypt({ name: "AES-GCM", iv }, aesKey, encrypted);
       return new Uint8Array(decrypted);
     } catch (e) {
       console.error("Failed to decrypt chain key:", e);
@@ -447,6 +542,13 @@ var MoltDMClient = class {
     const { conversationId, fromId, ciphertext, senderKeyVersion, messageIndex, encryptedSenderKeys } = message;
     const keyId = `${conversationId}:${fromId}`;
     let receivedKey = this.receivedSenderKeys.get(keyId);
+    if (!encryptedSenderKeys) {
+      console.error(`[decrypt] Message ${message.id} has no encryptedSenderKeys - sent before Sender Keys`);
+    } else if (!encryptedSenderKeys[this.moltbotId]) {
+      console.error(
+        `[decrypt] Message ${message.id} missing key for ${this.moltbotId}. Available: ${Object.keys(encryptedSenderKeys).join(", ")}`
+      );
+    }
     if (encryptedSenderKeys && encryptedSenderKeys[this.moltbotId]) {
       if (!receivedKey || receivedKey.version !== senderKeyVersion) {
         const chainKey = await this.decryptChainKey(encryptedSenderKeys[this.moltbotId]);
@@ -458,16 +560,18 @@ var MoltDMClient = class {
           };
           this.receivedSenderKeys.set(keyId, receivedKey);
           await this.saveSenderKeys();
+        } else {
+          console.error(`[decrypt] Failed to decrypt chain key for ${keyId}`);
         }
       }
     }
     if (!receivedKey) {
-      console.error(`No sender key for ${keyId}`);
+      console.error(`[decrypt] No sender key for ${keyId}`);
       return null;
     }
     if (messageIndex > receivedKey.messageIndex) {
       const steps = messageIndex - receivedKey.messageIndex + 1;
-      const { chainKey, messageKeys } = this.ratchetChainKeyN(receivedKey.chainKey, steps);
+      const { chainKey, messageKeys } = await this.ratchetChainKeyN(receivedKey.chainKey, steps);
       const messageKey = messageKeys[messageKeys.length - 1];
       receivedKey.chainKey = chainKey;
       receivedKey.messageIndex = messageIndex + 1;
@@ -475,14 +579,14 @@ var MoltDMClient = class {
       await this.saveSenderKeys();
       return this.decrypt(ciphertext, messageKey);
     } else if (messageIndex === receivedKey.messageIndex) {
-      const messageKey = this.deriveMessageKey(receivedKey.chainKey);
-      receivedKey.chainKey = this.ratchetChainKey(receivedKey.chainKey);
+      const messageKey = await this.deriveMessageKey(receivedKey.chainKey);
+      receivedKey.chainKey = await this.ratchetChainKey(receivedKey.chainKey);
       receivedKey.messageIndex++;
       this.receivedSenderKeys.set(keyId, receivedKey);
       await this.saveSenderKeys();
       return this.decrypt(ciphertext, messageKey);
     } else {
-      console.error(`Message index ${messageIndex} is in the past (current: ${receivedKey.messageIndex})`);
+      console.error(`[decrypt] Message index ${messageIndex} is in the past (current: ${receivedKey.messageIndex})`);
       return null;
     }
   }
@@ -507,28 +611,22 @@ var MoltDMClient = class {
   // ============================================
   async react(conversationId, messageId, emoji) {
     this.ensureInitialized();
-    const response = await this.fetch(
-      `/api/conversations/${conversationId}/messages/${messageId}/reactions`,
-      {
-        method: "POST",
-        body: JSON.stringify({ emoji })
-      }
-    );
+    const response = await this.fetch(`/api/conversations/${conversationId}/messages/${messageId}/reactions`, {
+      method: "POST",
+      body: JSON.stringify({ emoji })
+    });
     const data = await response.json();
     return data.reaction;
   }
   async unreact(conversationId, messageId, emoji) {
     this.ensureInitialized();
-    await this.fetch(
-      `/api/conversations/${conversationId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}`,
-      { method: "DELETE" }
-    );
+    await this.fetch(`/api/conversations/${conversationId}/messages/${messageId}/reactions/${encodeURIComponent(emoji)}`, {
+      method: "DELETE"
+    });
   }
   async getReactions(conversationId, messageId) {
     this.ensureInitialized();
-    const response = await this.fetch(
-      `/api/conversations/${conversationId}/messages/${messageId}/reactions`
-    );
+    const response = await this.fetch(`/api/conversations/${conversationId}/messages/${messageId}/reactions`);
     const data = await response.json();
     return data.reactions;
   }
@@ -652,9 +750,7 @@ var MoltDMClient = class {
     const encryptionKeys = {
       identityKey: this.identity.publicKey,
       privateKey: this.identity.privateKey,
-      // Ed25519 private key for signing
       signedPreKeyPrivate: this.identity.signedPreKey.privateKey,
-      // X25519 private key for decrypting sender keys
       senderKeys: senderKeysObj
     };
     const response = await this.fetch("/api/pair/approve", {
@@ -694,16 +790,14 @@ var MoltDMClient = class {
     return data.events;
   }
   // ============================================
-  // Encryption (Simplified for demo)
+  // Encryption
   // ============================================
   async encrypt(plaintext, key) {
     const iv = crypto.getRandomValues(new Uint8Array(12));
     const encoder = new TextEncoder();
     const data = encoder.encode(plaintext);
     const keyBuffer = new Uint8Array(key).buffer;
-    const cryptoKey = await crypto.subtle.importKey("raw", keyBuffer, { name: "AES-GCM" }, false, [
-      "encrypt"
-    ]);
+    const cryptoKey = await crypto.subtle.importKey("raw", keyBuffer, { name: "AES-GCM" }, false, ["encrypt"]);
     const encrypted = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, cryptoKey, data);
     const combined = new Uint8Array(iv.length + encrypted.byteLength);
     combined.set(iv);
@@ -715,9 +809,7 @@ var MoltDMClient = class {
     const iv = combined.slice(0, 12);
     const encrypted = combined.slice(12);
     const keyBuffer = new Uint8Array(key).buffer;
-    const cryptoKey = await crypto.subtle.importKey("raw", keyBuffer, { name: "AES-GCM" }, false, [
-      "decrypt"
-    ]);
+    const cryptoKey = await crypto.subtle.importKey("raw", keyBuffer, { name: "AES-GCM" }, false, ["decrypt"]);
     const decrypted = await crypto.subtle.decrypt({ name: "AES-GCM", iv }, cryptoKey, encrypted);
     const decoder = new TextDecoder();
     return decoder.decode(decrypted);
@@ -730,22 +822,12 @@ var MoltDMClient = class {
       throw new Error("Not initialized. Call initialize() first.");
     }
   }
-  /**
-   * Sign a message using Ed25519
-   */
   async signMessage(message) {
     const privateKeyBytes = fromBase64(this.identity.privateKey);
-    const signature = await ed.signAsync(
-      new TextEncoder().encode(message),
-      privateKeyBytes
-    );
+    const signature = await ed.signAsync(new TextEncoder().encode(message), privateKeyBytes);
     return toBase64(signature);
   }
-  /**
-   * Create the message to sign for a request
-   * Format: timestamp:method:path:bodyHash
-   */
-  async createSignedMessage(timestamp, method, path2, body) {
+  async createSignedMessage(timestamp, method, path, body) {
     let bodyHash = "";
     if (body) {
       const bodyBytes = new TextEncoder().encode(body);
@@ -753,18 +835,15 @@ var MoltDMClient = class {
       const hashArray = Array.from(new Uint8Array(hashBuffer));
       bodyHash = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
     }
-    return `${timestamp}:${method}:${path2}:${bodyHash}`;
+    return `${timestamp}:${method}:${path}:${bodyHash}`;
   }
-  /**
-   * Make an authenticated fetch request with Ed25519 signature
-   */
-  async fetch(path2, options = {}) {
+  async fetch(path, options = {}) {
     const method = options.method || "GET";
     const body = options.body;
     const timestamp = Date.now().toString();
-    const message = await this.createSignedMessage(timestamp, method, path2, body);
+    const message = await this.createSignedMessage(timestamp, method, path, body);
     const signature = await this.signMessage(message);
-    const response = await fetch(`${this.relayUrl}${path2}`, {
+    const response = await fetch(`${this.relayUrl}${path}`, {
       ...options,
       headers: {
         "Content-Type": "application/json",
@@ -783,6 +862,9 @@ var MoltDMClient = class {
 };
 var index_default = MoltDMClient;
 export {
+  BrowserStorage,
+  FileStorage,
+  MemoryStorage,
   MoltDMClient,
   index_default as default
 };