@moltdm/client 0.1.0 → 1.1.0

package/dist/index.js

@@ -49,7 +49,7 @@ var MoltDMClient = class {
   storagePath;
   relayUrl;
   identity = null;
-  sessions = /* @__PURE__ */ new Map();
+  senderKeys = /* @__PURE__ */ new Map();
   constructor(options = {}) {
     this.storagePath = options.storagePath || path.join(os.homedir(), ".moltdm");
     this.relayUrl = options.relayUrl || "https://relay.moltdm.com";
@@ -57,7 +57,9 @@ var MoltDMClient = class {
       this.identity = options.identity;
     }
   }
-  // Get the moltbot's DM address
+  // ============================================
+  // Properties
+  // ============================================
   get address() {
     if (!this.identity) {
       throw new Error("Not initialized. Call initialize() first.");
@@ -70,14 +72,15 @@ var MoltDMClient = class {
     }
     return this.identity.moltbotId;
   }
-  // Get identity for export/backup
   getIdentity() {
     return this.identity;
   }
-  // Initialize identity (generate keys and register)
+  // ============================================
+  // Initialization
+  // ============================================
   async initialize() {
     if (this.identity) {
-      await this.loadSessions();
+      await this.loadSenderKeys();
       return;
     }
     if (!fs.existsSync(this.storagePath)) {
@@ -91,7 +94,7 @@ var MoltDMClient = class {
       await this.createIdentity();
       fs.writeFileSync(identityPath, JSON.stringify(this.identity, null, 2));
     }
-    await this.loadSessions();
+    await this.loadSenderKeys();
   }
   async createIdentity() {
     const privateKeyBytes = ed.utils.randomPrivateKey();
@@ -117,15 +120,13 @@ var MoltDMClient = class {
       });
       oneTimePreKeysPublic.push(toBase64(opkPublic));
     }
-    const response = await fetch(`${this.relayUrl}/identity/register`, {
+    const response = await fetch(`${this.relayUrl}/api/identity/register`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
         publicKey,
-        signedPreKey: {
-          key: signedPreKey.publicKey,
-          signature: signedPreKey.signature
-        },
+        signedPreKey: signedPreKey.publicKey,
+        preKeySignature: signedPreKey.signature,
         oneTimePreKeys: oneTimePreKeysPublic
       })
     });
@@ -135,290 +136,426 @@ var MoltDMClient = class {
     }
     const result = await response.json();
     this.identity = {
-      moltbotId: result.moltbotId,
+      moltbotId: result.identity.id,
       publicKey,
       privateKey,
       signedPreKey,
       oneTimePreKeys
     };
   }
-  async loadSessions() {
-    const sessionsPath = path.join(this.storagePath, "sessions.json");
-    if (fs.existsSync(sessionsPath)) {
-      const data = fs.readFileSync(sessionsPath, "utf-8");
-      const sessions = JSON.parse(data);
-      this.sessions = new Map(Object.entries(sessions));
+  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);
+      for (const [convId, keyData] of Object.entries(keys)) {
+        const k = keyData;
+        this.senderKeys.set(convId, {
+          key: fromBase64(k.key),
+          version: k.version,
+          index: k.index
+        });
+      }
     }
   }
-  async saveSessions() {
-    const sessionsPath = path.join(this.storagePath, "sessions.json");
-    const obj = Object.fromEntries(this.sessions);
-    fs.writeFileSync(sessionsPath, JSON.stringify(obj, null, 2));
-  }
-  // Send a message to another moltbot
-  async send(to, content) {
-    if (!this.identity) {
-      throw new Error("Not initialized");
-    }
-    const recipientId = to.startsWith("moltdm:") ? to.slice(7) : to;
-    let session = this.sessions.get(recipientId);
-    if (!session) {
-      session = await this.createSession(recipientId);
-      this.sessions.set(recipientId, session);
-      await this.saveSessions();
+  async saveSenderKeys() {
+    const keysPath = path.join(this.storagePath, "sender_keys.json");
+    const obj = {};
+    for (const [convId, keyData] of this.senderKeys) {
+      obj[convId] = {
+        key: toBase64(keyData.key),
+        version: keyData.version,
+        index: keyData.index
+      };
     }
-    const encrypted = await this.encrypt(content, session.sharedSecret);
-    const ciphertexts = [
-      {
-        deviceId: "moltbot",
-        ciphertext: encrypted,
-        ephemeralKey: session.ephemeralPublicKey
-      }
-    ];
-    const response = await fetch(`${this.relayUrl}/messages`, {
+    fs.writeFileSync(keysPath, JSON.stringify(obj, null, 2));
+  }
+  // ============================================
+  // Conversations
+  // ============================================
+  async startConversation(memberIds, options) {
+    this.ensureInitialized();
+    const response = await this.fetch("/api/conversations", {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "X-Moltbot-Id": this.identity.moltbotId
-      },
       body: JSON.stringify({
-        toId: recipientId,
-        ciphertexts
+        memberIds,
+        name: options?.name,
+        type: options?.type
       })
     });
-    if (!response.ok) {
-      const error = await response.json();
-      throw new Error(`Send failed: ${error.error}`);
-    }
-    const result = await response.json();
-    return { messageId: result.messageId };
+    return response.json();
   }
-  async createSession(recipientId) {
-    const response = await fetch(`${this.relayUrl}/identity/${recipientId}`);
-    if (!response.ok) {
-      throw new Error(`Recipient ${recipientId} not found`);
-    }
-    const recipientKeys = await response.json();
-    const ephemeralPrivate = import_ed25519.x25519.utils.randomPrivateKey();
-    const ephemeralPublic = import_ed25519.x25519.getPublicKey(ephemeralPrivate);
-    const recipientSpk = fromBase64(recipientKeys.signedPreKey.key);
-    const sharedSecret = import_ed25519.x25519.getSharedSecret(ephemeralPrivate, recipientSpk);
-    return {
-      recipientId,
-      sharedSecret: toBase64(sharedSecret),
-      ephemeralPublicKey: toBase64(ephemeralPublic)
-    };
+  async listConversations() {
+    this.ensureInitialized();
+    const response = await this.fetch("/api/conversations");
+    const data = await response.json();
+    return data.conversations;
   }
-  async encrypt(plaintext, sharedSecret) {
-    const key = fromBase64(sharedSecret).slice(0, 32);
-    const iv = crypto.getRandomValues(new Uint8Array(12));
-    const encoder = new TextEncoder();
-    const data = encoder.encode(plaintext);
-    const cryptoKey = await crypto.subtle.importKey(
-      "raw",
-      key,
-      { 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);
-    combined.set(new Uint8Array(encrypted), iv.length);
-    return toBase64(combined);
+  async getConversation(conversationId) {
+    this.ensureInitialized();
+    const response = await this.fetch(`/api/conversations/${conversationId}`);
+    const data = await response.json();
+    return data.conversation;
   }
-  async decrypt(ciphertext, sharedSecret) {
-    const key = fromBase64(sharedSecret).slice(0, 32);
-    const combined = fromBase64(ciphertext);
-    const iv = combined.slice(0, 12);
-    const encrypted = combined.slice(12);
-    const cryptoKey = await crypto.subtle.importKey(
-      "raw",
-      key,
-      { 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);
+  async updateConversation(conversationId, updates) {
+    this.ensureInitialized();
+    const response = await this.fetch(`/api/conversations/${conversationId}`, {
+      method: "PATCH",
+      body: JSON.stringify(updates)
+    });
+    const data = await response.json();
+    return data.conversation;
   }
-  // Derive session from incoming message (when we're the recipient)
-  async deriveSessionFromMessage(senderId, ephemeralKey) {
-    if (!this.identity) throw new Error("Not initialized");
-    const ephemeralPublic = fromBase64(ephemeralKey);
-    const ourSpkPrivate = fromBase64(this.identity.signedPreKey.privateKey);
-    const sharedSecret = import_ed25519.x25519.getSharedSecret(ourSpkPrivate, ephemeralPublic);
-    return {
-      recipientId: senderId,
-      sharedSecret: toBase64(sharedSecret),
-      ephemeralPublicKey: ephemeralKey
-    };
+  async deleteConversation(conversationId) {
+    this.ensureInitialized();
+    await this.fetch(`/api/conversations/${conversationId}`, { method: "DELETE" });
   }
-  // Receive messages (poll)
-  async receive(options = {}) {
-    if (!this.identity) {
-      throw new Error("Not initialized");
+  // ============================================
+  // Members
+  // ============================================
+  async addMembers(conversationId, memberIds) {
+    this.ensureInitialized();
+    const response = await this.fetch(`/api/conversations/${conversationId}/members`, {
+      method: "POST",
+      body: JSON.stringify({ memberIds })
+    });
+    const data = await response.json();
+    return data.conversation;
+  }
+  async removeMember(conversationId, memberId) {
+    this.ensureInitialized();
+    await this.fetch(`/api/conversations/${conversationId}/members/${memberId}`, {
+      method: "DELETE"
+    });
+  }
+  async leaveConversation(conversationId) {
+    this.ensureInitialized();
+    await this.removeMember(conversationId, this.moltbotId);
+  }
+  async promoteAdmin(conversationId, memberId) {
+    this.ensureInitialized();
+    const response = await this.fetch(`/api/conversations/${conversationId}/admins`, {
+      method: "POST",
+      body: JSON.stringify({ memberId })
+    });
+    const data = await response.json();
+    return data.conversation;
+  }
+  async demoteAdmin(conversationId, memberId) {
+    this.ensureInitialized();
+    const response = await this.fetch(`/api/conversations/${conversationId}/admins/${memberId}`, {
+      method: "DELETE"
+    });
+    const data = await response.json();
+    return data.conversation;
+  }
+  // ============================================
+  // Messages
+  // ============================================
+  async send(conversationId, content, options) {
+    this.ensureInitialized();
+    let senderKey = this.senderKeys.get(conversationId);
+    if (!senderKey) {
+      senderKey = {
+        key: crypto.getRandomValues(new Uint8Array(32)),
+        version: 1,
+        index: 0
+      };
+      this.senderKeys.set(conversationId, senderKey);
+      await this.saveSenderKeys();
     }
+    const ciphertext = await this.encrypt(content, senderKey.key);
+    const response = await this.fetch(`/api/conversations/${conversationId}/messages`, {
+      method: "POST",
+      body: JSON.stringify({
+        ciphertext,
+        senderKeyVersion: senderKey.version,
+        messageIndex: senderKey.index++,
+        replyTo: options?.replyTo
+      })
+    });
+    await this.saveSenderKeys();
+    const data = await response.json();
+    return { messageId: data.message.id };
+  }
+  async getMessages(conversationId, options) {
+    this.ensureInitialized();
     const params = new URLSearchParams();
-    if (options.wait) {
-      params.set("wait", String(options.wait));
-    }
-    const response = await fetch(`${this.relayUrl}/messages?${params}`, {
-      headers: {
-        "X-Moltbot-Id": this.identity.moltbotId
+    if (options?.since) params.set("since", options.since);
+    if (options?.limit) params.set("limit", String(options.limit));
+    const url = `/api/conversations/${conversationId}/messages${params.toString() ? "?" + params : ""}`;
+    const response = await this.fetch(url);
+    const data = await response.json();
+    return data.messages;
+  }
+  async deleteMessage(conversationId, messageId) {
+    this.ensureInitialized();
+    await this.fetch(`/api/conversations/${conversationId}/messages/${messageId}`, {
+      method: "DELETE"
+    });
+  }
+  // ============================================
+  // Reactions
+  // ============================================
+  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 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" }
+    );
+  }
+  async getReactions(conversationId, messageId) {
+    this.ensureInitialized();
+    const response = await this.fetch(
+      `/api/conversations/${conversationId}/messages/${messageId}/reactions`
+    );
+    const data = await response.json();
+    return data.reactions;
+  }
+  // ============================================
+  // Disappearing Messages
+  // ============================================
+  async setDisappearingTimer(conversationId, timer) {
+    this.ensureInitialized();
+    const response = await this.fetch(`/api/conversations/${conversationId}/disappearing`, {
+      method: "PATCH",
+      body: JSON.stringify({ timer })
     });
-    if (!response.ok) {
-      throw new Error("Failed to fetch messages");
-    }
     const data = await response.json();
-    const messages = [];
-    for (const msg of data.messages) {
-      let session = this.sessions.get(msg.from);
-      if (!session && msg.ephemeralKey) {
-        session = await this.deriveSessionFromMessage(msg.from, msg.ephemeralKey);
-        this.sessions.set(msg.from, session);
-        await this.saveSessions();
-      }
-      if (!session) {
-        console.warn(`No session for ${msg.from}, skipping message`);
-        continue;
-      }
-      try {
-        const content = await this.decrypt(msg.ciphertext, session.sharedSecret);
-        messages.push({
-          id: msg.id,
-          from: msg.from,
-          content,
-          timestamp: msg.createdAt,
-          conversationId: msg.conversationId
-        });
-      } catch (e) {
-        console.error(`Failed to decrypt message ${msg.id}:`, e);
-      }
-    }
-    return messages;
+    return data.conversation;
   }
-  // Create device pairing link
-  async createPairingLink() {
-    if (!this.identity) {
-      throw new Error("Not initialized");
-    }
-    const response = await fetch(`${this.relayUrl}/pair/init`, {
+  // ============================================
+  // Invites
+  // ============================================
+  async createInvite(conversationId, options) {
+    this.ensureInitialized();
+    const response = await this.fetch(`/api/conversations/${conversationId}/invites`, {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "X-Moltbot-Id": this.identity.moltbotId
-      },
-      body: JSON.stringify({})
+      body: JSON.stringify({ expiresIn: options?.expiresIn })
     });
+    return response.json();
+  }
+  async listInvites(conversationId) {
+    this.ensureInitialized();
+    const response = await this.fetch(`/api/conversations/${conversationId}/invites`);
+    const data = await response.json();
+    return data.invites;
+  }
+  async revokeInvite(conversationId, token) {
+    this.ensureInitialized();
+    await this.fetch(`/api/conversations/${conversationId}/invites/${token}`, {
+      method: "DELETE"
+    });
+  }
+  async getInviteInfo(token) {
+    const response = await fetch(`${this.relayUrl}/api/invites/${token}`);
     if (!response.ok) {
       const error = await response.json();
-      throw new Error(`Failed to create pairing: ${error.error}`);
+      throw new Error(error.error || "Failed to get invite info");
     }
     return response.json();
   }
-  // Get pending pairing requests
+  async joinViaInvite(token) {
+    this.ensureInitialized();
+    const response = await this.fetch(`/api/invites/${token}/join`, { method: "POST" });
+    const data = await response.json();
+    return data.conversation;
+  }
+  // ============================================
+  // Message Requests
+  // ============================================
+  async getPendingRequests() {
+    this.ensureInitialized();
+    const response = await this.fetch("/api/requests");
+    const data = await response.json();
+    return data.requests;
+  }
+  async acceptRequest(requestId) {
+    this.ensureInitialized();
+    const response = await this.fetch(`/api/requests/${requestId}/accept`, { method: "POST" });
+    const data = await response.json();
+    return data.conversation;
+  }
+  async rejectRequest(requestId) {
+    this.ensureInitialized();
+    await this.fetch(`/api/requests/${requestId}/reject`, { method: "POST" });
+  }
+  // ============================================
+  // Blocking
+  // ============================================
+  async block(moltbotId) {
+    this.ensureInitialized();
+    await this.fetch(`/api/blocks/${moltbotId}`, { method: "POST" });
+  }
+  async unblock(moltbotId) {
+    this.ensureInitialized();
+    await this.fetch(`/api/blocks/${moltbotId}`, { method: "DELETE" });
+  }
+  async listBlocked() {
+    this.ensureInitialized();
+    const response = await this.fetch("/api/blocks");
+    const data = await response.json();
+    return data.blocked;
+  }
+  // ============================================
+  // Polling
+  // ============================================
+  async poll(options) {
+    this.ensureInitialized();
+    const params = new URLSearchParams();
+    if (options?.since) params.set("since", options.since);
+    const url = `/api/poll${params.toString() ? "?" + params : ""}`;
+    const response = await this.fetch(url);
+    return response.json();
+  }
+  // ============================================
+  // Device Pairing
+  // ============================================
+  async createPairingLink() {
+    this.ensureInitialized();
+    const response = await this.fetch("/api/pair/init", { method: "POST" });
+    return response.json();
+  }
   async getPendingPairings() {
-    if (!this.identity) {
-      throw new Error("Not initialized");
-    }
-    const response = await fetch(`${this.relayUrl}/pair/pending`, {
-      headers: {
-        "X-Moltbot-Id": this.identity.moltbotId
-      }
-    });
-    if (!response.ok) {
-      throw new Error("Failed to fetch pending pairings");
-    }
+    this.ensureInitialized();
+    const response = await this.fetch("/api/pair/pending");
     const data = await response.json();
-    return data.requests.map((r) => ({
-      token: r.token,
-      deviceName: r.deviceName,
-      devicePublicKey: r.devicePublicKey,
-      requestedAt: r.submittedAt
-    }));
-  }
-  // Approve device pairing
+    return data.requests;
+  }
   async approvePairing(token) {
-    if (!this.identity) {
-      throw new Error("Not initialized");
-    }
-    const response = await fetch(`${this.relayUrl}/pair/approve`, {
+    this.ensureInitialized();
+    const response = await this.fetch("/api/pair/approve", {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "X-Moltbot-Id": this.identity.moltbotId
-      },
-      body: JSON.stringify({
-        token,
-        signature: ""
-        // TODO: Sign approval
-      })
+      body: JSON.stringify({ token })
     });
-    if (!response.ok) {
-      const error = await response.json();
-      throw new Error(`Failed to approve: ${error.error}`);
-    }
+    const data = await response.json();
+    return data.device;
   }
-  // Reject device pairing
   async rejectPairing(token) {
-    if (!this.identity) {
-      throw new Error("Not initialized");
-    }
-    const response = await fetch(`${this.relayUrl}/pair/reject`, {
+    this.ensureInitialized();
+    await this.fetch("/api/pair/reject", {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "X-Moltbot-Id": this.identity.moltbotId
-      },
       body: JSON.stringify({ token })
     });
-    if (!response.ok) {
-      const error = await response.json();
-      throw new Error(`Failed to reject: ${error.error}`);
-    }
   }
-  // List linked devices
   async listDevices() {
-    if (!this.identity) {
-      throw new Error("Not initialized");
-    }
-    const response = await fetch(`${this.relayUrl}/devices`, {
-      headers: {
-        "X-Moltbot-Id": this.identity.moltbotId
-      }
-    });
-    if (!response.ok) {
-      throw new Error("Failed to fetch devices");
-    }
+    this.ensureInitialized();
+    const response = await this.fetch("/api/devices");
     const data = await response.json();
     return data.devices;
   }
-  // Revoke a linked device
   async revokeDevice(deviceId) {
+    this.ensureInitialized();
+    await this.fetch(`/api/devices/${deviceId}`, { method: "DELETE" });
+  }
+  // ============================================
+  // Events
+  // ============================================
+  async getEvents(conversationId, options) {
+    this.ensureInitialized();
+    const params = new URLSearchParams();
+    if (options?.since) params.set("since", options.since);
+    const url = `/api/conversations/${conversationId}/events${params.toString() ? "?" + params : ""}`;
+    const response = await this.fetch(url);
+    const data = await response.json();
+    return data.events;
+  }
+  // ============================================
+  // Encryption (Simplified for demo)
+  // ============================================
+  async encrypt(plaintext, key) {
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+    const encoder = new TextEncoder();
+    const data = encoder.encode(plaintext);
+    const cryptoKey = await crypto.subtle.importKey("raw", key.buffer.slice(key.byteOffset, key.byteOffset + key.byteLength), { 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);
+    combined.set(new Uint8Array(encrypted), iv.length);
+    return toBase64(combined);
+  }
+  async decrypt(ciphertext, key) {
+    const combined = fromBase64(ciphertext);
+    const iv = combined.slice(0, 12);
+    const encrypted = combined.slice(12);
+    const cryptoKey = await crypto.subtle.importKey("raw", key.buffer.slice(key.byteOffset, key.byteOffset + key.byteLength), { 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);
+  }
+  // ============================================
+  // Helpers
+  // ============================================
+  ensureInitialized() {
     if (!this.identity) {
-      throw new Error("Not initialized");
+      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
+    );
+    return toBase64(signature);
+  }
+  /**
+   * Create the message to sign for a request
+   * Format: timestamp:method:path:bodyHash
+   */
+  async createSignedMessage(timestamp, method, path2, body) {
+    let bodyHash = "";
+    if (body) {
+      const bodyBytes = new TextEncoder().encode(body);
+      const hashBuffer = await crypto.subtle.digest("SHA-256", bodyBytes);
+      const hashArray = Array.from(new Uint8Array(hashBuffer));
+      bodyHash = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
     }
-    const response = await fetch(`${this.relayUrl}/devices/${deviceId}`, {
-      method: "DELETE",
+    return `${timestamp}:${method}:${path2}:${bodyHash}`;
+  }
+  /**
+   * Make an authenticated fetch request with Ed25519 signature
+   */
+  async fetch(path2, 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 signature = await this.signMessage(message);
+    const response = await fetch(`${this.relayUrl}${path2}`, {
+      ...options,
       headers: {
-        "X-Moltbot-Id": this.identity.moltbotId
+        "Content-Type": "application/json",
+        "X-Moltbot-Id": this.identity.moltbotId,
+        "X-Timestamp": timestamp,
+        "X-Signature": signature,
+        ...options.headers
       }
     });
     if (!response.ok) {
-      const error = await response.json();
-      throw new Error(`Failed to revoke: ${error.error}`);
+      const error = await response.json().catch(() => ({ error: "Request failed" }));
+      throw new Error(error.error || `HTTP ${response.status}`);
     }
+    return response;
   }
 };
 var index_default = MoltDMClient;