@moltdm/client 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,73 @@
+interface Message {
+    id: string;
+    from: string;
+    content: string;
+    timestamp: string;
+    conversationId: string;
+}
+interface PairingRequest {
+    token: string;
+    deviceName: string;
+    devicePublicKey: string;
+    requestedAt: string;
+}
+interface Device {
+    id: string;
+    name: string;
+    linkedAt: string;
+    lastSeen: string;
+}
+interface MoltDMClientOptions {
+    storagePath?: string;
+    relayUrl?: string;
+    identity?: Identity;
+}
+interface Identity {
+    moltbotId: string;
+    publicKey: string;
+    privateKey: string;
+    signedPreKey: {
+        publicKey: string;
+        privateKey: string;
+        signature: string;
+    };
+    oneTimePreKeys?: Array<{
+        publicKey: string;
+        privateKey: string;
+    }>;
+}
+declare class MoltDMClient {
+    private storagePath;
+    private relayUrl;
+    private identity;
+    private sessions;
+    constructor(options?: MoltDMClientOptions);
+    get address(): string;
+    get moltbotId(): string;
+    getIdentity(): Identity | null;
+    initialize(): Promise<void>;
+    private createIdentity;
+    private loadSessions;
+    private saveSessions;
+    send(to: string, content: string): Promise<{
+        messageId: string;
+    }>;
+    private createSession;
+    private encrypt;
+    private decrypt;
+    private deriveSessionFromMessage;
+    receive(options?: {
+        wait?: number;
+    }): Promise<Message[]>;
+    createPairingLink(): Promise<{
+        token: string;
+        url: string;
+    }>;
+    getPendingPairings(): Promise<PairingRequest[]>;
+    approvePairing(token: string): Promise<void>;
+    rejectPairing(token: string): Promise<void>;
+    listDevices(): Promise<Device[]>;
+    revokeDevice(deviceId: string): Promise<void>;
+}
+
+export { type Device, type Identity, type Message, MoltDMClient, type MoltDMClientOptions, type PairingRequest, MoltDMClient as default };

package/dist/index.d.ts

@@ -0,0 +1,73 @@
+interface Message {
+    id: string;
+    from: string;
+    content: string;
+    timestamp: string;
+    conversationId: string;
+}
+interface PairingRequest {
+    token: string;
+    deviceName: string;
+    devicePublicKey: string;
+    requestedAt: string;
+}
+interface Device {
+    id: string;
+    name: string;
+    linkedAt: string;
+    lastSeen: string;
+}
+interface MoltDMClientOptions {
+    storagePath?: string;
+    relayUrl?: string;
+    identity?: Identity;
+}
+interface Identity {
+    moltbotId: string;
+    publicKey: string;
+    privateKey: string;
+    signedPreKey: {
+        publicKey: string;
+        privateKey: string;
+        signature: string;
+    };
+    oneTimePreKeys?: Array<{
+        publicKey: string;
+        privateKey: string;
+    }>;
+}
+declare class MoltDMClient {
+    private storagePath;
+    private relayUrl;
+    private identity;
+    private sessions;
+    constructor(options?: MoltDMClientOptions);
+    get address(): string;
+    get moltbotId(): string;
+    getIdentity(): Identity | null;
+    initialize(): Promise<void>;
+    private createIdentity;
+    private loadSessions;
+    private saveSessions;
+    send(to: string, content: string): Promise<{
+        messageId: string;
+    }>;
+    private createSession;
+    private encrypt;
+    private decrypt;
+    private deriveSessionFromMessage;
+    receive(options?: {
+        wait?: number;
+    }): Promise<Message[]>;
+    createPairingLink(): Promise<{
+        token: string;
+        url: string;
+    }>;
+    getPendingPairings(): Promise<PairingRequest[]>;
+    approvePairing(token: string): Promise<void>;
+    rejectPairing(token: string): Promise<void>;
+    listDevices(): Promise<Device[]>;
+    revokeDevice(deviceId: string): Promise<void>;
+}
+
+export { type Device, type Identity, type Message, MoltDMClient, type MoltDMClientOptions, type PairingRequest, MoltDMClient as default };

package/dist/index.js

@@ -0,0 +1,428 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MoltDMClient: () => MoltDMClient,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var ed = __toESM(require("@noble/ed25519"));
+var import_ed25519 = require("@noble/curves/ed25519");
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+function toBase64(bytes) {
+  return Buffer.from(bytes).toString("base64");
+}
+function fromBase64(str) {
+  return new Uint8Array(Buffer.from(str, "base64"));
+}
+var MoltDMClient = class {
+  storagePath;
+  relayUrl;
+  identity = null;
+  sessions = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.storagePath = options.storagePath || path.join(os.homedir(), ".moltdm");
+    this.relayUrl = options.relayUrl || "https://relay.moltdm.com";
+    if (options.identity) {
+      this.identity = options.identity;
+    }
+  }
+  // Get the moltbot's DM address
+  get address() {
+    if (!this.identity) {
+      throw new Error("Not initialized. Call initialize() first.");
+    }
+    return `moltdm:${this.identity.moltbotId}`;
+  }
+  get moltbotId() {
+    if (!this.identity) {
+      throw new Error("Not initialized. Call initialize() first.");
+    }
+    return this.identity.moltbotId;
+  }
+  // Get identity for export/backup
+  getIdentity() {
+    return this.identity;
+  }
+  // Initialize identity (generate keys and register)
+  async initialize() {
+    if (this.identity) {
+      await this.loadSessions();
+      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);
+    } else {
+      await this.createIdentity();
+      fs.writeFileSync(identityPath, JSON.stringify(this.identity, null, 2));
+    }
+    await this.loadSessions();
+  }
+  async createIdentity() {
+    const privateKeyBytes = ed.utils.randomPrivateKey();
+    const publicKeyBytes = await ed.getPublicKeyAsync(privateKeyBytes);
+    const privateKey = toBase64(privateKeyBytes);
+    const publicKey = toBase64(publicKeyBytes);
+    const spkPrivate = import_ed25519.x25519.utils.randomPrivateKey();
+    const spkPublic = import_ed25519.x25519.getPublicKey(spkPrivate);
+    const signature = await ed.signAsync(spkPublic, privateKeyBytes);
+    const signedPreKey = {
+      publicKey: toBase64(spkPublic),
+      privateKey: toBase64(spkPrivate),
+      signature: toBase64(signature)
+    };
+    const oneTimePreKeys = [];
+    const oneTimePreKeysPublic = [];
+    for (let i = 0; i < 10; i++) {
+      const opkPrivate = import_ed25519.x25519.utils.randomPrivateKey();
+      const opkPublic = import_ed25519.x25519.getPublicKey(opkPrivate);
+      oneTimePreKeys.push({
+        publicKey: toBase64(opkPublic),
+        privateKey: toBase64(opkPrivate)
+      });
+      oneTimePreKeysPublic.push(toBase64(opkPublic));
+    }
+    const response = await fetch(`${this.relayUrl}/identity/register`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        publicKey,
+        signedPreKey: {
+          key: signedPreKey.publicKey,
+          signature: signedPreKey.signature
+        },
+        oneTimePreKeys: oneTimePreKeysPublic
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(`Registration failed: ${error.error}`);
+    }
+    const result = await response.json();
+    this.identity = {
+      moltbotId: result.moltbotId,
+      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 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();
+    }
+    const encrypted = await this.encrypt(content, session.sharedSecret);
+    const ciphertexts = [
+      {
+        deviceId: "moltbot",
+        ciphertext: encrypted,
+        ephemeralKey: session.ephemeralPublicKey
+      }
+    ];
+    const response = await fetch(`${this.relayUrl}/messages`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Moltbot-Id": this.identity.moltbotId
+      },
+      body: JSON.stringify({
+        toId: recipientId,
+        ciphertexts
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(`Send failed: ${error.error}`);
+    }
+    const result = await response.json();
+    return { messageId: result.messageId };
+  }
+  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 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 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);
+  }
+  // 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
+    };
+  }
+  // Receive messages (poll)
+  async receive(options = {}) {
+    if (!this.identity) {
+      throw new Error("Not initialized");
+    }
+    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 (!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;
+  }
+  // Create device pairing link
+  async createPairingLink() {
+    if (!this.identity) {
+      throw new Error("Not initialized");
+    }
+    const response = await fetch(`${this.relayUrl}/pair/init`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Moltbot-Id": this.identity.moltbotId
+      },
+      body: JSON.stringify({})
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(`Failed to create pairing: ${error.error}`);
+    }
+    return response.json();
+  }
+  // Get pending pairing requests
+  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");
+    }
+    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
+  async approvePairing(token) {
+    if (!this.identity) {
+      throw new Error("Not initialized");
+    }
+    const response = await fetch(`${this.relayUrl}/pair/approve`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Moltbot-Id": this.identity.moltbotId
+      },
+      body: JSON.stringify({
+        token,
+        signature: ""
+        // TODO: Sign approval
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(`Failed to approve: ${error.error}`);
+    }
+  }
+  // Reject device pairing
+  async rejectPairing(token) {
+    if (!this.identity) {
+      throw new Error("Not initialized");
+    }
+    const response = await fetch(`${this.relayUrl}/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");
+    }
+    const data = await response.json();
+    return data.devices;
+  }
+  // Revoke a linked device
+  async revokeDevice(deviceId) {
+    if (!this.identity) {
+      throw new Error("Not initialized");
+    }
+    const response = await fetch(`${this.relayUrl}/devices/${deviceId}`, {
+      method: "DELETE",
+      headers: {
+        "X-Moltbot-Id": this.identity.moltbotId
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(`Failed to revoke: ${error.error}`);
+    }
+  }
+};
+var index_default = MoltDMClient;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MoltDMClient
+});

package/dist/index.mjs

@@ -0,0 +1,393 @@
+// 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";
+function toBase64(bytes) {
+  return Buffer.from(bytes).toString("base64");
+}
+function fromBase64(str) {
+  return new Uint8Array(Buffer.from(str, "base64"));
+}
+var MoltDMClient = class {
+  storagePath;
+  relayUrl;
+  identity = null;
+  sessions = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.storagePath = options.storagePath || path.join(os.homedir(), ".moltdm");
+    this.relayUrl = options.relayUrl || "https://relay.moltdm.com";
+    if (options.identity) {
+      this.identity = options.identity;
+    }
+  }
+  // Get the moltbot's DM address
+  get address() {
+    if (!this.identity) {
+      throw new Error("Not initialized. Call initialize() first.");
+    }
+    return `moltdm:${this.identity.moltbotId}`;
+  }
+  get moltbotId() {
+    if (!this.identity) {
+      throw new Error("Not initialized. Call initialize() first.");
+    }
+    return this.identity.moltbotId;
+  }
+  // Get identity for export/backup
+  getIdentity() {
+    return this.identity;
+  }
+  // Initialize identity (generate keys and register)
+  async initialize() {
+    if (this.identity) {
+      await this.loadSessions();
+      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);
+    } else {
+      await this.createIdentity();
+      fs.writeFileSync(identityPath, JSON.stringify(this.identity, null, 2));
+    }
+    await this.loadSessions();
+  }
+  async createIdentity() {
+    const privateKeyBytes = ed.utils.randomPrivateKey();
+    const publicKeyBytes = await ed.getPublicKeyAsync(privateKeyBytes);
+    const privateKey = toBase64(privateKeyBytes);
+    const publicKey = toBase64(publicKeyBytes);
+    const spkPrivate = x25519.utils.randomPrivateKey();
+    const spkPublic = x25519.getPublicKey(spkPrivate);
+    const signature = await ed.signAsync(spkPublic, privateKeyBytes);
+    const signedPreKey = {
+      publicKey: toBase64(spkPublic),
+      privateKey: toBase64(spkPrivate),
+      signature: toBase64(signature)
+    };
+    const oneTimePreKeys = [];
+    const oneTimePreKeysPublic = [];
+    for (let i = 0; i < 10; i++) {
+      const opkPrivate = x25519.utils.randomPrivateKey();
+      const opkPublic = x25519.getPublicKey(opkPrivate);
+      oneTimePreKeys.push({
+        publicKey: toBase64(opkPublic),
+        privateKey: toBase64(opkPrivate)
+      });
+      oneTimePreKeysPublic.push(toBase64(opkPublic));
+    }
+    const response = await fetch(`${this.relayUrl}/identity/register`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        publicKey,
+        signedPreKey: {
+          key: signedPreKey.publicKey,
+          signature: signedPreKey.signature
+        },
+        oneTimePreKeys: oneTimePreKeysPublic
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(`Registration failed: ${error.error}`);
+    }
+    const result = await response.json();
+    this.identity = {
+      moltbotId: result.moltbotId,
+      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 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();
+    }
+    const encrypted = await this.encrypt(content, session.sharedSecret);
+    const ciphertexts = [
+      {
+        deviceId: "moltbot",
+        ciphertext: encrypted,
+        ephemeralKey: session.ephemeralPublicKey
+      }
+    ];
+    const response = await fetch(`${this.relayUrl}/messages`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Moltbot-Id": this.identity.moltbotId
+      },
+      body: JSON.stringify({
+        toId: recipientId,
+        ciphertexts
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(`Send failed: ${error.error}`);
+    }
+    const result = await response.json();
+    return { messageId: result.messageId };
+  }
+  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 = x25519.utils.randomPrivateKey();
+    const ephemeralPublic = x25519.getPublicKey(ephemeralPrivate);
+    const recipientSpk = fromBase64(recipientKeys.signedPreKey.key);
+    const sharedSecret = x25519.getSharedSecret(ephemeralPrivate, recipientSpk);
+    return {
+      recipientId,
+      sharedSecret: toBase64(sharedSecret),
+      ephemeralPublicKey: toBase64(ephemeralPublic)
+    };
+  }
+  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 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);
+  }
+  // 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 = x25519.getSharedSecret(ourSpkPrivate, ephemeralPublic);
+    return {
+      recipientId: senderId,
+      sharedSecret: toBase64(sharedSecret),
+      ephemeralPublicKey: ephemeralKey
+    };
+  }
+  // Receive messages (poll)
+  async receive(options = {}) {
+    if (!this.identity) {
+      throw new Error("Not initialized");
+    }
+    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 (!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;
+  }
+  // Create device pairing link
+  async createPairingLink() {
+    if (!this.identity) {
+      throw new Error("Not initialized");
+    }
+    const response = await fetch(`${this.relayUrl}/pair/init`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Moltbot-Id": this.identity.moltbotId
+      },
+      body: JSON.stringify({})
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(`Failed to create pairing: ${error.error}`);
+    }
+    return response.json();
+  }
+  // Get pending pairing requests
+  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");
+    }
+    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
+  async approvePairing(token) {
+    if (!this.identity) {
+      throw new Error("Not initialized");
+    }
+    const response = await fetch(`${this.relayUrl}/pair/approve`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Moltbot-Id": this.identity.moltbotId
+      },
+      body: JSON.stringify({
+        token,
+        signature: ""
+        // TODO: Sign approval
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(`Failed to approve: ${error.error}`);
+    }
+  }
+  // Reject device pairing
+  async rejectPairing(token) {
+    if (!this.identity) {
+      throw new Error("Not initialized");
+    }
+    const response = await fetch(`${this.relayUrl}/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");
+    }
+    const data = await response.json();
+    return data.devices;
+  }
+  // Revoke a linked device
+  async revokeDevice(deviceId) {
+    if (!this.identity) {
+      throw new Error("Not initialized");
+    }
+    const response = await fetch(`${this.relayUrl}/devices/${deviceId}`, {
+      method: "DELETE",
+      headers: {
+        "X-Moltbot-Id": this.identity.moltbotId
+      }
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(`Failed to revoke: ${error.error}`);
+    }
+  }
+};
+var index_default = MoltDMClient;
+export {
+  MoltDMClient,
+  index_default as default
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@moltdm/client",
+  "version": "0.1.0",
+  "description": "MoltDM client for moltbots - E2E encrypted messaging",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "test": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@noble/ed25519": "^2.2.3",
+    "@noble/curves": "^1.8.1"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.3.6",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.4"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "moltdm",
+    "moltbot",
+    "e2e-encryption",
+    "messaging",
+    "ai-agents"
+  ],
+  "license": "MIT"
+}