chatly-sdk 1.0.0 → 2.0.0

package/src/utils/mediaUtils.ts

@@ -0,0 +1,235 @@
+import { MediaType, MediaMetadata, MediaAttachment, SUPPORTED_MIME_TYPES, FILE_SIZE_LIMITS } from '../models/mediaTypes.js';
+import { ValidationError } from './errors.js';
+
+/**
+ * Convert File or Blob to base64 string
+ */
+export async function encodeFileToBase64(file: File | Blob): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => {
+      const result = reader.result as string;
+      if (!result) {
+        reject(new Error('Failed to read file: result is null'));
+        return;
+      }
+      const base64 = result.split(',')[1];
+      if (!base64) {
+        reject(new Error('Failed to extract base64 data'));
+        return;
+      }
+      resolve(base64);
+    };
+    reader.onerror = () => reject(new Error('Failed to read file'));
+    reader.readAsDataURL(file);
+  });
+}
+
+/**
+ * Convert base64 string to Blob
+ */
+export function decodeBase64ToBlob(base64: string, mimeType: string): Blob {
+  const byteCharacters = atob(base64);
+  const byteNumbers = new Array(byteCharacters.length);
+  
+  for (let i = 0; i < byteCharacters.length; i++) {
+    byteNumbers[i] = byteCharacters.charCodeAt(i);
+  }
+  
+  const byteArray = new Uint8Array(byteNumbers);
+  return new Blob([byteArray], { type: mimeType });
+}
+
+/**
+ * Detect media type from MIME type
+ */
+export function getMediaType(mimeType: string): MediaType {
+  if (SUPPORTED_MIME_TYPES.image.includes(mimeType)) {
+    return MediaType.IMAGE;
+  }
+  if (SUPPORTED_MIME_TYPES.audio.includes(mimeType)) {
+    return MediaType.AUDIO;
+  }
+  if (SUPPORTED_MIME_TYPES.video.includes(mimeType)) {
+    return MediaType.VIDEO;
+  }
+  if (SUPPORTED_MIME_TYPES.document.includes(mimeType)) {
+    return MediaType.DOCUMENT;
+  }
+  throw new ValidationError(`Unsupported MIME type: ${mimeType}`);
+}
+
+/**
+ * Validate media file
+ */
+export function validateMediaFile(file: File | Blob, filename?: string): void {
+  const mimeType = file.type;
+  
+  // Check if MIME type is supported
+  const mediaType = getMediaType(mimeType);
+  
+  // Check file size
+  const maxSize = FILE_SIZE_LIMITS[mediaType];
+  if (file.size > maxSize) {
+    throw new ValidationError(
+      `File size exceeds limit. Max size for ${mediaType}: ${maxSize / 1024 / 1024}MB`
+    );
+  }
+  
+  // Validate filename if provided
+  if (filename && filename.length > 255) {
+    throw new ValidationError('Filename too long (max 255 characters)');
+  }
+}
+
+/**
+ * Create media metadata from file
+ */
+export async function createMediaMetadata(
+  file: File | Blob,
+  filename?: string
+): Promise<MediaMetadata> {
+  const actualFilename = filename || (file instanceof File ? file.name : 'file');
+  
+  const metadata: MediaMetadata = {
+    filename: actualFilename,
+    mimeType: file.type,
+    size: file.size,
+  };
+  
+  // For images, try to get dimensions
+  if (file.type.startsWith('image/')) {
+    try {
+      const dimensions = await getImageDimensions(file);
+      metadata.width = dimensions.width;
+      metadata.height = dimensions.height;
+      
+      // Generate thumbnail for images
+      metadata.thumbnail = await generateThumbnail(file);
+    } catch (error) {
+      // Dimensions optional, continue without them
+    }
+  }
+  
+  // For audio/video, duration would need to be provided by the caller
+  // as we can't reliably get it in Node.js without external libraries
+  
+  return metadata;
+}
+
+/**
+ * Get image dimensions
+ */
+function getImageDimensions(file: Blob): Promise<{ width: number; height: number }> {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    const url = URL.createObjectURL(file);
+    
+    img.onload = () => {
+      URL.revokeObjectURL(url);
+      resolve({ width: img.width, height: img.height });
+    };
+    
+    img.onerror = () => {
+      URL.revokeObjectURL(url);
+      reject(new Error('Failed to load image'));
+    };
+    
+    img.src = url;
+  });
+}
+
+/**
+ * Generate thumbnail for image (max 200x200)
+ */
+async function generateThumbnail(file: Blob): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    const url = URL.createObjectURL(file);
+    
+    img.onload = () => {
+      URL.revokeObjectURL(url);
+      
+      // Calculate thumbnail size (max 200x200, maintain aspect ratio)
+      const maxSize = 200;
+      let width = img.width;
+      let height = img.height;
+      
+      if (width > height) {
+        if (width > maxSize) {
+          height = (height * maxSize) / width;
+          width = maxSize;
+        }
+      } else {
+        if (height > maxSize) {
+          width = (width * maxSize) / height;
+          height = maxSize;
+        }
+      }
+      
+      // Create canvas and draw thumbnail
+      const canvas = document.createElement('canvas');
+      canvas.width = width;
+      canvas.height = height;
+      const ctx = canvas.getContext('2d');
+      
+      if (!ctx) {
+        reject(new Error('Failed to get canvas context'));
+        return;
+      }
+      
+      ctx.drawImage(img, 0, 0, width, height);
+      
+      // Convert to base64
+      const dataUrl = canvas.toDataURL('image/jpeg', 0.7);
+      const thumbnail = dataUrl.split(',')[1];
+      if (!thumbnail) {
+        reject(new Error('Failed to generate thumbnail'));
+        return;
+      }
+      resolve(thumbnail);
+    };
+    
+    img.onerror = () => {
+      URL.revokeObjectURL(url);
+      reject(new Error('Failed to load image for thumbnail'));
+    };
+    
+    img.src = url;
+  });
+}
+
+/**
+ * Create media attachment from file
+ */
+export async function createMediaAttachment(
+  file: File | Blob,
+  filename?: string
+): Promise<MediaAttachment> {
+  // Validate file
+  validateMediaFile(file, filename);
+  
+  // Get media type
+  const mediaType = getMediaType(file.type);
+  
+  // Encode file to base64
+  const data = await encodeFileToBase64(file);
+  
+  // Create metadata
+  const metadata = await createMediaMetadata(file, filename);
+  
+  return {
+    type: mediaType,
+    data,
+    metadata,
+  };
+}
+
+/**
+ * Format file size for display
+ */
+export function formatFileSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+}

package/src/utils/messageQueue.ts

@@ -0,0 +1,162 @@
+import { Message } from '../models/message.js';
+import { logger } from './logger.js';
+import { MAX_QUEUE_SIZE, MESSAGE_RETRY_ATTEMPTS, MESSAGE_RETRY_DELAY, MessageStatus } from '../constants.js';
+
+/**
+ * Queued message with retry metadata
+ */
+export interface QueuedMessage {
+  message: Message;
+  status: MessageStatus;
+  attempts: number;
+  lastAttempt?: number;
+  error?: Error;
+}
+
+/**
+ * Message queue for offline support and retry logic
+ */
+export class MessageQueue {
+  private queue: Map<string, QueuedMessage> = new Map();
+  private maxSize: number;
+  private maxRetries: number;
+  private retryDelay: number;
+
+  constructor(
+    maxSize: number = MAX_QUEUE_SIZE,
+    maxRetries: number = MESSAGE_RETRY_ATTEMPTS,
+    retryDelay: number = MESSAGE_RETRY_DELAY
+  ) {
+    this.maxSize = maxSize;
+    this.maxRetries = maxRetries;
+    this.retryDelay = retryDelay;
+  }
+
+  /**
+   * Add a message to the queue
+   */
+  enqueue(message: Message): void {
+    if (this.queue.size >= this.maxSize) {
+      logger.warn('Message queue is full, removing oldest message');
+      const firstKey = this.queue.keys().next().value;
+      if (firstKey) {
+        this.queue.delete(firstKey);
+      }
+    }
+
+    this.queue.set(message.id, {
+      message,
+      status: MessageStatus.PENDING,
+      attempts: 0,
+    });
+
+    logger.debug('Message enqueued', { messageId: message.id });
+  }
+
+  /**
+   * Mark a message as sent
+   */
+  markSent(messageId: string): void {
+    const queued = this.queue.get(messageId);
+    if (queued) {
+      queued.status = MessageStatus.SENT;
+      logger.debug('Message marked as sent', { messageId });
+      // Remove from queue after successful send
+      this.queue.delete(messageId);
+    }
+  }
+
+  /**
+   * Mark a message as failed
+   */
+  markFailed(messageId: string, error: Error): void {
+    const queued = this.queue.get(messageId);
+    if (queued) {
+      queued.status = MessageStatus.FAILED;
+      queued.error = error;
+      queued.attempts++;
+      queued.lastAttempt = Date.now();
+
+      logger.warn('Message failed', {
+        messageId,
+        attempts: queued.attempts,
+        error: error.message,
+      });
+
+      // Remove if max retries exceeded
+      if (queued.attempts >= this.maxRetries) {
+        logger.error('Message exceeded max retries, removing from queue', {
+          messageId,
+          attempts: queued.attempts,
+        });
+        this.queue.delete(messageId);
+      }
+    }
+  }
+
+  /**
+   * Get messages that need to be retried
+   */
+  getRetryableMessages(): QueuedMessage[] {
+    const now = Date.now();
+    const retryable: QueuedMessage[] = [];
+
+    for (const queued of this.queue.values()) {
+      if (
+        queued.status === MessageStatus.FAILED &&
+        queued.attempts < this.maxRetries &&
+        (!queued.lastAttempt || now - queued.lastAttempt >= this.retryDelay)
+      ) {
+        retryable.push(queued);
+      }
+    }
+
+    return retryable;
+  }
+
+  /**
+   * Get all pending messages
+   */
+  getPendingMessages(): QueuedMessage[] {
+    return Array.from(this.queue.values()).filter(
+      (q) => q.status === MessageStatus.PENDING
+    );
+  }
+
+  /**
+   * Get queue size
+   */
+  size(): number {
+    return this.queue.size;
+  }
+
+  /**
+   * Clear the queue
+   */
+  clear(): void {
+    this.queue.clear();
+    logger.debug('Message queue cleared');
+  }
+
+  /**
+   * Get message by ID
+   */
+  get(messageId: string): QueuedMessage | undefined {
+    return this.queue.get(messageId);
+  }
+
+  /**
+   * Remove message from queue
+   */
+  remove(messageId: string): void {
+    this.queue.delete(messageId);
+    logger.debug('Message removed from queue', { messageId });
+  }
+
+  /**
+   * Get all messages in queue
+   */
+  getAll(): QueuedMessage[] {
+    return Array.from(this.queue.values());
+  }
+}

package/src/utils/validation.ts

@@ -0,0 +1,99 @@
+import { ValidationError } from "./errors.js";
+
+/**
+ * Validation utilities
+ */
+
+const USERNAME_REGEX = /^[a-zA-Z0-9_-]{3,20}$/;
+const MAX_MESSAGE_LENGTH = 10000;
+const MIN_GROUP_MEMBERS = 2;
+const MAX_GROUP_MEMBERS = 256;
+const MAX_GROUP_NAME_LENGTH = 100;
+
+/**
+ * Validate username format
+ */
+export function validateUsername(username: string): void {
+  if (!username || typeof username !== 'string') {
+    throw new ValidationError('Username is required', { username });
+  }
+
+  if (!USERNAME_REGEX.test(username)) {
+    throw new ValidationError(
+      'Username must be 3-20 characters and contain only letters, numbers, underscores, and hyphens',
+      { username }
+    );
+  }
+}
+
+/**
+ * Validate message content
+ */
+export function validateMessage(message: string): void {
+  if (!message || typeof message !== 'string') {
+    throw new ValidationError('Message content is required');
+  }
+
+  if (message.length === 0) {
+    throw new ValidationError('Message cannot be empty');
+  }
+
+  if (message.length > MAX_MESSAGE_LENGTH) {
+    throw new ValidationError(
+      `Message exceeds maximum length of ${MAX_MESSAGE_LENGTH} characters`,
+      { length: message.length, max: MAX_MESSAGE_LENGTH }
+    );
+  }
+}
+
+/**
+ * Validate group name
+ */
+export function validateGroupName(name: string): void {
+  if (!name || typeof name !== 'string') {
+    throw new ValidationError('Group name is required');
+  }
+
+  if (name.trim().length === 0) {
+    throw new ValidationError('Group name cannot be empty');
+  }
+
+  if (name.length > MAX_GROUP_NAME_LENGTH) {
+    throw new ValidationError(
+      `Group name exceeds maximum length of ${MAX_GROUP_NAME_LENGTH} characters`,
+      { length: name.length, max: MAX_GROUP_NAME_LENGTH }
+    );
+  }
+}
+
+/**
+ * Validate group members count
+ */
+export function validateGroupMembers(memberCount: number): void {
+  if (memberCount < MIN_GROUP_MEMBERS) {
+    throw new ValidationError(
+      `Group must have at least ${MIN_GROUP_MEMBERS} members`,
+      { count: memberCount, min: MIN_GROUP_MEMBERS }
+    );
+  }
+
+  if (memberCount > MAX_GROUP_MEMBERS) {
+    throw new ValidationError(
+      `Group cannot have more than ${MAX_GROUP_MEMBERS} members`,
+      { count: memberCount, max: MAX_GROUP_MEMBERS }
+    );
+  }
+}
+
+/**
+ * Validate user ID format
+ */
+export function validateUserId(userId: string): void {
+  if (!userId || typeof userId !== 'string') {
+    throw new ValidationError('User ID is required');
+  }
+
+  if (userId.trim().length === 0) {
+    throw new ValidationError('User ID cannot be empty');
+  }
+}

package/test/crypto.test.ts

@@ -1,45 +1,132 @@
+import { encryptMessage, decryptMessage, deriveSharedSecret } from '../src/crypto/e2e.js';
+import { generateIdentityKeyPair } from '../src/crypto/keys.js';
 
-import assert from 'assert';
-import { KeyManager } from '../src/crypto/keyManager';
-import { encrypt } from '../src/crypto/encrypt';
-import { decrypt } from '../src/crypto/decrypt';
+describe('End-to-End Encryption', () => {
+  describe('Key Generation', () => {
+    it('should generate a valid key pair', () => {
+      const keyPair = generateIdentityKeyPair();
+      
+      expect(keyPair).toHaveProperty('publicKey');
+      expect(keyPair).toHaveProperty('privateKey');
+      expect(typeof keyPair.publicKey).toBe('string');
+      expect(typeof keyPair.privateKey).toBe('string');
+      expect(keyPair.publicKey.length).toBeGreaterThan(0);
+      expect(keyPair.privateKey.length).toBeGreaterThan(0);
+    });
 
-async function testCrypto() {
-  console.log('Running crypto tests...');
+    it('should generate unique key pairs', () => {
+      const keyPair1 = generateIdentityKeyPair();
+      const keyPair2 = generateIdentityKeyPair();
+      
+      expect(keyPair1.publicKey).not.toBe(keyPair2.publicKey);
+      expect(keyPair1.privateKey).not.toBe(keyPair2.privateKey);
+    });
+  });
 
-  // Test KeyManager
-  const keyManager1 = new KeyManager();
-  const keyManager2 = new KeyManager();
+  describe('Shared Secret Derivation', () => {
+    it('should derive the same shared secret for both parties', async () => {
+      const aliceKeys = generateIdentityKeyPair();
+      const bobKeys = generateIdentityKeyPair();
+      
+      const aliceShared = await deriveSharedSecret(aliceKeys, bobKeys.publicKey);
+      const bobShared = await deriveSharedSecret(bobKeys, aliceKeys.publicKey);
+      
+      expect(aliceShared).toEqual(bobShared);
+    });
 
-  await keyManager1.generateKeys();
-  await keyManager2.generateKeys();
+    it('should derive different secrets for different key pairs', async () => {
+      const aliceKeys = generateIdentityKeyPair();
+      const bobKeys = generateIdentityKeyPair();
+      const charlieKeys = generateIdentityKeyPair();
+      
+      const aliceBobSecret = await deriveSharedSecret(aliceKeys, bobKeys.publicKey);
+      const aliceCharlieSecret = await deriveSharedSecret(aliceKeys, charlieKeys.publicKey);
+      
+      expect(aliceBobSecret).not.toEqual(aliceCharlieSecret);
+    });
+  });
 
-  const publicKey1 = keyManager1.getPublicKey();
-  const privateKey1 = keyManager1.getPrivateKey();
-  const publicKey2 = keyManager2.getPublicKey();
-  const privateKey2 = keyManager2.getPrivateKey();
+  describe('Message Encryption and Decryption', () => {
+    it('should encrypt and decrypt a message correctly', async () => {
+      const aliceKeys = generateIdentityKeyPair();
+      const bobKeys = generateIdentityKeyPair();
+      const sharedSecret = await deriveSharedSecret(aliceKeys, bobKeys.publicKey);
+      
+      const plaintext = 'Hello, Bob!';
+      const encrypted = await encryptMessage(plaintext, sharedSecret);
+      
+      expect(encrypted).toHaveProperty('ciphertext');
+      expect(encrypted).toHaveProperty('iv');
+      expect(typeof encrypted.ciphertext).toBe('string');
+      expect(typeof encrypted.iv).toBe('string');
+      
+      const decrypted = await decryptMessage(encrypted.ciphertext, encrypted.iv, sharedSecret);
+      expect(decrypted).toBe(plaintext);
+    });
 
-  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');
+    it('should produce different ciphertexts for the same plaintext', async () => {
+      const aliceKeys = generateIdentityKeyPair();
+      const bobKeys = generateIdentityKeyPair();
+      const sharedSecret = await deriveSharedSecret(aliceKeys, bobKeys.publicKey);
+      
+      const plaintext = 'Hello, Bob!';
+      const encrypted1 = await encryptMessage(plaintext, sharedSecret);
+      const encrypted2 = await encryptMessage(plaintext, sharedSecret);
+      
+      expect(encrypted1.ciphertext).not.toBe(encrypted2.ciphertext);
+      expect(encrypted1.iv).not.toBe(encrypted2.iv);
+    });
 
-  console.log('KeyManager test passed.');
+    it('should fail to decrypt with wrong shared secret', async () => {
+      const aliceKeys = generateIdentityKeyPair();
+      const bobKeys = generateIdentityKeyPair();
+      const charlieKeys = generateIdentityKeyPair();
+      
+      const aliceBobSecret = await deriveSharedSecret(aliceKeys, bobKeys.publicKey);
+      const aliceCharlieSecret = await deriveSharedSecret(aliceKeys, charlieKeys.publicKey);
+      
+      const plaintext = 'Secret message';
+      const encrypted = await encryptMessage(plaintext, aliceBobSecret);
+      
+      expect(() =>
+        decryptMessage(encrypted.ciphertext, encrypted.iv, aliceCharlieSecret)
+      ).toThrow(/Unsupported state or unable to authenticate data/);
+    });
 
-  // 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);
+    it('should handle empty messages', async () => {
+      const aliceKeys = generateIdentityKeyPair();
+      const bobKeys = generateIdentityKeyPair();
+      const sharedSecret = await deriveSharedSecret(aliceKeys, bobKeys.publicKey);
+      
+      const plaintext = '';
+      const encrypted = await encryptMessage(plaintext, sharedSecret);
+      const decrypted = await decryptMessage(encrypted.ciphertext, encrypted.iv, sharedSecret);
+      
+      expect(decrypted).toBe(plaintext);
+    });
 
-    assert.strictEqual(decryptedMessage, message, 'Decrypted message should match original message.');
-  } else {
-    assert.fail('Keys should not be null');
-  }
+    it('should handle long messages', async () => {
+      const aliceKeys = generateIdentityKeyPair();
+      const bobKeys = generateIdentityKeyPair();
+      const sharedSecret = await deriveSharedSecret(aliceKeys, bobKeys.publicKey);
+      
+      const plaintext = 'A'.repeat(10000);
+      const encrypted = await encryptMessage(plaintext, sharedSecret);
+      const decrypted = await decryptMessage(encrypted.ciphertext, encrypted.iv, sharedSecret);
+      
+      expect(decrypted).toBe(plaintext);
+    });
 
-  console.log('Encrypt/decrypt test passed.');
-
-  console.log('All crypto tests passed.');
-}
-
-testCrypto().catch(console.error);
+    it('should handle special characters and emojis', async () => {
+      const aliceKeys = generateIdentityKeyPair();
+      const bobKeys = generateIdentityKeyPair();
+      const sharedSecret = await deriveSharedSecret(aliceKeys, bobKeys.publicKey);
+      
+      const plaintext = 'Hello 👋 World! 🌍 Special chars: @#$%^&*()';
+      const encrypted = await encryptMessage(plaintext, sharedSecret);
+      const decrypted = await decryptMessage(encrypted.ciphertext, encrypted.iv, sharedSecret);
+      
+      expect(decrypted).toBe(plaintext);
+    });
+  });
+});