@nuraly/lumenjs 0.1.3 → 0.1.4

package/dist/communication/handlers/messaging.js

@@ -0,0 +1,237 @@
+// ── Messages ────────────────────────────────────────────────────
+export async function handleMessageSend(ctx, data) {
+    // ── Membership check ──────────────────────────────────────────
+    if (ctx.db) {
+        const row = await ctx.db.get('SELECT 1 FROM conversation_participants WHERE conversation_id = ? AND user_id = ?', data.conversationId, ctx.userId);
+        if (!row) {
+            ctx.push({ event: 'message:error', data: { code: 'FORBIDDEN', message: 'Not a participant of this conversation' } });
+            return;
+        }
+    }
+    else {
+        const members = ctx.store.getConversationMembers(data.conversationId);
+        if (members.size > 0 && !members.has(ctx.userId)) {
+            ctx.push({ event: 'message:error', data: { code: 'FORBIDDEN', message: 'Not a participant of this conversation' } });
+            return;
+        }
+    }
+    // ── Message length check ──────────────────────────────────────
+    const maxLen = ctx.config.maxMessageLength ?? 10_000;
+    if (data.content && data.content.length > maxLen) {
+        ctx.push({ event: 'message:error', data: { code: 'MESSAGE_TOO_LONG', message: `Message exceeds maximum length of ${maxLen} characters.` } });
+        return;
+    }
+    // ── Rate limit check ──────────────────────────────────────────
+    if (ctx.config.rateLimit) {
+        const allowed = ctx.store.checkRateLimit(ctx.userId, ctx.config.rateLimit);
+        if (!allowed) {
+            ctx.push({ event: 'message:error', data: { code: 'RATE_LIMITED', message: 'Message rate limit exceeded. Please wait before sending more messages.' } });
+            return;
+        }
+    }
+    // ── File upload validation ────────────────────────────────────
+    if (data.attachment && ctx.config.fileUpload) {
+        const { maxFileSize, allowedMimeTypes } = ctx.config.fileUpload;
+        if (data.attachment.fileSize > maxFileSize) {
+            ctx.push({ event: 'message:error', data: { code: 'FILE_TOO_LARGE', message: `File size ${data.attachment.fileSize} exceeds maximum allowed size of ${maxFileSize} bytes.` } });
+            return;
+        }
+        if (allowedMimeTypes && allowedMimeTypes.length > 0 && !allowedMimeTypes.includes(data.attachment.mimeType)) {
+            ctx.push({ event: 'message:error', data: { code: 'MIME_TYPE_NOT_ALLOWED', message: `MIME type '${data.attachment.mimeType}' is not allowed.` } });
+            return;
+        }
+    }
+    const now = new Date().toISOString();
+    let message;
+    // For encrypted messages, content is ciphertext — server stores it as opaque blob
+    const contentToStore = data.encrypted && data.envelope
+        ? JSON.stringify(data.envelope)
+        : data.content;
+    if (ctx.db) {
+        const inserted = await ctx.db.get(`INSERT INTO messages (conversation_id, sender_id, content, type, reply_to, attachment, status, encrypted, created_at)
+       VALUES (?, ?, ?, ?, ?, ?, 'sent', ?, ?) RETURNING id`, data.conversationId, ctx.userId, contentToStore, data.type, data.replyTo || null, data.attachment ? JSON.stringify(data.attachment) : null, data.encrypted ? 1 : 0, now);
+        message = {
+            id: String(inserted?.id ?? 0),
+            conversationId: data.conversationId,
+            senderId: ctx.userId,
+            content: contentToStore,
+            type: data.type,
+            createdAt: now,
+            replyTo: data.replyTo,
+            attachment: data.attachment,
+            status: 'sent',
+            readBy: [],
+            encrypted: data.encrypted,
+            envelope: data.envelope,
+        };
+        // Update conversation's last activity
+        await ctx.db.run(`UPDATE conversations SET updated_at = ? WHERE id = ?`, now, data.conversationId);
+    }
+    else {
+        // Without DB, create an in-memory message
+        message = {
+            id: crypto.randomUUID(),
+            conversationId: data.conversationId,
+            senderId: ctx.userId,
+            content: contentToStore,
+            type: data.type,
+            createdAt: now,
+            replyTo: data.replyTo,
+            attachment: data.attachment,
+            status: 'sent',
+            readBy: [],
+            encrypted: data.encrypted,
+            envelope: data.envelope,
+        };
+    }
+    // Clear typing indicator since the user just sent a message
+    ctx.store.clearTyping(data.conversationId, ctx.userId);
+    // Notify sender that the message has been persisted
+    ctx.push({ event: 'message:status', data: { messageId: message.id, status: 'sent' } });
+    // Broadcast to all participants in the conversation
+    ctx.broadcastAll(`conv:${data.conversationId}`, { event: 'message:new', data: message });
+    // Check if any recipient in the conversation has a connected socket
+    const members = ctx.store.getConversationMembers(data.conversationId);
+    const hasOnlineRecipient = Array.from(members).some((uid) => uid !== ctx.userId && ctx.store.isUserOnline(uid));
+    if (hasOnlineRecipient) {
+        if (ctx.db) {
+            await ctx.db.run(`UPDATE messages SET status = 'delivered' WHERE id = ? AND status = 'sent'`, message.id);
+        }
+        message.status = 'delivered';
+        ctx.push({ event: 'message:status', data: { messageId: message.id, status: 'delivered' } });
+    }
+}
+export async function handleMessageRead(ctx, data) {
+    const now = new Date().toISOString();
+    const receipt = { userId: ctx.userId, readAt: now };
+    if (ctx.db) {
+        // Insert read receipt (ignore duplicates)
+        await ctx.db.run(`INSERT OR IGNORE INTO read_receipts (message_id, user_id, read_at) VALUES (?, ?, ?)`, data.messageId, ctx.userId, now);
+        // Update message status to 'read' if all participants have read it
+        await ctx.db.run(`UPDATE messages SET status = 'read' WHERE id = ? AND status != 'read'`, data.messageId);
+    }
+    ctx.broadcastAll(`conv:${data.conversationId}`, {
+        event: 'read-receipt:update',
+        data: { conversationId: data.conversationId, messageId: data.messageId, readBy: receipt },
+    });
+    // Emit message:status so clients can update delivery indicators
+    ctx.broadcastAll(`conv:${data.conversationId}`, {
+        event: 'message:status',
+        data: { messageId: data.messageId, status: 'read' },
+    });
+}
+// ── Message Reactions ────────────────────────────────────────────
+export async function handleMessageReact(ctx, data) {
+    if (ctx.db) {
+        // Toggle: if already reacted with this emoji, remove it
+        const existing = await ctx.db.get('SELECT 1 FROM message_reactions WHERE message_id = ? AND user_id = ? AND emoji = ?', data.messageId, ctx.userId, data.emoji);
+        if (existing) {
+            await ctx.db.run('DELETE FROM message_reactions WHERE message_id = ? AND user_id = ? AND emoji = ?', data.messageId, ctx.userId, data.emoji);
+        }
+        else {
+            await ctx.db.run('INSERT INTO message_reactions (message_id, user_id, emoji) VALUES (?, ?, ?)', data.messageId, ctx.userId, data.emoji);
+        }
+        // Fetch all reactions for this message
+        const reactions = await ctx.db.all('SELECT emoji, COUNT(*) as count, GROUP_CONCAT(user_id) as users FROM message_reactions WHERE message_id = ? GROUP BY emoji', data.messageId);
+        ctx.broadcastAll(`conv:${data.conversationId}`, {
+            event: 'message:reaction-update',
+            data: { messageId: data.messageId, reactions: reactions.map((r) => ({ emoji: r.emoji, count: r.count, users: r.users.split(',') })) },
+        });
+    }
+    else {
+        // Without DB, just broadcast the reaction event
+        ctx.broadcastAll(`conv:${data.conversationId}`, {
+            event: 'message:reaction-update',
+            data: { messageId: data.messageId, reactions: [{ emoji: data.emoji, count: 1, users: [ctx.userId] }] },
+        });
+    }
+}
+// ── Message Edit ────────────────────────────────────────────────
+export async function handleMessageEdit(ctx, data) {
+    const now = new Date().toISOString();
+    if (ctx.db) {
+        // Only allow sender to edit — return early if not the owner
+        const msg = await ctx.db.get('SELECT sender_id FROM messages WHERE id = ?', data.messageId);
+        if (!msg || msg.sender_id !== ctx.userId)
+            return;
+        await ctx.db.run('UPDATE messages SET content = ?, updated_at = ? WHERE id = ? AND sender_id = ?', data.content, now, data.messageId, ctx.userId);
+    }
+    ctx.broadcastAll(`conv:${data.conversationId}`, {
+        event: 'message:updated',
+        data: { messageId: data.messageId, content: data.content, updatedAt: now, editedBy: ctx.userId },
+    });
+}
+// ── Message Delete ──────────────────────────────────────────────
+export async function handleMessageDelete(ctx, data) {
+    if (ctx.db) {
+        // Only allow sender to delete — return early if not the owner
+        const msg = await ctx.db.get('SELECT sender_id FROM messages WHERE id = ?', data.messageId);
+        if (!msg || msg.sender_id !== ctx.userId)
+            return;
+        await ctx.db.run("UPDATE messages SET content = '', type = 'system', updated_at = ? WHERE id = ? AND sender_id = ?", new Date().toISOString(), data.messageId, ctx.userId);
+    }
+    ctx.broadcastAll(`conv:${data.conversationId}`, {
+        event: 'message:deleted',
+        data: { messageId: data.messageId, conversationId: data.conversationId, deletedBy: ctx.userId },
+    });
+}
+// ── Message Forward ─────────────────────────────────────────────
+export async function handleMessageForward(ctx, data) {
+    // Verify user is a participant of both source and target conversations
+    if (ctx.db) {
+        const inSource = await ctx.db.get('SELECT 1 FROM conversation_participants WHERE conversation_id = ? AND user_id = ?', data.fromConversationId, ctx.userId);
+        if (!inSource) {
+            ctx.push({ event: 'message:error', data: { code: 'FORBIDDEN', message: 'Not a participant of the source conversation' } });
+            return;
+        }
+        const inTarget = await ctx.db.get('SELECT 1 FROM conversation_participants WHERE conversation_id = ? AND user_id = ?', data.toConversationId, ctx.userId);
+        if (!inTarget) {
+            ctx.push({ event: 'message:error', data: { code: 'FORBIDDEN', message: 'Not a participant of the target conversation' } });
+            return;
+        }
+    }
+    const now = new Date().toISOString();
+    if (ctx.db) {
+        // Fetch the original message
+        const original = await ctx.db.get(`SELECT * FROM messages WHERE id = ?`, data.messageId);
+        if (!original)
+            return;
+        // Insert a forwarded copy into the target conversation
+        const fwdInserted = await ctx.db.get(`INSERT INTO messages (conversation_id, sender_id, content, type, status, encrypted, created_at, forwarded_from_conversation_id, forwarded_from_message_id)
+       VALUES (?, ?, ?, ?, 'sent', ?, ?, ?, ?) RETURNING id`, data.toConversationId, ctx.userId, original.content, original.type, original.encrypted || 0, now, data.fromConversationId, data.messageId);
+        const forwarded = {
+            id: String(fwdInserted?.id ?? 0),
+            conversationId: data.toConversationId,
+            senderId: ctx.userId,
+            content: original.content,
+            type: original.type,
+            createdAt: now,
+            status: 'sent',
+            readBy: [],
+            encrypted: !!original.encrypted,
+            forwardedFrom: {
+                conversationId: data.fromConversationId,
+                messageId: data.messageId,
+            },
+        };
+        await ctx.db.run(`UPDATE conversations SET updated_at = ? WHERE id = ?`, now, data.toConversationId);
+        ctx.broadcastAll(`conv:${data.toConversationId}`, { event: 'message:forwarded', data: forwarded });
+    }
+    else {
+        const forwarded = {
+            id: crypto.randomUUID(),
+            conversationId: data.toConversationId,
+            senderId: ctx.userId,
+            content: '',
+            type: 'text',
+            createdAt: now,
+            status: 'sent',
+            readBy: [],
+            forwardedFrom: {
+                conversationId: data.fromConversationId,
+                messageId: data.messageId,
+            },
+        };
+        ctx.broadcastAll(`conv:${data.toConversationId}`, { event: 'message:forwarded', data: forwarded });
+    }
+}

package/dist/communication/handlers/presence.d.ts

@@ -0,0 +1,15 @@
+import type { PresenceStatus } from '../types.js';
+import type { HandlerContext } from './context.js';
+export declare function handleTypingStart(ctx: HandlerContext, data: {
+    conversationId: string;
+}): void;
+export declare function handleTypingStop(ctx: HandlerContext, data: {
+    conversationId: string;
+}): void;
+/** Broadcast online status to all conversation rooms when a user connects */
+export declare function handleConnect(ctx: HandlerContext): void;
+export declare function handlePresenceUpdate(ctx: HandlerContext, data: {
+    status: PresenceStatus;
+}): void;
+/** Called on disconnect to clean up user state */
+export declare function handleDisconnect(ctx: HandlerContext, socketId: string): void;

package/dist/communication/handlers/presence.js

@@ -0,0 +1,76 @@
+// ── Typing ──────────────────────────────────────────────────────
+export function handleTypingStart(ctx, data) {
+    ctx.store.setTyping(data.conversationId, ctx.userId, () => {
+        // Auto-expire: broadcast typing stopped
+        ctx.broadcastAll(`conv:${data.conversationId}`, {
+            event: 'typing:update',
+            data: { conversationId: data.conversationId, userId: ctx.userId, isTyping: false },
+        });
+    });
+    ctx.broadcast(`conv:${data.conversationId}`, {
+        event: 'typing:update',
+        data: { conversationId: data.conversationId, userId: ctx.userId, isTyping: true },
+    });
+}
+export function handleTypingStop(ctx, data) {
+    ctx.store.clearTyping(data.conversationId, ctx.userId);
+    ctx.broadcast(`conv:${data.conversationId}`, {
+        event: 'typing:update',
+        data: { conversationId: data.conversationId, userId: ctx.userId, isTyping: false },
+    });
+}
+// ── Presence ────────────────────────────────────────────────────
+/** Broadcast online status to all conversation rooms when a user connects */
+export function handleConnect(ctx) {
+    const conversations = ctx.store.getUserConversations(ctx.userId);
+    if (conversations.size === 0)
+        return;
+    const entry = ctx.store.getPresence(ctx.userId);
+    if (!entry)
+        return;
+    const payload = {
+        event: 'presence:changed',
+        data: { userId: ctx.userId, status: entry.status, lastSeen: entry.lastSeen },
+    };
+    for (const convId of conversations) {
+        ctx.broadcastAll(`conv:${convId}`, payload);
+    }
+}
+export function handlePresenceUpdate(ctx, data) {
+    const entry = ctx.store.setPresence(ctx.userId, data.status);
+    const payload = {
+        event: 'presence:changed',
+        data: { userId: ctx.userId, status: entry.status, lastSeen: entry.lastSeen },
+    };
+    // Broadcast to all conversation rooms the user has joined
+    for (const convId of ctx.store.getUserConversations(ctx.userId)) {
+        ctx.broadcastAll(`conv:${convId}`, payload);
+    }
+}
+/** Called on disconnect to clean up user state */
+export function handleDisconnect(ctx, socketId) {
+    const userId = ctx.store.unmapUserSocket(socketId);
+    if (!userId)
+        return;
+    // Clear all typing indicators for this user
+    const clearedConversations = ctx.store.clearAllTypingForUser(userId);
+    for (const convId of clearedConversations) {
+        ctx.broadcastAll(`conv:${convId}`, {
+            event: 'typing:update',
+            data: { conversationId: convId, userId, isTyping: false },
+        });
+    }
+    // If user has no more connected sockets, set presence to offline and broadcast
+    if (!ctx.store.isUserOnline(userId)) {
+        const entry = ctx.store.setPresence(userId, 'offline');
+        const payload = {
+            event: 'presence:changed',
+            data: { userId, status: 'offline', lastSeen: entry.lastSeen },
+        };
+        // Broadcast offline to all conversation rooms before cleaning up membership
+        for (const convId of ctx.store.getUserConversations(userId)) {
+            ctx.broadcastAll(`conv:${convId}`, payload);
+        }
+        ctx.store.removeUserFromAllConversations(userId);
+    }
+}

package/dist/communication/handlers.d.ts

@@ -0,0 +1,5 @@
+export type { HandlerContext } from './handlers/context.js';
+export { handleConversationCreate, handleConversationJoin, handleConversationLeave, handleConversationArchive, handleConversationMute, handleConversationPin, } from './handlers/conversation.js';
+export { handleMessageSend, handleMessageRead, handleMessageReact, handleMessageEdit, handleMessageDelete, handleMessageForward, } from './handlers/messaging.js';
+export { handleTypingStart, handleTypingStop, handleConnect, handlePresenceUpdate, handleDisconnect, } from './handlers/presence.js';
+export { handleFileUploadRequest } from './handlers/file-upload.js';

package/dist/communication/handlers.js

@@ -0,0 +1,5 @@
+// Barrel re-export — keeps the public API identical for all existing consumers.
+export { handleConversationCreate, handleConversationJoin, handleConversationLeave, handleConversationArchive, handleConversationMute, handleConversationPin, } from './handlers/conversation.js';
+export { handleMessageSend, handleMessageRead, handleMessageReact, handleMessageEdit, handleMessageDelete, handleMessageForward, } from './handlers/messaging.js';
+export { handleTypingStart, handleTypingStop, handleConnect, handlePresenceUpdate, handleDisconnect, } from './handlers/presence.js';
+export { handleFileUploadRequest } from './handlers/file-upload.js';

package/dist/communication/index.d.ts

@@ -0,0 +1,9 @@
+export type { CommunicationConfig, RTCIceServerConfig, MediaConstraintDefaults, MediaTrackConstraintSet, Conversation, Participant, PresenceStatus, PresenceUpdate, Message, MessageStatus, MessageAttachment, ReadReceipt, TypingIndicator, MessageForward, CallType, CallState, CallEndReason, Call, CallParticipant, SignalOffer, SignalIceCandidate, SignalIceRestart, ConnectionQualityReport, CallInitiate, CallResponse, CallHangup, CallMediaToggle, CommunicationClientEvents, CommunicationServerEvents, RateLimitConfig, FileUploadConfig, ReconnectionConfig, EncryptionConfig, PreKey, KeyBundle, EncryptedEnvelope, KeyExchangeRequest, KeyExchangeResponse, NkCommunication, } from './types.js';
+export { CommunicationStore, useCommunicationStore } from './store.js';
+export type { PresenceEntry } from './store.js';
+export type { HandlerContext } from './handlers.js';
+export type { SignalingContext } from './signaling.js';
+export type { EncryptionContext } from './encryption.js';
+export { createCommunicationHandler, createCommunicationApiHandlers } from './server.js';
+export type { CommunicationHandlerOptions } from './server.js';
+export { ensureCommunicationTables } from './schema.js';

package/dist/communication/index.js

@@ -0,0 +1,7 @@
+// ── Types ─────────────────────────────────────────────────────────
+// ── Store ─────────────────────────────────────────────────────────
+export { CommunicationStore, useCommunicationStore } from './store.js';
+// ── Server (main entry points) ────────────────────────────────────
+export { createCommunicationHandler, createCommunicationApiHandlers } from './server.js';
+// ── Schema ────────────────────────────────────────────────────────
+export { ensureCommunicationTables } from './schema.js';

package/dist/communication/link-preview.d.ts

@@ -0,0 +1,18 @@
+interface LinkPreview {
+    url: string;
+    title: string | null;
+    description: string | null;
+    image: string | null;
+    domain: string;
+}
+interface Db {
+    get<T = any>(sql: string, ...params: any[]): Promise<T | undefined>;
+    run(sql: string, ...params: any[]): Promise<any>;
+}
+/**
+ * Fetch Open Graph metadata from a URL and cache it.
+ */
+export declare function fetchLinkPreview(url: string, db?: Db): Promise<LinkPreview | null>;
+/** Extract URLs from message text */
+export declare function extractUrls(text: string): string[];
+export {};

package/dist/communication/link-preview.js

@@ -0,0 +1,115 @@
+import crypto from 'node:crypto';
+function isPrivateUrl(urlStr) {
+    try {
+        const parsed = new URL(urlStr);
+        // Only allow http/https schemes
+        if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:')
+            return true;
+        const hostname = parsed.hostname.toLowerCase();
+        // Loopback and unspecified addresses
+        if (hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '[::1]' || hostname === '0.0.0.0')
+            return true;
+        // Single-label hostnames (no dots)
+        if (!hostname.includes('.'))
+            return true;
+        // Cloud metadata endpoints
+        if (hostname === 'metadata.google.internal' || hostname === 'metadata.internal')
+            return true;
+        // IPv6 addresses — block all private/reserved ranges
+        if (hostname.startsWith('[')) {
+            const ipv6 = hostname.slice(1, -1).toLowerCase();
+            if (ipv6 === '::1' || ipv6 === '::' || ipv6.startsWith('fe80:') || ipv6.startsWith('fd') || ipv6.startsWith('fc'))
+                return true;
+            return true; // Block all bracketed IPv6 for safety
+        }
+        // IPv4 private ranges
+        const parts = hostname.split('.').map(Number);
+        if (parts.length === 4 && parts.every(n => !isNaN(n))) {
+            if (parts[0] === 10)
+                return true;
+            if (parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31)
+                return true;
+            if (parts[0] === 192 && parts[1] === 168)
+                return true;
+            if (parts[0] === 169 && parts[1] === 254)
+                return true; // link-local + cloud metadata
+            if (parts[0] === 0)
+                return true;
+            if (parts[0] === 127)
+                return true; // full loopback range
+        }
+        return false;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Fetch Open Graph metadata from a URL and cache it.
+ */
+export async function fetchLinkPreview(url, db) {
+    if (isPrivateUrl(url))
+        return null;
+    const urlHash = crypto.createHash('sha256').update(url).digest('hex').slice(0, 16);
+    // Check cache
+    if (db) {
+        const cached = await db.get('SELECT * FROM link_previews WHERE url_hash = ?', urlHash);
+        if (cached) {
+            return { url: cached.url, title: cached.title, description: cached.description, image: cached.image, domain: cached.domain };
+        }
+    }
+    try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 5000);
+        const res = await fetch(url, {
+            headers: { 'User-Agent': 'LumenJS LinkPreview/1.0' },
+            signal: controller.signal,
+            redirect: 'follow',
+        });
+        clearTimeout(timeout);
+        // Re-check final URL after redirects to prevent SSRF via redirect
+        if (res.url && res.url !== url && isPrivateUrl(res.url))
+            return null;
+        if (!res.ok)
+            return null;
+        const contentType = res.headers.get('content-type') || '';
+        if (!contentType.includes('text/html'))
+            return null;
+        const html = await res.text();
+        const domain = new URL(url).hostname;
+        const title = extractMeta(html, 'og:title') || extractTag(html, 'title');
+        const description = extractMeta(html, 'og:description') || extractMeta(html, 'description');
+        const image = extractMeta(html, 'og:image');
+        const preview = { url, title, description, image, domain };
+        // Cache
+        if (db) {
+            await db.run('INSERT OR REPLACE INTO link_previews (url_hash, url, title, description, image, domain) VALUES (?, ?, ?, ?, ?, ?)', urlHash, url, title, description, image, domain);
+        }
+        return preview;
+    }
+    catch {
+        return null;
+    }
+}
+/** Extract URLs from message text */
+export function extractUrls(text) {
+    const regex = /https?:\/\/[^\s<>"')\]]+/g;
+    const matches = text.match(regex);
+    return matches ? [...new Set(matches)].slice(0, 3) : [];
+}
+function extractMeta(html, name) {
+    // Match <meta property="og:title" content="..."> or <meta name="description" content="...">
+    const regex = new RegExp(`<meta[^>]+(?:property|name)=["']${name}["'][^>]+content=["']([^"']+)["']`, 'i');
+    const match = html.match(regex);
+    if (match)
+        return match[1];
+    // Try reversed order: content before property
+    const regex2 = new RegExp(`<meta[^>]+content=["']([^"']+)["'][^>]+(?:property|name)=["']${name}["']`, 'i');
+    const match2 = html.match(regex2);
+    return match2 ? match2[1] : null;
+}
+function extractTag(html, tag) {
+    const regex = new RegExp(`<${tag}[^>]*>([^<]+)</${tag}>`, 'i');
+    const match = html.match(regex);
+    return match ? match[1].trim() : null;
+}

package/dist/communication/schema.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Communication module DB schema.
+ * Call ensureCommunicationTables(db) to create all required tables.
+ */
+interface Db {
+    exec(sql: string): Promise<void>;
+    isPg?: boolean;
+}
+export declare function ensureCommunicationTables(db: Db): Promise<void>;
+export {};

package/dist/communication/schema.js

@@ -0,0 +1,101 @@
+/**
+ * Communication module DB schema.
+ * Call ensureCommunicationTables(db) to create all required tables.
+ */
+export async function ensureCommunicationTables(db) {
+    if (db.isPg)
+        return;
+    await db.exec(`
+    CREATE TABLE IF NOT EXISTS conversations (
+      id TEXT PRIMARY KEY,
+      type TEXT NOT NULL CHECK(type IN ('direct', 'group')),
+      name TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS conversation_participants (
+      conversation_id TEXT NOT NULL,
+      user_id TEXT NOT NULL,
+      role TEXT NOT NULL DEFAULT 'member',
+      joined_at TEXT NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY (conversation_id, user_id),
+      FOREIGN KEY (conversation_id) REFERENCES conversations(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS messages (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      conversation_id TEXT NOT NULL,
+      sender_id TEXT NOT NULL,
+      content TEXT NOT NULL DEFAULT '',
+      type TEXT NOT NULL DEFAULT 'text',
+      reply_to TEXT,
+      attachment TEXT,
+      status TEXT NOT NULL DEFAULT 'sent',
+      encrypted INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT,
+      FOREIGN KEY (conversation_id) REFERENCES conversations(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS read_receipts (
+      message_id INTEGER NOT NULL,
+      user_id TEXT NOT NULL,
+      read_at TEXT NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY (message_id, user_id),
+      FOREIGN KEY (message_id) REFERENCES messages(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS encryption_keys (
+      user_id TEXT PRIMARY KEY,
+      identity_key TEXT NOT NULL,
+      signed_pre_key_id INTEGER NOT NULL,
+      signed_pre_key TEXT NOT NULL,
+      signed_pre_key_signature TEXT NOT NULL,
+      uploaded_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS encryption_prekeys (
+      user_id TEXT NOT NULL,
+      key_id INTEGER NOT NULL,
+      public_key TEXT NOT NULL,
+      PRIMARY KEY (user_id, key_id),
+      FOREIGN KEY (user_id) REFERENCES encryption_keys(user_id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS message_reactions (
+      message_id INTEGER NOT NULL,
+      user_id TEXT NOT NULL,
+      emoji TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      PRIMARY KEY (message_id, user_id, emoji),
+      FOREIGN KEY (message_id) REFERENCES messages(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS attachments (
+      id TEXT PRIMARY KEY,
+      filename TEXT NOT NULL,
+      mimetype TEXT NOT NULL,
+      size INTEGER NOT NULL,
+      url TEXT NOT NULL,
+      thumbnail_url TEXT,
+      uploaded_by TEXT NOT NULL,
+      encrypted INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS link_previews (
+      url_hash TEXT PRIMARY KEY,
+      url TEXT NOT NULL,
+      title TEXT,
+      description TEXT,
+      image TEXT,
+      domain TEXT,
+      fetched_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_messages_conversation ON messages(conversation_id, created_at);
+    CREATE INDEX IF NOT EXISTS idx_participants_user ON conversation_participants(user_id);
+    CREATE INDEX IF NOT EXISTS idx_reactions_message ON message_reactions(message_id);
+  `);
+}