@jungjaehoon/mama-core 2.4.1 → 4.0.0

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

@@ -1,486 +0,0 @@
-"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()}`;
-    }
-}
-/**
- * Safe send helper - guards against closed socket with try-catch for race conditions
- */
-function safeSend(ws, data) {
-    if (ws.readyState === ws_1.WebSocket.OPEN) {
-        try {
-            ws.send(data);
-            return true;
-        }
-        catch {
-            // Socket may have closed between readyState check and send
-            return false;
-        }
-    }
-    return false;
-}
-/**
- * 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;
-                let deltasSent = false;
-                let toolIndex = 0;
-                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, {
-                        onQueued: () => {
-                            // Guard: check if socket is still open before sending
-                            if (clientInfo.ws.readyState !== ws_1.WebSocket.OPEN) {
-                                return;
-                            }
-                            // Notify client that message is queued (session busy)
-                            try {
-                                clientInfo.ws.send(JSON.stringify({
-                                    type: 'queued',
-                                    message: '⏳ 이전 요청 처리 중... 대기열에 추가되었습니다.',
-                                }));
-                            }
-                            catch (err) {
-                                logger.warn('Queued notification failed:', err instanceof Error ? err.message : String(err));
-                            }
-                            logger.info(`Message queued for ${clientId} (session busy)`);
-                        },
-                        onStream: {
-                            onDelta: (text) => {
-                                deltasSent = true;
-                                safeSend(clientInfo.ws, JSON.stringify({ type: 'stream', content: text }));
-                            },
-                            onToolUse: (tool, input) => {
-                                const idx = toolIndex++;
-                                safeSend(clientInfo.ws, JSON.stringify({ type: 'tool_use', tool, index: idx, input }));
-                            },
-                            onToolComplete: (tool, _toolUseId, isError) => {
-                                safeSend(clientInfo.ws, JSON.stringify({ type: 'tool_complete', tool, index: toolIndex - 1, isError }));
-                            },
-                        },
-                    });
-                }
-                finally {
-                    clearInterval(keepAliveInterval);
-                }
-                // Only send full response if no deltas were streamed (Codex fallback)
-                if (!deltasSent) {
-                    safeSend(clientInfo.ws, JSON.stringify({
-                        type: 'stream',
-                        content: result.response,
-                        sessionId: result.sessionId,
-                    }));
-                }
-                // Always send stream end
-                safeSend(clientInfo.ws, 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);
-                safeSend(clientInfo.ws, 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

@@ -1,68 +0,0 @@
-/**
- * MAMA (Memory-Augmented MCP Architecture) - Embedding Generation
- *
- * Story M1.4: Configurable embedding model selection
- * Generates embeddings using configurable model (default: multilingual-e5-large)
- * 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, getQuantized } from './config-loader.js';
-export declare const EMBEDDING_MODEL_MAX_LENGTH = 512;
-export declare const EMBEDDING_MAX_TOKENISH_SEGMENTS = 480;
-export type EmbeddingRole = 'passage' | 'query';
-export declare const EMBEDDING_PREFIX_SCHEME = "e5-prefixed-v1";
-export declare function prepareEmbeddingText(text: string): string;
-/**
- * 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, role?: EmbeddingRole): 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 1024-dim enhanced embedding
- */
-export declare function generateEnhancedEmbedding(decision: DecisionForEmbedding, role?: EmbeddingRole): 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, getQuantized };
-//# sourceMappingURL=embeddings.d.ts.map