@jungjaehoon/mama-core 2.4.1 → 4.1.0

package/dist/embedding-server/mobile/output-parser.js

@@ -1,241 +0,0 @@
-"use strict";
-/**
- * @fileoverview Output Parser - parses Claude Code stdout into structured events
- * @module mobile/output-parser
- * @version 1.5.0
- *
- * Parses raw stdout from Claude Code CLI, identifying message types
- * such as stream content, tool usage, completion, and errors.
- *
- * @example
- * import { OutputParser } from './output-parser';
- * const parser = new OutputParser();
- * const events = parser.parse(chunk);
- * // events: [{ type: 'stream', text: '...' }, { type: 'tool_use', tool: 'Read' }]
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OutputParser = exports.ANSI_REGEX = exports.COMPLETE_PATTERNS = exports.ERROR_PATTERNS = exports.TOOL_PATTERNS = void 0;
-/**
- * Tool detection patterns
- */
-exports.TOOL_PATTERNS = [
-    /Tool:\s*(\w+)/i,
-    /Using\s+(\w+)\s+tool/i,
-    /Calling\s+(\w+)/i,
-    /⏺\s*(\w+)/, // Claude Code uses this indicator
-    /\[(\w+)\]\s*Reading/i,
-    /\[(\w+)\]\s*Writing/i,
-    /\[(\w+)\]\s*Editing/i,
-];
-/**
- * Tool completion patterns
- */
-const TOOL_COMPLETE_PATTERNS = [
-    /Tool\s+(\w+)\s+completed/i,
-    /(\w+)\s+finished/i,
-    /✓\s*(\w+)/,
-];
-/**
- * Error patterns
- */
-exports.ERROR_PATTERNS = [
-    /Error:\s*(.+)/i,
-    /ERROR:\s*(.+)/i,
-    /Failed:\s*(.+)/i,
-    /Exception:\s*(.+)/i,
-];
-/**
- * Completion/prompt patterns
- */
-exports.COMPLETE_PATTERNS = [
-    /^>\s*$/m, // Simple prompt
-    /^\$\s*$/m, // Shell prompt
-    /^claude>\s*$/im, // Claude prompt
-    /\n\n\n$/, // Multiple empty lines
-];
-/**
- * ANSI escape code regex pattern
- */
-// eslint-disable-next-line no-control-regex
-exports.ANSI_REGEX = /\x1b\[[0-9;]*m/g;
-/**
- * OutputParser class - parses Claude Code stdout
- */
-class OutputParser {
-    buffer;
-    lastToolDetected;
-    /**
-     * Create a new OutputParser instance
-     */
-    constructor() {
-        this.buffer = '';
-        this.lastToolDetected = null;
-    }
-    /**
-     * Parse a stdout chunk into events
-     * @param chunk - Raw stdout data
-     * @returns Array of parsed events
-     */
-    parse(chunk) {
-        const text = typeof chunk === 'string' ? chunk : chunk.toString();
-        const cleanText = this.stripAnsi(text);
-        // Add to buffer for incomplete line handling
-        this.buffer += cleanText;
-        const events = [];
-        // Check for errors first (highest priority)
-        const errorResult = this.detectError(this.buffer);
-        if (errorResult) {
-            events.push({
-                type: 'error',
-                message: errorResult,
-            });
-            // Don't clear buffer entirely, might have more content
-        }
-        // Check for tool usage
-        const toolResult = this.detectToolUse(this.buffer);
-        if (toolResult) {
-            events.push({
-                type: 'tool_use',
-                tool: toolResult.tool,
-                status: 'started',
-                args: toolResult.args || null,
-            });
-            this.lastToolDetected = toolResult.tool;
-        }
-        // Check for tool completion
-        const toolComplete = this.detectToolComplete(this.buffer);
-        if (toolComplete) {
-            events.push({
-                type: 'tool_complete',
-                tool: toolComplete,
-                status: 'completed',
-            });
-        }
-        // Check for completion
-        if (this.detectComplete(this.buffer)) {
-            events.push({
-                type: 'complete',
-            });
-        }
-        // Always emit stream event with the text
-        if (cleanText.trim()) {
-            events.push({
-                type: 'stream',
-                text: cleanText,
-            });
-        }
-        // Clear buffer if we have complete lines (ends with newline)
-        if (this.buffer.endsWith('\n')) {
-            this.buffer = '';
-        }
-        else {
-            // Keep only the incomplete last line
-            const lastNewline = this.buffer.lastIndexOf('\n');
-            if (lastNewline !== -1) {
-                this.buffer = this.buffer.substring(lastNewline + 1);
-            }
-        }
-        return events;
-    }
-    /**
-     * Remove ANSI escape codes from text
-     * @param text - Text with potential ANSI codes
-     * @returns Clean text
-     */
-    stripAnsi(text) {
-        return text.replace(exports.ANSI_REGEX, '');
-    }
-    /**
-     * Detect tool usage pattern in text
-     * @param text - Text to analyze
-     * @returns Tool info or null
-     */
-    detectToolUse(text) {
-        for (const pattern of exports.TOOL_PATTERNS) {
-            const match = text.match(pattern);
-            if (match) {
-                const tool = match[1];
-                // Try to extract args if present
-                const argsMatch = text.match(new RegExp(`${tool}[:\\s]+(.+?)(?:\\n|$)`, 'i'));
-                return {
-                    tool,
-                    args: argsMatch ? argsMatch[1].trim() : null,
-                };
-            }
-        }
-        return null;
-    }
-    /**
-     * Detect tool completion pattern in text
-     * @param text - Text to analyze
-     * @returns Tool name or null
-     */
-    detectToolComplete(text) {
-        for (const pattern of TOOL_COMPLETE_PATTERNS) {
-            const match = text.match(pattern);
-            if (match) {
-                return match[1];
-            }
-        }
-        return null;
-    }
-    /**
-     * Detect completion pattern in text
-     * @param text - Text to analyze
-     * @returns True if completion detected
-     */
-    detectComplete(text) {
-        for (const pattern of exports.COMPLETE_PATTERNS) {
-            if (pattern.test(text)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Detect error pattern in text
-     * @param text - Text to analyze
-     * @returns Error message or null
-     */
-    detectError(text) {
-        for (const pattern of exports.ERROR_PATTERNS) {
-            const match = text.match(pattern);
-            if (match) {
-                return match[1].trim();
-            }
-        }
-        return null;
-    }
-    /**
-     * Flush any remaining buffer content
-     * @returns Remaining events
-     */
-    flush() {
-        const events = [];
-        if (this.buffer.trim()) {
-            events.push({
-                type: 'stream',
-                text: this.buffer,
-            });
-        }
-        this.buffer = '';
-        this.lastToolDetected = null;
-        return events;
-    }
-    /**
-     * Reset the parser state
-     */
-    reset() {
-        this.buffer = '';
-        this.lastToolDetected = null;
-    }
-    /**
-     * Get current buffer content
-     * @returns Buffer content
-     */
-    getBuffer() {
-        return this.buffer;
-    }
-}
-exports.OutputParser = OutputParser;
-//# sourceMappingURL=output-parser.js.map

package/dist/embedding-server/mobile/session-api.d.ts

@@ -1,57 +0,0 @@
-/**
- * @fileoverview Session REST API - HTTP endpoints for session management
- * @module mobile/session-api
- * @version 1.5.0
- *
- * Provides REST API endpoints for creating, listing, and terminating
- * Claude Code sessions.
- *
- * @example
- * import { createSessionHandler } from './session-api';
- * const sessionHandler = createSessionHandler(sessionManager);
- * // Use in HTTP server: if (sessionHandler(req, res)) return;
- */
-import type { IncomingMessage, ServerResponse } from 'http';
-import { SessionManager } from './session-manager.js';
-/**
- * Default WebSocket port (same as HTTP port)
- */
-export declare const DEFAULT_WS_PORT: number;
-/**
- * Request body type
- */
-interface RequestBody {
-    projectDir?: string;
-    workDir?: string;
-}
-/**
- * Parse request body as JSON
- * @param req - HTTP request
- * @returns Parsed JSON body
- */
-export declare function readBody(req: IncomingMessage): Promise<RequestBody>;
-/**
- * Extract session ID from URL path
- * @param url - Request URL
- * @returns Session ID or null
- */
-export declare function extractSessionId(url: string): string | null;
-/**
- * Get WebSocket URL for a session
- * @param req - HTTP request
- * @param sessionId - Session ID
- * @returns WebSocket URL
- */
-export declare function getWsUrl(req: IncomingMessage, sessionId: string): string;
-/**
- * Session handler function type
- */
-type SessionHandler = (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
-/**
- * Create session API request handler
- * @param sessionManager - Session manager instance (will create if not provided)
- * @returns Request handler function
- */
-export declare function createSessionHandler(sessionManager?: SessionManager | null): SessionHandler;
-export {};
-//# sourceMappingURL=session-api.d.ts.map

package/dist/embedding-server/mobile/session-api.js

@@ -1,261 +0,0 @@
-"use strict";
-/**
- * @fileoverview Session REST API - HTTP endpoints for session management
- * @module mobile/session-api
- * @version 1.5.0
- *
- * Provides REST API endpoints for creating, listing, and terminating
- * Claude Code sessions.
- *
- * @example
- * import { createSessionHandler } from './session-api';
- * const sessionHandler = createSessionHandler(sessionManager);
- * // Use in HTTP server: if (sessionHandler(req, res)) return;
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_WS_PORT = void 0;
-exports.readBody = readBody;
-exports.extractSessionId = extractSessionId;
-exports.getWsUrl = getWsUrl;
-exports.createSessionHandler = createSessionHandler;
-const session_manager_js_1 = require("./session-manager.js");
-const auth_js_1 = require("./auth.js");
-function resolveConfiguredPort() {
-    const rawPort = process.env.MAMA_EMBEDDING_PORT || process.env.MAMA_HTTP_PORT || '';
-    const parsedPort = parseInt(rawPort, 10);
-    if (Number.isInteger(parsedPort) && parsedPort > 0 && parsedPort < 65536) {
-        return parsedPort;
-    }
-    return 3849;
-}
-/**
- * Default WebSocket port (same as HTTP port)
- */
-exports.DEFAULT_WS_PORT = resolveConfiguredPort();
-/**
- * Parse request body as JSON
- * @param req - HTTP request
- * @returns Parsed JSON body
- */
-function readBody(req) {
-    return new Promise((resolve, reject) => {
-        let data = '';
-        req.on('data', (chunk) => (data += chunk));
-        req.on('end', () => {
-            try {
-                if (!data) {
-                    resolve({});
-                }
-                else {
-                    resolve(JSON.parse(data));
-                }
-            }
-            catch {
-                reject(new Error('Invalid JSON'));
-            }
-        });
-        req.on('error', reject);
-    });
-}
-/**
- * Extract session ID from URL path
- * @param url - Request URL
- * @returns Session ID or null
- */
-function extractSessionId(url) {
-    const match = url.match(/\/api\/sessions\/([^/?]+)/);
-    return match ? match[1] : null;
-}
-/**
- * Get WebSocket URL for a session
- * @param req - HTTP request
- * @param sessionId - Session ID
- * @returns WebSocket URL
- */
-function getWsUrl(req, sessionId) {
-    const host = req.headers.host || `localhost:${exports.DEFAULT_WS_PORT}`;
-    const protocol = req.headers['x-forwarded-proto'] === 'https' ? 'wss' : 'ws';
-    return `${protocol}://${host}/ws?session=${sessionId}`;
-}
-/**
- * Create session API request handler
- * @param sessionManager - Session manager instance (will create if not provided)
- * @returns Request handler function
- */
-function createSessionHandler(sessionManager = null) {
-    // Create session manager if not provided
-    const manager = sessionManager || new session_manager_js_1.SessionManager();
-    let initialized = false;
-    /**
-     * Handle session API requests
-     * @param req - HTTP request
-     * @param res - HTTP response
-     * @returns True if request was handled
-     */
-    return async function handleSessionRequest(req, res) {
-        const url = new URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
-        const pathname = url.pathname;
-        // Only handle /api/session routes (includes /api/sessions and /api/session/create)
-        if (!pathname.startsWith('/api/session')) {
-            return false;
-        }
-        // Initialize manager on first request
-        if (!initialized) {
-            try {
-                await manager.initDB();
-                initialized = true;
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                console.error('[SessionAPI] Failed to initialize:', message);
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Session manager initialization failed' }));
-                return true;
-            }
-        }
-        // Set common headers
-        res.setHeader('Content-Type', 'application/json');
-        res.setHeader('Access-Control-Allow-Origin', '*');
-        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
-        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
-        // Handle CORS preflight
-        if (req.method === 'OPTIONS') {
-            res.writeHead(204);
-            res.end();
-            return true;
-        }
-        // Authentication check
-        if (!(0, auth_js_1.authenticate)(req)) {
-            res.writeHead(401, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ error: 'Unauthorized' }));
-            return true;
-        }
-        try {
-            // GET /api/sessions - List active sessions
-            if (pathname === '/api/sessions' && req.method === 'GET') {
-                const sessions = await manager.getActiveSessions();
-                res.writeHead(200);
-                res.end(JSON.stringify({
-                    sessions: sessions.map((s) => ({
-                        id: s.id,
-                        projectDir: s.projectDir,
-                        status: s.status,
-                        createdAt: s.createdAt,
-                        lastActive: s.lastActive,
-                        isAlive: s.isAlive,
-                    })),
-                }));
-                return true;
-            }
-            // POST /api/sessions - Create new session
-            // Alias: POST /api/session/create
-            if ((pathname === '/api/sessions' || pathname === '/api/session/create') &&
-                req.method === 'POST') {
-                const body = await readBody(req);
-                const projectDir = body.projectDir || body.workDir || '.';
-                try {
-                    const { sessionId } = await manager.createSession(projectDir);
-                    const wsUrl = getWsUrl(req, sessionId);
-                    res.writeHead(201);
-                    res.end(JSON.stringify({
-                        sessionId,
-                        wsUrl,
-                        status: 'active',
-                    }));
-                }
-                catch (err) {
-                    const message = err instanceof Error ? err.message : String(err);
-                    console.error('[SessionAPI] Failed to create session:', message);
-                    res.writeHead(500);
-                    res.end(JSON.stringify({ error: 'Failed to create session', details: message }));
-                }
-                return true;
-            }
-            // DELETE /api/sessions/:id - Terminate session
-            if (pathname.startsWith('/api/sessions/') && req.method === 'DELETE') {
-                const sessionId = extractSessionId(pathname);
-                if (!sessionId) {
-                    res.writeHead(400);
-                    res.end(JSON.stringify({ error: 'Missing session ID' }));
-                    return true;
-                }
-                const terminated = await manager.terminateSession(sessionId);
-                if (terminated) {
-                    res.writeHead(200);
-                    res.end(JSON.stringify({ success: true, sessionId }));
-                }
-                else {
-                    res.writeHead(404);
-                    res.end(JSON.stringify({ error: 'Session not found', sessionId }));
-                }
-                return true;
-            }
-            // GET /api/sessions/last-active - Get the most recently active session
-            // NOTE: This must come BEFORE the generic :id handler to avoid being matched as an ID
-            if (pathname === '/api/sessions/last-active' && req.method === 'GET') {
-                const sessions = await manager.getActiveSessions();
-                if (sessions.length > 0) {
-                    // Sort by lastActive descending and get the first one
-                    const sorted = sessions.sort((a, b) => {
-                        const aTime = a.lastActive ? new Date(a.lastActive).getTime() : 0;
-                        const bTime = b.lastActive ? new Date(b.lastActive).getTime() : 0;
-                        return bTime - aTime;
-                    });
-                    const lastSession = sorted[0];
-                    res.writeHead(200);
-                    res.end(JSON.stringify({
-                        id: lastSession.id,
-                        projectDir: lastSession.projectDir,
-                        status: lastSession.status,
-                        createdAt: lastSession.createdAt,
-                        lastActive: lastSession.lastActive,
-                        isAlive: lastSession.isAlive,
-                    }));
-                }
-                else {
-                    res.writeHead(404);
-                    res.end(JSON.stringify({ error: 'No active sessions found' }));
-                }
-                return true;
-            }
-            // GET /api/sessions/:id - Get single session (bonus endpoint)
-            if (pathname.startsWith('/api/sessions/') && req.method === 'GET') {
-                const sessionId = extractSessionId(pathname);
-                if (!sessionId) {
-                    res.writeHead(400);
-                    res.end(JSON.stringify({ error: 'Missing session ID' }));
-                    return true;
-                }
-                const session = manager.getSession(sessionId);
-                if (session) {
-                    res.writeHead(200);
-                    res.end(JSON.stringify({
-                        id: sessionId,
-                        projectDir: session.projectDir,
-                        status: 'active',
-                        createdAt: session.createdAt,
-                        clientId: session.clientId,
-                        isAlive: session.daemon?.isActive() || false,
-                    }));
-                }
-                else {
-                    res.writeHead(404);
-                    res.end(JSON.stringify({ error: 'Session not found', sessionId }));
-                }
-                return true;
-            }
-            // Unknown /api/sessions route
-            res.writeHead(404);
-            res.end(JSON.stringify({ error: 'Not found' }));
-            return true;
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error('[SessionAPI] Error:', message);
-            res.writeHead(500);
-            res.end(JSON.stringify({ error: 'Internal server error', details: message }));
-            return true;
-        }
-    };
-}
-//# sourceMappingURL=session-api.js.map

package/dist/embedding-server/mobile/session-manager.d.ts

@@ -1,138 +0,0 @@
-/**
- * @fileoverview Session Manager - tracks multiple Claude Code sessions in SQLite
- * @module mobile/session-manager
- * @version 1.5.0
- *
- * Manages session lifecycle including creation, tracking, and termination.
- * Sessions are persisted to SQLite for durability across server restarts.
- *
- * @example
- * import { SessionManager } from './session-manager';
- * const manager = new SessionManager();
- * await manager.initDB();
- * const { sessionId, daemon } = await manager.createSession('/path/to/project');
- */
-import { ClaudeDaemon } from './daemon.js';
-/**
- * Default database path
- */
-export declare const DEFAULT_DB_PATH: string;
-/**
- * Sessions table creation SQL
- */
-export declare const CREATE_SESSIONS_TABLE: string;
-/**
- * In-memory session data
- */
-interface MemorySession {
-    daemon: ClaudeDaemon;
-    clientId: string | null;
-    projectDir: string;
-    createdAt: string;
-}
-/**
- * Session info returned from getActiveSessions
- */
-export interface SessionInfo {
-    id: string;
-    projectDir: string;
-    createdAt: string | undefined;
-    lastActive: string | undefined;
-    status: string;
-    pid: number | null;
-    clientId: string | null;
-    isAlive: boolean;
-}
-/**
- * Create session result
- */
-export interface CreateSessionResult {
-    sessionId: string;
-    daemon: ClaudeDaemon;
-}
-/**
- * SessionManager class - manages Claude Code sessions
- */
-export declare class SessionManager {
-    private dbPath;
-    private sessions;
-    private db;
-    private initialized;
-    private cleanupPromise;
-    private cleanupHandlersRegistered;
-    private handleProcessExit;
-    /**
-     * Create a new SessionManager instance
-     * @param dbPath - Path to SQLite database
-     */
-    constructor(dbPath?: string);
-    /**
-     * Initialize the SQLite database and create sessions table
-     */
-    initDB(): Promise<void>;
-    /**
-     * Create a new Claude Code session
-     * @param projectDir - Working directory for the session
-     * @returns Session ID and daemon
-     */
-    createSession(projectDir: string): Promise<CreateSessionResult>;
-    /**
-     * Get all active sessions
-     * @returns Array of active session info
-     */
-    getActiveSessions(): Promise<SessionInfo[]>;
-    /**
-     * Terminate a session by ID
-     * @param sessionId - Session to terminate
-     * @returns True if session was terminated
-     */
-    terminateSession(sessionId: string): Promise<boolean>;
-    /**
-     * Get a session by ID
-     * @param sessionId - Session ID to look up
-     * @returns Session data or undefined
-     */
-    getSession(sessionId: string): MemorySession | undefined;
-    /**
-     * Update session's last active timestamp
-     * @param sessionId - Session ID
-     */
-    touchSession(sessionId: string): void;
-    /**
-     * Assign a client to a session
-     * @param sessionId - Session ID
-     * @param clientId - Client ID
-     */
-    assignClient(sessionId: string, clientId: string): void;
-    /**
-     * Remove client assignment from a session
-     * @param sessionId - Session ID
-     */
-    unassignClient(sessionId: string): void;
-    /**
-     * Get session count
-     * @returns Number of active sessions
-     */
-    getSessionCount(): number;
-    /**
-     * Terminate all active sessions
-     * @returns Number of sessions terminated
-     */
-    terminateAll(): Promise<number>;
-    /**
-     * Setup daemon event handlers
-     * @private
-     */
-    private _setupDaemonHandlers;
-    /**
-     * Setup process cleanup handlers
-     * @private
-     */
-    private _setupProcessCleanup;
-    /**
-     * Close the database connection
-     */
-    close(): void;
-}
-export {};
-//# sourceMappingURL=session-manager.d.ts.map