chatly-sdk 0.0.1

package/dist/index.js

@@ -0,0 +1,443 @@
+// src/crypto/e2e.ts
+import { createECDH as createECDH2, createCipheriv, createDecipheriv, randomBytes as randomBytes2, pbkdf2Sync } from "crypto";
+
+// src/crypto/utils.ts
+function bufferToBase64(buffer) {
+  return buffer.toString("base64");
+}
+function base64ToBuffer(data) {
+  return Buffer.from(data, "base64");
+}
+
+// src/crypto/keys.ts
+import { createECDH } from "crypto";
+var SUPPORTED_CURVE = "prime256v1";
+function generateIdentityKeyPair() {
+  const ecdh = createECDH(SUPPORTED_CURVE);
+  ecdh.generateKeys();
+  return {
+    publicKey: bufferToBase64(ecdh.getPublicKey()),
+    privateKey: bufferToBase64(ecdh.getPrivateKey())
+  };
+}
+
+// src/crypto/e2e.ts
+import { createHash } from "crypto";
+var ALGORITHM = "aes-256-gcm";
+var IV_LENGTH = 12;
+var SALT_LENGTH = 16;
+var KEY_LENGTH = 32;
+var TAG_LENGTH = 16;
+var PBKDF2_ITERATIONS = 1e5;
+function deriveSharedSecret(local, remotePublicKey) {
+  const ecdh = createECDH2(SUPPORTED_CURVE);
+  ecdh.setPrivateKey(base64ToBuffer(local.privateKey));
+  const remotePublicKeyBuffer = base64ToBuffer(remotePublicKey);
+  const sharedSecret = ecdh.computeSecret(remotePublicKeyBuffer);
+  const a = base64ToBuffer(local.publicKey);
+  const b = base64ToBuffer(remotePublicKey);
+  const [first, second] = Buffer.compare(a, b) <= 0 ? [a, b] : [b, a];
+  const hash = createHash("sha256").update(first).update(second).digest();
+  const salt = hash.slice(0, SALT_LENGTH);
+  const derivedKey = pbkdf2Sync(sharedSecret, salt, PBKDF2_ITERATIONS, KEY_LENGTH, "sha256");
+  return derivedKey;
+}
+function encryptMessage(plaintext, secret) {
+  const iv = randomBytes2(IV_LENGTH);
+  const cipher = createCipheriv(ALGORITHM, secret, iv);
+  let ciphertext = cipher.update(plaintext, "utf8");
+  ciphertext = Buffer.concat([ciphertext, cipher.final()]);
+  const tag = cipher.getAuthTag();
+  const encrypted = Buffer.concat([ciphertext, tag]);
+  return {
+    ciphertext: bufferToBase64(encrypted),
+    iv: bufferToBase64(iv)
+  };
+}
+function decryptMessage(ciphertext, iv, secret) {
+  const encryptedBuffer = base64ToBuffer(ciphertext);
+  const ivBuffer = base64ToBuffer(iv);
+  const tag = encryptedBuffer.slice(-TAG_LENGTH);
+  const actualCiphertext = encryptedBuffer.slice(0, -TAG_LENGTH);
+  const decipher = createDecipheriv(ALGORITHM, secret, ivBuffer);
+  decipher.setAuthTag(tag);
+  let decrypted = decipher.update(actualCiphertext);
+  decrypted = Buffer.concat([decrypted, decipher.final()]);
+  return decrypted.toString("utf8");
+}
+
+// src/crypto/uuid.ts
+function generateUUID() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return [
+      hex.slice(0, 8),
+      hex.slice(8, 12),
+      hex.slice(12, 16),
+      hex.slice(16, 20),
+      hex.slice(20, 32)
+    ].join("-");
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+
+// src/chat/ChatSession.ts
+var ChatSession = class {
+  constructor(id, userA, userB) {
+    this.id = id;
+    this.userA = userA;
+    this.userB = userB;
+  }
+  sharedSecret = null;
+  ephemeralKeyPair = null;
+  /**
+   * Initialize the session by deriving the shared secret
+   * ECDH is commutative, so we can use either user's keys
+   */
+  async initialize() {
+    const localKeyPair = {
+      publicKey: this.userA.publicKey,
+      privateKey: this.userA.privateKey
+    };
+    this.sharedSecret = deriveSharedSecret(localKeyPair, this.userB.publicKey);
+  }
+  /**
+   * Initialize from a specific user's perspective (useful when decrypting)
+   */
+  async initializeForUser(user) {
+    const otherUser = user.id === this.userA.id ? this.userB : this.userA;
+    const localKeyPair = {
+      publicKey: user.publicKey,
+      privateKey: user.privateKey
+    };
+    this.sharedSecret = deriveSharedSecret(localKeyPair, otherUser.publicKey);
+  }
+  /**
+   * Encrypt a message for this session
+   */
+  async encrypt(plaintext, senderId) {
+    if (!this.sharedSecret) {
+      await this.initialize();
+    }
+    if (!this.sharedSecret) {
+      throw new Error("Failed to initialize session");
+    }
+    const { ciphertext, iv } = encryptMessage(plaintext, this.sharedSecret);
+    return {
+      id: generateUUID(),
+      senderId,
+      receiverId: senderId === this.userA.id ? this.userB.id : this.userA.id,
+      ciphertext,
+      iv,
+      timestamp: Date.now(),
+      type: "text"
+    };
+  }
+  /**
+   * Decrypt a message in this session
+   */
+  async decrypt(message, user) {
+    if (!this.sharedSecret || user.id !== this.userA.id && user.id !== this.userB.id) {
+      await this.initializeForUser(user);
+    }
+    if (!this.sharedSecret) {
+      throw new Error("Failed to initialize session");
+    }
+    return decryptMessage(message.ciphertext, message.iv, this.sharedSecret);
+  }
+};
+
+// src/crypto/group.ts
+import { pbkdf2Sync as pbkdf2Sync2 } from "crypto";
+var KEY_LENGTH2 = 32;
+var PBKDF2_ITERATIONS2 = 1e5;
+function deriveGroupKey(groupId) {
+  const salt = Buffer.from(groupId, "utf8");
+  const key = pbkdf2Sync2(groupId, salt, PBKDF2_ITERATIONS2, KEY_LENGTH2, "sha256");
+  return {
+    groupId,
+    key: bufferToBase64(key)
+  };
+}
+
+// src/chat/GroupSession.ts
+var GroupSession = class {
+  constructor(group) {
+    this.group = group;
+  }
+  groupKey = null;
+  /**
+   * Initialize the session by deriving the group key
+   */
+  async initialize() {
+    const groupKeyData = deriveGroupKey(this.group.id);
+    this.groupKey = base64ToBuffer(groupKeyData.key);
+  }
+  /**
+   * Encrypt a message for this group
+   */
+  async encrypt(plaintext, senderId) {
+    if (!this.groupKey) {
+      await this.initialize();
+    }
+    if (!this.groupKey) {
+      throw new Error("Failed to initialize group session");
+    }
+    const { ciphertext, iv } = encryptMessage(plaintext, this.groupKey);
+    return {
+      id: generateUUID(),
+      senderId,
+      groupId: this.group.id,
+      ciphertext,
+      iv,
+      timestamp: Date.now(),
+      type: "text"
+    };
+  }
+  /**
+   * Decrypt a message in this group
+   */
+  async decrypt(message) {
+    if (!this.groupKey) {
+      await this.initialize();
+    }
+    if (!this.groupKey) {
+      throw new Error("Failed to initialize group session");
+    }
+    return decryptMessage(message.ciphertext, message.iv, this.groupKey);
+  }
+};
+
+// src/stores/memory/userStore.ts
+var InMemoryUserStore = class {
+  users = /* @__PURE__ */ new Map();
+  async create(user) {
+    const stored = { ...user, createdAt: Date.now() };
+    this.users.set(stored.id, stored);
+    return stored;
+  }
+  async findById(id) {
+    return this.users.get(id);
+  }
+  async save(user) {
+    this.users.set(user.id, user);
+  }
+  async list() {
+    return Array.from(this.users.values());
+  }
+};
+
+// src/stores/memory/messageStore.ts
+var InMemoryMessageStore = class {
+  messages = [];
+  async create(message) {
+    this.messages.push(message);
+    return message;
+  }
+  async listByUser(userId) {
+    return this.messages.filter(
+      (msg) => msg.senderId === userId || msg.receiverId === userId
+    );
+  }
+  async listByGroup(groupId) {
+    return this.messages.filter((msg) => msg.groupId === groupId);
+  }
+};
+
+// src/stores/memory/groupStore.ts
+var InMemoryGroupStore = class {
+  groups = /* @__PURE__ */ new Map();
+  async create(group) {
+    this.groups.set(group.id, group);
+    return group;
+  }
+  async findById(id) {
+    return this.groups.get(id);
+  }
+  async list() {
+    return Array.from(this.groups.values());
+  }
+};
+
+// src/transport/memoryTransport.ts
+var InMemoryTransport = class {
+  handler;
+  connected = false;
+  async connect(_userId) {
+    this.connected = true;
+  }
+  async send(message) {
+    if (!this.connected) {
+      throw new Error("Transport not connected");
+    }
+    this.handler?.(message);
+  }
+  onMessage(handler) {
+    this.handler = handler;
+  }
+};
+
+// src/index.ts
+var ChatSDK = class {
+  config;
+  currentUser = null;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Create a new user with generated identity keys
+   */
+  async createUser(username) {
+    const keyPair = generateIdentityKeyPair();
+    const user = {
+      id: generateUUID(),
+      username,
+      identityKey: keyPair.publicKey,
+      publicKey: keyPair.publicKey,
+      privateKey: keyPair.privateKey
+    };
+    await this.config.userStore.create(user);
+    return user;
+  }
+  /**
+   * Import an existing user from stored data
+   */
+  async importUser(userData) {
+    await this.config.userStore.save(userData);
+    return userData;
+  }
+  /**
+   * Set the current active user
+   */
+  setCurrentUser(user) {
+    this.currentUser = user;
+    if (this.config.transport) {
+      this.config.transport.connect(user.id);
+    }
+  }
+  /**
+   * Get the current active user
+   */
+  getCurrentUser() {
+    return this.currentUser;
+  }
+  /**
+   * Start a 1:1 chat session between two users
+   */
+  async startSession(userA, userB) {
+    const ids = [userA.id, userB.id].sort();
+    const sessionId = `${ids[0]}-${ids[1]}`;
+    const session = new ChatSession(sessionId, userA, userB);
+    await session.initialize();
+    return session;
+  }
+  /**
+   * Create a new group with members
+   */
+  async createGroup(name, members) {
+    if (members.length < 2) {
+      throw new Error("Group must have at least 2 members");
+    }
+    const group = {
+      id: generateUUID(),
+      name,
+      members,
+      createdAt: Date.now()
+    };
+    await this.config.groupStore.create(group);
+    const session = new GroupSession(group);
+    await session.initialize();
+    return session;
+  }
+  /**
+   * Load an existing group by ID
+   */
+  async loadGroup(id) {
+    const group = await this.config.groupStore.findById(id);
+    if (!group) {
+      throw new Error(`Group not found: ${id}`);
+    }
+    const session = new GroupSession(group);
+    await session.initialize();
+    return session;
+  }
+  /**
+   * Send a message in a chat session (1:1 or group)
+   */
+  async sendMessage(session, plaintext) {
+    if (!this.currentUser) {
+      throw new Error("No current user set. Call setCurrentUser() first.");
+    }
+    let message;
+    if (session instanceof ChatSession) {
+      message = await session.encrypt(plaintext, this.currentUser.id);
+    } else {
+      message = await session.encrypt(plaintext, this.currentUser.id);
+    }
+    await this.config.messageStore.create(message);
+    if (this.config.transport) {
+      await this.config.transport.send(message);
+    }
+    return message;
+  }
+  /**
+   * Decrypt a message
+   */
+  async decryptMessage(message, user) {
+    if (message.groupId) {
+      const group = await this.config.groupStore.findById(message.groupId);
+      if (!group) {
+        throw new Error(`Group not found: ${message.groupId}`);
+      }
+      const session = new GroupSession(group);
+      await session.initialize();
+      return await session.decrypt(message);
+    } else {
+      const otherUserId = message.senderId === user.id ? message.receiverId : message.senderId;
+      if (!otherUserId) {
+        throw new Error("Invalid message: missing receiver/sender");
+      }
+      const otherUser = await this.config.userStore.findById(otherUserId);
+      if (!otherUser) {
+        throw new Error(`User not found: ${otherUserId}`);
+      }
+      const ids = [user.id, otherUser.id].sort();
+      const sessionId = `${ids[0]}-${ids[1]}`;
+      const session = new ChatSession(sessionId, user, otherUser);
+      await session.initializeForUser(user);
+      return await session.decrypt(message, user);
+    }
+  }
+  /**
+   * Get messages for a user
+   */
+  async getMessagesForUser(userId) {
+    return await this.config.messageStore.listByUser(userId);
+  }
+  /**
+   * Get messages for a group
+   */
+  async getMessagesForGroup(groupId) {
+    return await this.config.messageStore.listByGroup(groupId);
+  }
+};
+export {
+  ChatSDK,
+  ChatSession,
+  GroupSession,
+  InMemoryGroupStore,
+  InMemoryMessageStore,
+  InMemoryTransport,
+  InMemoryUserStore
+};

package/examples/groupChat.ts

@@ -0,0 +1,71 @@
+import { ChatSDK } from "../src/index.js";
+import {
+  InMemoryUserStore,
+  InMemoryMessageStore,
+  InMemoryGroupStore,
+} from "../src/index.js";
+import { InMemoryTransport } from "../src/index.js";
+
+/**
+ * Example: Group Chat with multiple members
+ */
+async function main() {
+  // Initialize SDK
+  const sdk = new ChatSDK({
+    userStore: new InMemoryUserStore(),
+    messageStore: new InMemoryMessageStore(),
+    groupStore: new InMemoryGroupStore(),
+    transport: new InMemoryTransport(),
+  });
+
+  // Create users
+  console.log("Creating users...");
+  const alice = await sdk.createUser("alice");
+  const bob = await sdk.createUser("bob");
+  const charlie = await sdk.createUser("charlie");
+
+  console.log(`Alice: ${alice.id}`);
+  console.log(`Bob: ${bob.id}`);
+  console.log(`Charlie: ${charlie.id}`);
+
+  // Create a group
+  console.log("\nCreating group...");
+  const group = await sdk.createGroup("Project Team", [alice, bob, charlie]);
+  console.log(`Group created: ${group.group.id} - ${group.group.name}`);
+  console.log(`Members: ${group.group.members.map((m) => m.username).join(", ")}`);
+
+  // Alice sends a message to the group
+  console.log("\nAlice sending group message...");
+  sdk.setCurrentUser(alice);
+  const message1 = await sdk.sendMessage(group, "Hello team! Let's start the project.");
+  console.log(`Message sent: ${message1.id}`);
+
+  // Bob reads the group message
+  console.log("\nBob reading group messages...");
+  sdk.setCurrentUser(bob);
+  const bobMessages = await sdk.getMessagesForGroup(group.group.id);
+  for (const msg of bobMessages) {
+    const decrypted = await sdk.decryptMessage(msg, bob);
+    console.log(`Bob sees: "${decrypted}" from ${msg.senderId}`);
+  }
+
+  // Charlie replies
+  console.log("\nCharlie replying...");
+  sdk.setCurrentUser(charlie);
+  const message2 = await sdk.sendMessage(group, "Sounds good! I'm ready.");
+  console.log(`Message sent: ${message2.id}`);
+
+  // Alice reads all messages
+  console.log("\nAlice reading all group messages...");
+  sdk.setCurrentUser(alice);
+  const allMessages = await sdk.getMessagesForGroup(group.group.id);
+  console.log(`Total messages: ${allMessages.length}`);
+  for (const msg of allMessages) {
+    const decrypted = await sdk.decryptMessage(msg, alice);
+    const sender = group.group.members.find((m) => m.id === msg.senderId);
+    console.log(`${sender?.username || "Unknown"}: "${decrypted}"`);
+  }
+}
+
+main().catch(console.error);
+

package/examples/oneToOne.ts

@@ -0,0 +1,72 @@
+import { ChatSDK } from "../src/index.js";
+import {
+  InMemoryUserStore,
+  InMemoryMessageStore,
+  InMemoryGroupStore,
+} from "../src/index.js";
+import { InMemoryTransport } from "../src/index.js";
+
+/**
+ * Example: 1:1 Chat between two users
+ */
+async function main() {
+  // Initialize SDK with in-memory stores
+  const sdk = new ChatSDK({
+    userStore: new InMemoryUserStore(),
+    messageStore: new InMemoryMessageStore(),
+    groupStore: new InMemoryGroupStore(),
+    transport: new InMemoryTransport(),
+  });
+
+  // Create two users
+  console.log("Creating users...");
+  const alice = await sdk.createUser("alice");
+  const bob = await sdk.createUser("bob");
+
+  console.log(`Alice ID: ${alice.id}`);
+  console.log(`Bob ID: ${bob.id}`);
+
+  // Set Alice as current user
+  sdk.setCurrentUser(alice);
+
+  // Start a chat session between Alice and Bob
+  console.log("\nStarting chat session...");
+  const session = await sdk.startSession(alice, bob);
+
+  // Alice sends a message to Bob
+  console.log("\nAlice sending message...");
+  const message1 = await sdk.sendMessage(session, "Hello Bob! This is encrypted.");
+  console.log(`Message sent: ${message1.id}`);
+
+  // Switch to Bob's perspective
+  sdk.setCurrentUser(bob);
+
+  // Bob receives and decrypts the message
+  console.log("\nBob receiving messages...");
+  const messages = await sdk.getMessagesForUser(bob.id);
+  console.log(`Bob has ${messages.length} message(s)`);
+
+  for (const msg of messages) {
+    const decrypted = await sdk.decryptMessage(msg, bob);
+    console.log(`Decrypted: "${decrypted}"`);
+  }
+
+  // Bob replies
+  console.log("\nBob replying...");
+  const replySession = await sdk.startSession(bob, alice);
+  const message2 = await sdk.sendMessage(replySession, "Hi Alice! Got your message.");
+  console.log(`Reply sent: ${message2.id}`);
+
+  // Switch back to Alice
+  sdk.setCurrentUser(alice);
+  const aliceMessages = await sdk.getMessagesForUser(alice.id);
+  console.log(`\nAlice has ${aliceMessages.length} message(s)`);
+
+  for (const msg of aliceMessages) {
+    const decrypted = await sdk.decryptMessage(msg, alice);
+    console.log(`Decrypted: "${decrypted}"`);
+  }
+}
+
+main().catch(console.error);
+

package/examples/saveLoadUser.ts

@@ -0,0 +1,61 @@
+import { ChatSDK } from "../src/index.js";
+import {
+  InMemoryUserStore,
+  InMemoryMessageStore,
+  InMemoryGroupStore,
+} from "../src/index.js";
+import type { StoredUser } from "../src/index.js";
+
+/**
+ * Example: Save and load user data
+ */
+async function main() {
+  // Initialize SDK
+  const sdk = new ChatSDK({
+    userStore: new InMemoryUserStore(),
+    messageStore: new InMemoryMessageStore(),
+    groupStore: new InMemoryGroupStore(),
+  });
+
+  // Create a user
+  console.log("Creating user...");
+  const user = await sdk.createUser("john_doe");
+  console.log(`User created: ${user.username} (${user.id})`);
+  console.log(`Public key: ${user.publicKey.substring(0, 20)}...`);
+
+  // Simulate saving user data (in real app, this would be to a database)
+  const userStore = new InMemoryUserStore();
+  const storedUser: StoredUser = {
+    ...user,
+    createdAt: Date.now(),
+  };
+
+  // Save user
+  await userStore.save(storedUser);
+  console.log("\nUser saved to store");
+
+  // Simulate loading user from storage
+  console.log("\nLoading user from store...");
+  const loadedUser = await userStore.findById(user.id);
+  if (loadedUser) {
+    console.log(`User loaded: ${loadedUser.username} (${loadedUser.id})`);
+    console.log(`Keys match: ${loadedUser.publicKey === user.publicKey}`);
+
+    // Import the user into a new SDK instance
+    const sdk2 = new ChatSDK({
+      userStore: new InMemoryUserStore(),
+      messageStore: new InMemoryMessageStore(),
+      groupStore: new InMemoryGroupStore(),
+    });
+
+    const importedUser = await sdk2.importUser(loadedUser as StoredUser);
+    console.log(`\nUser imported into new SDK instance: ${importedUser.username}`);
+    sdk2.setCurrentUser(importedUser);
+    console.log("User is now active in SDK2");
+  } else {
+    console.error("Failed to load user");
+  }
+}
+
+main().catch(console.error);
+

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "chatly-sdk",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsup src/index.ts --dts --format esm",
+    "start": "ts-node src/index.ts",
+    "test": "ts-node test/crypto.test.ts"
+  },
+
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+  "type": "git",
+  "url": "https://github.com/bharath-arch/chatly-sdk.git"
+},
+
+  "keywords": [
+    "chat",
+    "sdk",
+    "e2e",
+    "encryption",
+    "messaging",
+    "whatsapp"
+  ],
+  "author": "",
+  "license": "ISC",
+  "description": "Production-ready end-to-end encrypted chat SDK with WhatsApp-style features",
+  "dependencies": {
+    "buffer": "^6.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "ts-node": "^10.9.2",
+    "tsup": "^8.0.0",
+    "typescript": "^5.9.3"
+  }
+}