chatly-sdk 1.0.0

package/src/index.ts

@@ -0,0 +1,212 @@
+import type { User, StoredUser } from "./models/user.js";
+import type { Message } from "./models/message.js";
+import type { Group } from "./models/group.js";
+import type {
+  UserStoreAdapter,
+  MessageStoreAdapter,
+  GroupStoreAdapter,
+} from "./stores/adapters.js";
+import type { TransportAdapter } from "./transport/adapters.js";
+import { ChatSession } from "./chat/ChatSession.js";
+import { GroupSession } from "./chat/GroupSession.js";
+import { generateIdentityKeyPair } from "./crypto/keys.js";
+import { generateUUID } from "./crypto/uuid.js";
+
+export interface ChatSDKConfig {
+  userStore: UserStoreAdapter;
+  messageStore: MessageStoreAdapter;
+  groupStore: GroupStoreAdapter;
+  transport?: TransportAdapter;
+}
+
+/**
+ * Main ChatSDK class - production-ready WhatsApp-style chat SDK
+ */
+export class ChatSDK {
+  private config: ChatSDKConfig;
+  private currentUser: User | null = null;
+
+  constructor(config: ChatSDKConfig) {
+    this.config = config;
+  }
+
+  /**
+   * Create a new user with generated identity keys
+   */
+  async createUser(username: string): Promise<User> {
+    const keyPair = generateIdentityKeyPair();
+    const user: 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: StoredUser): Promise<User> {
+    await this.config.userStore.save(userData);
+    return userData;
+  }
+
+  /**
+   * Set the current active user
+   */
+  setCurrentUser(user: User): void {
+    this.currentUser = user;
+    if (this.config.transport) {
+      this.config.transport.connect(user.id);
+    }
+  }
+
+  /**
+   * Get the current active user
+   */
+  getCurrentUser(): User | null {
+    return this.currentUser;
+  }
+
+  /**
+   * Start a 1:1 chat session between two users
+   */
+  async startSession(userA: User, userB: User): Promise<ChatSession> {
+    // Create consistent session ID regardless of user order
+    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: string, members: User[]): Promise<GroupSession> {
+    if (members.length < 2) {
+      throw new Error("Group must have at least 2 members");
+    }
+
+    const group: 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: string): Promise<GroupSession> {
+    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: ChatSession | GroupSession,
+    plaintext: string
+  ): Promise<Message> {
+    if (!this.currentUser) {
+      throw new Error("No current user set. Call setCurrentUser() first.");
+    }
+
+    let message: Message;
+    if (session instanceof ChatSession) {
+      message = await session.encrypt(plaintext, this.currentUser.id);
+    } else {
+      message = await session.encrypt(plaintext, this.currentUser.id);
+    }
+
+    // Store the message
+    await this.config.messageStore.create(message);
+
+    // Send via transport if available
+    if (this.config.transport) {
+      await this.config.transport.send(message);
+    }
+
+    return message;
+  }
+
+  /**
+   * Decrypt a message
+   */
+  async decryptMessage(message: Message, user: User): Promise<string> {
+    if (message.groupId) {
+      // Group message
+      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 {
+      // 1:1 message - need to find the session
+      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}`);
+      }
+
+      // Create consistent session ID
+      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: string): Promise<Message[]> {
+    return await this.config.messageStore.listByUser(userId);
+  }
+
+  /**
+   * Get messages for a group
+   */
+  async getMessagesForGroup(groupId: string): Promise<Message[]> {
+    return await this.config.messageStore.listByGroup(groupId);
+  }
+}
+
+// Export adapters and implementations
+export * from "./stores/adapters.js";
+export * from "./stores/memory/userStore.js";
+export * from "./stores/memory/messageStore.js";
+export * from "./stores/memory/groupStore.js";
+export * from "./transport/adapters.js";
+export * from "./transport/memoryTransport.js";
+export * from "./models/user.js";
+export * from "./models/message.js";
+export * from "./models/group.js";
+export * from "./chat/ChatSession.js";
+export * from "./chat/GroupSession.js";

package/src/models/ImageMessage.ts

@@ -0,0 +1,6 @@
+
+import { Message } from './Message';
+
+export interface ImageMessage extends Message {
+  imageUrl: string;
+}

package/src/models/ReadReceipt.ts

@@ -0,0 +1,6 @@
+
+export interface ReadReceipt {
+  messageId: string;
+  readerId: string;
+  timestamp: number;
+}

package/src/models/group.ts

@@ -0,0 +1,8 @@
+import type { User } from "./user.js";
+
+export interface Group {
+  id: string;
+  name: string;
+  members: User[];
+  createdAt: number;
+}

package/src/models/message.ts

@@ -0,0 +1,13 @@
+export type MessageType = "text" | "system";
+
+export interface Message {
+  id: string;
+  senderId: string;
+  receiverId?: string;
+  groupId?: string;
+  ciphertext: string;
+  iv: string;
+  timestamp: number;
+  type: MessageType;
+}
+

package/src/models/user.ts

@@ -0,0 +1,11 @@
+export interface User {
+  id: string;
+  username: string;
+  identityKey: string;
+  publicKey: string;
+  privateKey: string;
+}
+
+export interface StoredUser extends User {
+  createdAt: number;
+}

package/src/stores/adapters.ts

@@ -0,0 +1,22 @@
+import type { User, StoredUser } from "../models/user.js";
+import type { Message } from "../models/message.js";
+import type { Group } from "../models/group.js";
+
+export interface UserStoreAdapter {
+  create(user: User): Promise<User>;
+  findById(id: string): Promise<User | undefined>;
+  save(user: StoredUser): Promise<void>;
+  list(): Promise<User[]>;
+}
+
+export interface MessageStoreAdapter {
+  create(message: Message): Promise<Message>;
+  listByUser(userId: string): Promise<Message[]>;
+  listByGroup(groupId: string): Promise<Message[]>;
+}
+
+export interface GroupStoreAdapter {
+  create(group: Group): Promise<Group>;
+  findById(id: string): Promise<Group | undefined>;
+  list(): Promise<Group[]>;
+}

package/src/stores/memory/groupStore.ts

@@ -0,0 +1,19 @@
+import type { Group } from "../../models/group.js";
+import type { GroupStoreAdapter } from "../adapters.js";
+
+export class InMemoryGroupStore implements GroupStoreAdapter {
+  private groups = new Map<string, Group>();
+
+  async create(group: Group): Promise<Group> {
+    this.groups.set(group.id, group);
+    return group;
+  }
+
+  async findById(id: string): Promise<Group | undefined> {
+    return this.groups.get(id);
+  }
+
+  async list(): Promise<Group[]> {
+    return Array.from(this.groups.values());
+  }
+}

package/src/stores/memory/messageStore.ts

@@ -0,0 +1,21 @@
+import type { Message } from "../../models/message.js";
+import type { MessageStoreAdapter } from "../adapters.js";
+
+export class InMemoryMessageStore implements MessageStoreAdapter {
+  private messages: Message[] = [];
+
+  async create(message: Message): Promise<Message> {
+    this.messages.push(message);
+    return message;
+  }
+
+  async listByUser(userId: string): Promise<Message[]> {
+    return this.messages.filter(
+      (msg) => msg.senderId === userId || msg.receiverId === userId
+    );
+  }
+
+  async listByGroup(groupId: string): Promise<Message[]> {
+    return this.messages.filter((msg) => msg.groupId === groupId);
+  }
+}

package/src/stores/memory/userStore.ts

@@ -0,0 +1,24 @@
+import type { User, StoredUser } from "../../models/user.js";
+import type { UserStoreAdapter } from "../adapters.js";
+
+export class InMemoryUserStore implements UserStoreAdapter {
+  private users = new Map<string, StoredUser>();
+
+  async create(user: User): Promise<User> {
+    const stored: StoredUser = { ...user, createdAt: Date.now() };
+    this.users.set(stored.id, stored);
+    return stored;
+  }
+
+  async findById(id: string): Promise<User | undefined> {
+    return this.users.get(id);
+  }
+
+  async save(user: StoredUser): Promise<void> {
+    this.users.set(user.id, user);
+  }
+
+  async list(): Promise<User[]> {
+    return Array.from(this.users.values());
+  }
+}

package/src/transport/adapters.ts

@@ -0,0 +1,7 @@
+import type { Message } from "../models/message.js";
+
+export interface TransportAdapter {
+  connect(userId: string): Promise<void>;
+  send(message: Message): Promise<void>;
+  onMessage(handler: (message: Message) => void): void;
+}

package/src/transport/memoryTransport.ts

@@ -0,0 +1,24 @@
+import type { Message } from "../models/message.js";
+import type { TransportAdapter } from "./adapters.js";
+
+type MessageHandler = (message: Message) => void;
+
+export class InMemoryTransport implements TransportAdapter {
+  private handler?: MessageHandler;
+  private connected = false;
+
+  async connect(_userId: string): Promise<void> {
+    this.connected = true;
+  }
+
+  async send(message: Message): Promise<void> {
+    if (!this.connected) {
+      throw new Error("Transport not connected");
+    }
+    this.handler?.(message);
+  }
+
+  onMessage(handler: MessageHandler): void {
+    this.handler = handler;
+  }
+}

package/src/transport/websocketClient.ts

@@ -0,0 +1,37 @@
+
+import WebSocket from 'ws';
+
+export class ChatClient {
+  private ws: WebSocket | null = null;
+  private messageHandlers: ((message: Buffer) => void)[] = [];
+
+  constructor(private url: string) {}
+
+  connect(): void {
+    this.ws = new WebSocket(this.url);
+
+    this.ws.on('open', () => {
+      console.log('Connected to WebSocket server');
+    });
+
+    this.ws.on('message', (message: Buffer) => {
+      this.messageHandlers.forEach(handler => handler(message));
+    });
+
+    this.ws.on('close', () => {
+      console.log('Disconnected from WebSocket server');
+    });
+  }
+
+  sendMessage(message: string | Buffer): void {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(message);
+    } else {
+      console.error('WebSocket is not connected.');
+    }
+  }
+
+  onMessage(handler: (message: Buffer) => void): void {
+    this.messageHandlers.push(handler);
+  }
+}

package/src/transport/websocketServer.ts

@@ -0,0 +1,33 @@
+
+import { WebSocketServer, WebSocket } from 'ws';
+
+export class ChatServer {
+  private wss: WebSocketServer;
+
+  constructor(port: number) {
+    this.wss = new WebSocketServer({ port });
+    this.initialize();
+  }
+
+  private initialize(): void {
+    this.wss.on('connection', (ws: WebSocket) => {
+      console.log('Client connected');
+
+      ws.on('message', (message: Buffer) => {
+        console.log('Received message:', message.toString());
+        // Broadcast the message to all other clients
+        this.wss.clients.forEach((client) => {
+          if (client !== ws && client.readyState === WebSocket.OPEN) {
+            client.send(message);
+          }
+        });
+      });
+
+      ws.on('close', () => {
+        console.log('Client disconnected');
+      });
+    });
+
+    console.log(`WebSocket server started on port ${this.wss.options.port}`);
+  }
+}

package/test/crypto.test.ts

@@ -0,0 +1,45 @@
+
+import assert from 'assert';
+import { KeyManager } from '../src/crypto/keyManager';
+import { encrypt } from '../src/crypto/encrypt';
+import { decrypt } from '../src/crypto/decrypt';
+
+async function testCrypto() {
+  console.log('Running crypto tests...');
+
+  // Test KeyManager
+  const keyManager1 = new KeyManager();
+  const keyManager2 = new KeyManager();
+
+  await keyManager1.generateKeys();
+  await keyManager2.generateKeys();
+
+  const publicKey1 = keyManager1.getPublicKey();
+  const privateKey1 = keyManager1.getPrivateKey();
+  const publicKey2 = keyManager2.getPublicKey();
+  const privateKey2 = keyManager2.getPrivateKey();
+
+  assert(publicKey1, 'publicKey1 should not be null');
+  assert(privateKey1, 'privateKey1 should not be null');
+  assert(publicKey2, 'publicKey2 should not be null');
+  assert(privateKey2, 'privateKey2 should not be null');
+
+  console.log('KeyManager test passed.');
+
+  // Test encrypt and decrypt
+  const message = 'This is a secret message.';
+  if (publicKey1 && privateKey1 && publicKey2 && privateKey2) {
+    const encryptedMessage = await encrypt(message, publicKey2, privateKey1);
+    const decryptedMessage = await decrypt(encryptedMessage, publicKey1, privateKey2);
+
+    assert.strictEqual(decryptedMessage, message, 'Decrypted message should match original message.');
+  } else {
+    assert.fail('Keys should not be null');
+  }
+
+  console.log('Encrypt/decrypt test passed.');
+
+  console.log('All crypto tests passed.');
+}
+
+testCrypto().catch(console.error);

package/tsconfig.json

@@ -0,0 +1,44 @@
+{
+  // Visit https://aka.ms/tsconfig to read more about this file
+  "compilerOptions": {
+    // File Layout
+    // "rootDir": "./src",
+    // "outDir": "./dist",
+
+    // Environment Settings
+    // See also https://aka.ms/tsconfig/module
+    "module": "nodenext",
+    "target": "esnext",
+ 
+    // For nodejs:
+    // "lib": ["esnext"],
+    "types": ["node"],
+    // and npm install -D @types/node
+
+    // Other Outputs
+    "sourceMap": true,
+    "declaration": true,
+    "declarationMap": true,
+
+    // Stricter Typechecking Options
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+
+    // Style Options
+    // "noImplicitReturns": true,
+    // "noImplicitOverride": true,
+    // "noUnusedLocals": true,
+    // "noUnusedParameters": true,
+    // "noFallthroughCasesInSwitch": true,
+    // "noPropertyAccessFromIndexSignature": true,
+
+    // Recommended Options
+    "strict": true,
+    "jsx": "react-jsx",
+    "verbatimModuleSyntax": false,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+  }
+}