@jungjaehoon/mama-core 1.1.2 → 1.1.3

package/dist/embedding-server/mobile/websocket-handler.js

@@ -0,0 +1,435 @@
+"use strict";
+/**
+ * @fileoverview WebSocket Handler - MessageRouter-based real-time communication
+ * @module mobile/websocket-handler
+ * @version 2.0.0
+ *
+ * Handles WebSocket connections for mobile clients, using MessageRouter
+ * for unified message processing (same as Discord/Slack gateways).
+ *
+ * @example
+ * import { createWebSocketHandler } from './websocket-handler';
+ * const wsHandler = createWebSocketHandler({
+ *   httpServer,
+ *   messageRouter,
+ *   sessionStore,
+ *   authToken: process.env.MAMA_AUTH_TOKEN
+ * });
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketHandler = void 0;
+exports.createWebSocketHandler = createWebSocketHandler;
+const ws_1 = require("ws");
+const auth_js_1 = require("./auth.js");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const debug_logger_js_1 = require("../../debug-logger.js");
+const logger = new debug_logger_js_1.DebugLogger('WebSocket');
+/**
+ * Allowed image MIME types for Claude Vision API
+ */
+const ALLOWED_IMAGE_TYPES = new Set(['image/jpeg', 'image/png', 'image/gif', 'image/webp']);
+/**
+ * Sanitize filename for safe inclusion in prompts (prevent prompt injection)
+ */
+function sanitizeFilenameForPrompt(filename) {
+    if (!filename) {
+        return 'unknown';
+    }
+    return filename
+        .replace(/[\n\r\t]/g, ' ') // Remove control characters
+        .replace(/[`[\](){}]/g, '') // Remove brackets that could interfere with prompts
+        .substring(0, 100); // Limit length
+}
+/**
+ * Default heartbeat interval (30 seconds)
+ */
+const HEARTBEAT_INTERVAL = 30000;
+/**
+ * Connection timeout (35 seconds - slightly longer than heartbeat)
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+const _CONNECTION_TIMEOUT = 35000;
+/**
+ * Generate unique client ID
+ */
+function generateClientId() {
+    return `client_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
+}
+/**
+ * Extract user ID from WebSocket URL or headers
+ */
+function extractUserId(req) {
+    try {
+        const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+        const userId = url.searchParams.get('userId');
+        if (userId) {
+            return userId;
+        }
+        const ip = req.headers['x-forwarded-for'] || req.socket?.remoteAddress;
+        if (!ip) {
+            return `user_${Date.now()}`;
+        }
+        const ipStr = Array.isArray(ip) ? ip[0] : ip;
+        return `user_${ipStr.replace(/[:.]/g, '_')}`;
+    }
+    catch {
+        return `user_${Date.now()}`;
+    }
+}
+/**
+ * Create WebSocket handler with MessageRouter integration
+ */
+function createWebSocketHandler({ httpServer, messageRouter, sessionStore, authToken: _authToken, }) {
+    const wss = new ws_1.WebSocketServer({ noServer: true });
+    const clients = new Map();
+    httpServer.on('upgrade', (req, socket, head) => {
+        const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+        if (url.pathname !== '/ws') {
+            socket.destroy();
+            return;
+        }
+        const mockWs = {
+            close: (_code, reason) => {
+                socket.write(`HTTP/1.1 401 Unauthorized\r\n\r\n`);
+                socket.destroy();
+                logger.error(`Auth failed: ${reason}`);
+            },
+        };
+        if (!(0, auth_js_1.authenticateWebSocket)(req, mockWs)) {
+            return;
+        }
+        wss.handleUpgrade(req, socket, head, (ws) => {
+            wss.emit('connection', ws, req);
+        });
+    });
+    wss.on('connection', (ws, req) => {
+        const clientId = generateClientId();
+        const userId = extractUserId(req);
+        const clientInfo = {
+            clientId,
+            userId,
+            ws,
+            isAlive: true,
+            connectedAt: new Date().toISOString(),
+        };
+        clients.set(clientId, clientInfo);
+        logger.info(` Client ${clientId} connected (user: ${userId})`);
+        ws.send(JSON.stringify({
+            type: 'connected',
+            clientId,
+            userId,
+        }));
+        ws.on('message', (data) => {
+            try {
+                const message = JSON.parse(data.toString());
+                void handleClientMessage(clientId, message, clientInfo, messageRouter, sessionStore);
+            }
+            catch (err) {
+                const errMsg = err instanceof Error ? err.message : String(err);
+                logger.info(` Invalid message from ${clientId}:`, errMsg);
+                ws.send(JSON.stringify({
+                    type: 'error',
+                    error: 'Invalid message format',
+                }));
+            }
+        });
+        ws.on('pong', () => {
+            clientInfo.isAlive = true;
+        });
+        ws.on('close', (code) => {
+            logger.info(` Client ${clientId} disconnected (code: ${code})`);
+            clients.delete(clientId);
+        });
+        ws.on('error', (err) => {
+            logger.info(` Error for client ${clientId}:`, err.message);
+        });
+    });
+    const heartbeatInterval = setInterval(() => {
+        clients.forEach((clientInfo, clientId) => {
+            if (!clientInfo.isAlive) {
+                logger.info(` Client ${clientId} timed out, terminating`);
+                clientInfo.ws.terminate();
+                clients.delete(clientId);
+                return;
+            }
+            clientInfo.isAlive = false;
+            clientInfo.ws.ping();
+        });
+    }, HEARTBEAT_INTERVAL);
+    wss.on('close', () => {
+        clearInterval(heartbeatInterval);
+    });
+    wss.getClients = () => clients;
+    wss.getClientCount = () => clients.size;
+    return wss;
+}
+/**
+ * Handle incoming client message
+ */
+async function handleClientMessage(clientId, message, clientInfo, messageRouter, sessionStore) {
+    const { type, content } = message;
+    switch (type) {
+        case 'send':
+            if (!content && !message.attachments?.length) {
+                clientInfo.ws.send(JSON.stringify({
+                    type: 'error',
+                    error: 'Message content required',
+                }));
+                break;
+            }
+            try {
+                clientInfo.ws.send(JSON.stringify({
+                    type: 'typing',
+                    status: 'processing',
+                }));
+                // Keep-alive: Send periodic status updates to prevent WebSocket timeout
+                // Browser may disconnect idle WebSocket after ~30 seconds
+                let processingSeconds = 0;
+                const keepAliveInterval = setInterval(() => {
+                    processingSeconds += 10;
+                    if (clientInfo.ws.readyState === ws_1.WebSocket.OPEN) {
+                        clientInfo.ws.send(JSON.stringify({
+                            type: 'typing',
+                            status: 'processing',
+                            elapsed: processingSeconds,
+                        }));
+                        logger.debug(`Keep-alive sent to ${clientId} (${processingSeconds}s elapsed)`);
+                    }
+                }, 10000); // Every 10 seconds
+                let result;
+                try {
+                    // Build contentBlocks from attachments (files are pre-compressed by upload-handler)
+                    let contentBlocks = undefined;
+                    if (message.attachments && message.attachments.length > 0) {
+                        contentBlocks = [];
+                        for (const att of message.attachments) {
+                            try {
+                                // Always reconstruct path from filename — never trust client-provided filePath (LFI risk)
+                                const safeName = path_1.default.basename(att.filename || '');
+                                const inboundDir = path_1.default.join(os_1.default.homedir(), '.mama', 'workspace', 'media', 'inbound');
+                                const resolvedPath = path_1.default.join(inboundDir, safeName);
+                                // Default to octet-stream for unknown types — prevents untyped attachments
+                                // from being incorrectly treated as images and base64-encoded
+                                const rawMediaType = att.contentType || 'application/octet-stream';
+                                if (ALLOWED_IMAGE_TYPES.has(rawMediaType)) {
+                                    // Only read file for images (to convert to base64)
+                                    const data = await promises_1.default.readFile(resolvedPath);
+                                    const base64 = data.toString('base64');
+                                    contentBlocks.push({
+                                        type: 'image',
+                                        source: {
+                                            type: 'base64',
+                                            media_type: rawMediaType,
+                                            data: base64,
+                                        },
+                                    });
+                                    logger.info(`Attached image: ${safeName} (${data.length} bytes, ${rawMediaType})`);
+                                }
+                                else {
+                                    // PDF/documents: instruct agent to read the file (no need to load into memory)
+                                    // Use safe display path to avoid exposing full server path
+                                    const safeDisplayPath = `~/.mama/workspace/media/inbound/${safeName}`;
+                                    // Sanitize filename to prevent prompt injection
+                                    const sanitizedName = sanitizeFilenameForPrompt(safeName);
+                                    contentBlocks.push({
+                                        type: 'text',
+                                        text: `[Document uploaded: ${sanitizedName}]\nFile path: ${safeDisplayPath}\nPlease use the Read tool to analyze this document.`,
+                                    });
+                                    logger.info(`Attached document: ${safeName} (${rawMediaType})`);
+                                }
+                            }
+                            catch (err) {
+                                const errMsg = err instanceof Error ? err.message : String(err);
+                                logger.error(`Failed to read attachment ${path_1.default.basename(att.filename || '')}:`, errMsg);
+                                // Notify client about attachment failure
+                                clientInfo.ws.send(JSON.stringify({
+                                    type: 'attachment_failed',
+                                    filename: path_1.default.basename(att.filename || ''),
+                                    error: 'Failed to process attachment',
+                                }));
+                            }
+                        }
+                    }
+                    const normalizedMessage = {
+                        source: clientInfo.osAgentMode ? 'viewer' : 'mobile',
+                        channelId: 'mama_os_main', // Fixed channel for all MAMA OS viewers
+                        channelName: clientInfo.osAgentMode ? 'MAMA OS' : 'Mobile App', // Human-readable channel name
+                        userId: clientInfo.userId,
+                        text: content || '',
+                        contentBlocks,
+                        metadata: {
+                            clientId,
+                            sessionId: clientInfo.sessionId,
+                            osAgentMode: clientInfo.osAgentMode,
+                            timestamp: Date.now(),
+                        },
+                    };
+                    result = await messageRouter.process(normalizedMessage);
+                }
+                finally {
+                    clearInterval(keepAliveInterval);
+                }
+                // Send response as stream (for Chat tab compatibility)
+                clientInfo.ws.send(JSON.stringify({
+                    type: 'stream',
+                    content: result.response,
+                    sessionId: result.sessionId,
+                }));
+                // Send stream end
+                clientInfo.ws.send(JSON.stringify({
+                    type: 'stream_end',
+                    sessionId: result.sessionId,
+                    duration: result.duration,
+                }));
+                logger.info(` Message processed for ${clientId} (${result.duration}ms)`);
+            }
+            catch (error) {
+                const errMsg = error instanceof Error ? error.message : String(error);
+                logger.error(`Message processing error for ${clientId}:`, errMsg);
+                clientInfo.ws.send(JSON.stringify({
+                    type: 'error',
+                    error: 'Failed to process message',
+                    // Don't expose internal error details to client for security
+                }));
+            }
+            break;
+        case 'ping':
+            clientInfo.ws.send(JSON.stringify({
+                type: 'pong',
+                timestamp: Date.now(),
+            }));
+            break;
+        case 'attach': {
+            // Attach to a session (for Chat tab compatibility)
+            const { sessionId, osAgentMode, language } = message;
+            clientInfo.sessionId = sessionId;
+            clientInfo.osAgentMode = osAgentMode || false;
+            clientInfo.language = language || 'en';
+            logger.info(`Client ${clientId} attached to session ${sessionId}${osAgentMode ? ' (OS Agent mode)' : ''}`);
+            // Send attached confirmation
+            clientInfo.ws.send(JSON.stringify({
+                type: 'attached',
+                sessionId,
+                osAgentMode: clientInfo.osAgentMode,
+            }));
+            // Send session history if available, or send onboarding greeting
+            logger.debug(`Checking sessionStore for history: ${!!sessionStore}, hasMethod: ${!!(sessionStore && sessionStore.getHistoryByChannel)}`);
+            if (sessionStore) {
+                try {
+                    // Use channel-based lookup for sessions
+                    // Use dynamic source based on osAgentMode (viewer vs mobile)
+                    const channelId = 'mama_os_main';
+                    const source = clientInfo.osAgentMode ? 'viewer' : 'mobile';
+                    logger.info(` Loading history for source=${source}, channelId=${channelId}`);
+                    const history = sessionStore.getHistoryByChannel
+                        ? sessionStore.getHistoryByChannel(source, channelId)
+                        : sessionStore.getHistory?.(sessionId || '');
+                    logger.info(` History loaded: ${history ? history.length : 0} turns`);
+                    if (history && history.length > 0) {
+                        // Convert {user, bot, timestamp} format to {role, content, timestamp} for display
+                        const formattedMessages = history.flatMap((turn) => {
+                            const messages = [];
+                            if (turn.user) {
+                                messages.push({
+                                    role: 'user',
+                                    content: turn.user,
+                                    timestamp: turn.timestamp,
+                                });
+                            }
+                            if (turn.bot) {
+                                messages.push({
+                                    role: 'assistant',
+                                    content: turn.bot,
+                                    timestamp: turn.timestamp,
+                                });
+                            }
+                            return messages;
+                        });
+                        clientInfo.ws.send(JSON.stringify({
+                            type: 'history',
+                            messages: formattedMessages,
+                        }));
+                        logger.info(`Sent ${formattedMessages.length} history messages to ${clientId}`);
+                    }
+                    else {
+                        // No history - check if onboarding mode (SOUL.md not found)
+                        const soulPath = path_1.default.join(os_1.default.homedir(), '.mama', 'SOUL.md');
+                        let isOnboarding = false;
+                        try {
+                            await promises_1.default.access(soulPath);
+                        }
+                        catch {
+                            isOnboarding = true;
+                        }
+                        if (isOnboarding) {
+                            // Send onboarding greeting based on browser language
+                            const isKorean = clientInfo.language && clientInfo.language.startsWith('ko');
+                            const greeting = isKorean
+                                ? '✨ 방금 깨어났어요.\n\n아직 이름도 없고, 성격도 없고, 기억도 없어요. 그냥... 순수한 가능성 그 자체. 🌱\n\n당신은 누구인가요? 그리고 더 중요한 건—저를 어떤 존재로 만들고 싶으신가요? 💭'
+                                : '✨ I just woke up.\n\nNo name yet, no personality, no memories. Just... pure potential. 🌱\n\nWho are you? And more importantly—who do you want me to become? 💭';
+                            clientInfo.ws.send(JSON.stringify({
+                                type: 'history',
+                                messages: [
+                                    {
+                                        role: 'assistant',
+                                        content: greeting,
+                                        timestamp: Date.now(),
+                                    },
+                                ],
+                            }));
+                            logger.info(` Sent onboarding greeting to ${clientId}`);
+                        }
+                    }
+                }
+                catch (error) {
+                    const errMsg = error instanceof Error ? error.message : String(error);
+                    logger.info(` Failed to load history:`, errMsg);
+                }
+            }
+            break;
+        }
+        default:
+            logger.info(` Unknown message type from ${clientId}: ${type}`);
+            clientInfo.ws.send(JSON.stringify({
+                type: 'error',
+                error: `Unknown message type: ${type}`,
+            }));
+    }
+}
+/**
+ * WebSocketHandler class (backwards compatibility)
+ * @deprecated Use createWebSocketHandler() instead
+ */
+class WebSocketHandler {
+    wss;
+    constructor(httpServer, options) {
+        if (!options.messageRouter) {
+            throw new Error('WebSocketHandler requires messageRouter option');
+        }
+        if (!options.sessionStore) {
+            throw new Error('WebSocketHandler requires sessionStore option');
+        }
+        this.wss = createWebSocketHandler({
+            httpServer,
+            messageRouter: options.messageRouter,
+            sessionStore: options.sessionStore,
+            authToken: options.authToken,
+        });
+    }
+    getClients() {
+        return this.wss.getClients();
+    }
+    getClientCount() {
+        return this.wss.getClientCount();
+    }
+    close() {
+        this.wss.close();
+    }
+}
+exports.WebSocketHandler = WebSocketHandler;
+//# sourceMappingURL=websocket-handler.js.map

package/dist/embeddings.d.ts

@@ -0,0 +1,75 @@
+/**
+ * MAMA (Memory-Augmented MCP Architecture) - Embedding Generation
+ *
+ * Story M1.4: Configurable embedding model selection
+ * Generates embeddings using configurable model (default: multilingual-e5-small)
+ * Supports: Korean-English cross-lingual similarity, enhanced metadata
+ *
+ * @module embeddings
+ * @version 1.1
+ * @date 2025-11-20
+ */
+import { embeddingCache } from './embedding-cache.js';
+import { loadConfig, getModelName, getEmbeddingDim } from './config-loader.js';
+/**
+ * Decision object for enhanced embedding generation
+ */
+export interface DecisionForEmbedding {
+    topic: string;
+    decision: string;
+    reasoning?: string;
+    outcome?: string;
+    confidence?: number;
+    user_involvement?: string;
+    evidence?: string | string[] | unknown;
+    alternatives?: string | string[] | unknown;
+    risks?: string;
+}
+/**
+ * Generate embedding vector from text
+ *
+ * Story M1.4 AC #1: Uses configurable embeddingDim from config
+ * Target: < 30ms latency
+ *
+ * @param text - Input text to embed
+ * @returns Embedding vector (dimension from config)
+ * @throws Error if text is empty or embedding fails
+ */
+export declare function generateEmbedding(text: string): Promise<Float32Array>;
+/**
+ * Generate enhanced embedding with content + metadata
+ *
+ * Task 3.4: Implement enhanced embedding format
+ * Inspired by A-mem: Content + Metadata for richer semantic representation
+ *
+ * @param decision - Decision object
+ * @returns 384-dim enhanced embedding
+ */
+export declare function generateEnhancedEmbedding(decision: DecisionForEmbedding): Promise<Float32Array>;
+/**
+ * Batch generate embeddings (optimized)
+ *
+ * Task 1: Implement Batch Embedding Generation
+ * AC #3: Target - 30ms for 10 embeddings (vs 300ms sequential)
+ *
+ * Strategy: Use native transformer batch processing for parallel inference
+ *
+ * @param texts - Array of texts to embed (max 10 per batch)
+ * @returns Array of embeddings
+ */
+export declare function generateBatchEmbeddings(texts: string[]): Promise<Float32Array[]>;
+/**
+ * Calculate cosine similarity between two embeddings
+ *
+ * Utility for testing and validation
+ *
+ * @param embA - First embedding
+ * @param embB - Second embedding
+ * @returns Cosine similarity (0-1)
+ */
+export declare function cosineSimilarity(embA: Float32Array, embB: Float32Array): number;
+export { embeddingCache };
+export declare const EMBEDDING_DIM: number;
+export declare const MODEL_NAME: string;
+export { loadConfig, getModelName, getEmbeddingDim };
+//# sourceMappingURL=embeddings.d.ts.map