@jungjaehoon/mama-core 2.4.1 → 4.1.0

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

@@ -1,378 +0,0 @@
-"use strict";
-/**
- * @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');
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionManager = exports.CREATE_SESSIONS_TABLE = exports.DEFAULT_DB_PATH = void 0;
-const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
-const daemon_js_1 = require("./daemon.js");
-/**
- * Default database path
- */
-exports.DEFAULT_DB_PATH = process.env.MAMA_DB_PATH || path_1.default.join(os_1.default.homedir(), '.claude', 'mama-memory.db');
-/**
- * Sessions table creation SQL
- */
-exports.CREATE_SESSIONS_TABLE = `
-  CREATE TABLE IF NOT EXISTS sessions (
-    id TEXT PRIMARY KEY,
-    project_path TEXT,
-    created_at TEXT DEFAULT (datetime('now')),
-    last_active TEXT DEFAULT (datetime('now')),
-    status TEXT DEFAULT 'active',
-    pid INTEGER,
-    client_id TEXT
-  )
-`;
-/**
- * Create index for status queries
- */
-const CREATE_STATUS_INDEX = `
-  CREATE INDEX IF NOT EXISTS idx_sessions_status ON sessions(status)
-`;
-/**
- * SessionManager class - manages Claude Code sessions
- */
-class SessionManager {
-    dbPath;
-    sessions;
-    db;
-    initialized;
-    cleanupPromise;
-    cleanupHandlersRegistered;
-    handleProcessExit;
-    /**
-     * Create a new SessionManager instance
-     * @param dbPath - Path to SQLite database
-     */
-    constructor(dbPath = exports.DEFAULT_DB_PATH) {
-        this.dbPath = dbPath;
-        this.sessions = new Map();
-        this.db = null;
-        this.initialized = false;
-        this.cleanupPromise = null;
-        this.cleanupHandlersRegistered = false;
-        this.handleProcessExit = null;
-    }
-    /**
-     * Initialize the SQLite database and create sessions table
-     */
-    async initDB() {
-        if (this.initialized) {
-            return;
-        }
-        try {
-            // eslint-disable-next-line @typescript-eslint/no-require-imports
-            const { DatabaseSync } = require('node:sqlite');
-            this.db = new DatabaseSync(this.dbPath);
-            // Create sessions table if not exists
-            this.db.exec(exports.CREATE_SESSIONS_TABLE);
-            this.db.exec(CREATE_STATUS_INDEX);
-            // Add missing columns for older databases
-            for (const col of [
-                'pid INTEGER',
-                'client_id TEXT',
-                "status TEXT DEFAULT 'active'",
-                'last_active TEXT',
-                'created_at TEXT',
-            ]) {
-                try {
-                    this.db.exec(`ALTER TABLE sessions ADD COLUMN ${col}`);
-                }
-                catch {
-                    // Column already exists
-                }
-            }
-            // Mark any orphaned 'active' sessions as 'terminated'
-            // (from previous server crashes)
-            this.db
-                .prepare(`
-        UPDATE sessions
-        SET status = 'terminated', last_active = datetime('now')
-        WHERE status = 'active'
-      `)
-                .run();
-            this.initialized = true;
-            console.error(`[SessionManager] Database initialized at ${this.dbPath}`);
-            // Setup cleanup on process exit
-            this._setupProcessCleanup();
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error('[SessionManager] Failed to initialize database:', message);
-            throw err;
-        }
-    }
-    /**
-     * Create a new Claude Code session
-     * @param projectDir - Working directory for the session
-     * @returns Session ID and daemon
-     */
-    async createSession(projectDir) {
-        if (!this.initialized) {
-            await this.initDB();
-        }
-        // Generate unique session ID
-        const sessionId = `session_${Date.now()}_${Math.random().toString(36).substring(2, 8)}`;
-        // Create daemon instance
-        const daemon = new daemon_js_1.ClaudeDaemon(projectDir, sessionId);
-        try {
-            // Spawn the daemon
-            await daemon.spawn();
-            // Insert into database
-            const stmt = this.db.prepare(`
-        INSERT INTO sessions (id, project_path, status, pid)
-        VALUES (?, ?, 'active', ?)
-      `);
-            stmt.run(sessionId, projectDir, daemon.getPid());
-            // Store in memory map
-            this.sessions.set(sessionId, {
-                daemon,
-                clientId: null,
-                projectDir,
-                createdAt: new Date().toISOString(),
-            });
-            // Setup daemon event handlers
-            this._setupDaemonHandlers(sessionId, daemon);
-            console.error(`[SessionManager] Session ${sessionId} created for ${projectDir}`);
-            return { sessionId, daemon };
-        }
-        catch (err) {
-            const message = err instanceof Error ? err.message : String(err);
-            console.error(`[SessionManager] Failed to create session:`, message);
-            // Cleanup on failure
-            daemon.kill();
-            throw err;
-        }
-    }
-    /**
-     * Get all active sessions
-     * @returns Array of active session info
-     */
-    async getActiveSessions() {
-        if (!this.initialized) {
-            await this.initDB();
-        }
-        const stmt = this.db.prepare(`
-      SELECT id, project_path, created_at, last_active, status, pid, client_id
-      FROM sessions
-      WHERE status = 'active'
-      ORDER BY created_at DESC
-    `);
-        const rows = stmt.all();
-        // Enrich with in-memory data
-        return rows.map((row) => {
-            const memSession = this.sessions.get(row.id);
-            return {
-                id: row.id,
-                projectDir: row.project_path ?? '',
-                createdAt: row.created_at,
-                lastActive: row.last_active,
-                status: row.status,
-                pid: row.pid,
-                clientId: row.client_id,
-                isAlive: memSession?.daemon?.isActive() || false,
-            };
-        });
-    }
-    /**
-     * Terminate a session by ID
-     * @param sessionId - Session to terminate
-     * @returns True if session was terminated
-     */
-    async terminateSession(sessionId) {
-        if (!this.initialized) {
-            await this.initDB();
-        }
-        const session = this.sessions.get(sessionId);
-        if (session) {
-            // Kill the daemon
-            if (session.daemon) {
-                session.daemon.kill();
-            }
-            // Remove from memory
-            this.sessions.delete(sessionId);
-        }
-        // Update database
-        const stmt = this.db.prepare(`
-      UPDATE sessions
-      SET status = 'terminated', last_active = datetime('now')
-      WHERE id = ?
-    `);
-        const result = stmt.run(sessionId);
-        console.error(`[SessionManager] Session ${sessionId} terminated`);
-        return result.changes > 0;
-    }
-    /**
-     * Get a session by ID
-     * @param sessionId - Session ID to look up
-     * @returns Session data or undefined
-     */
-    getSession(sessionId) {
-        return this.sessions.get(sessionId);
-    }
-    /**
-     * Update session's last active timestamp
-     * @param sessionId - Session ID
-     */
-    touchSession(sessionId) {
-        if (!this.db || !this.initialized) {
-            return;
-        }
-        const stmt = this.db.prepare(`
-      UPDATE sessions
-      SET last_active = datetime('now')
-      WHERE id = ?
-    `);
-        stmt.run(sessionId);
-    }
-    /**
-     * Assign a client to a session
-     * @param sessionId - Session ID
-     * @param clientId - Client ID
-     */
-    assignClient(sessionId, clientId) {
-        const session = this.sessions.get(sessionId);
-        if (session) {
-            session.clientId = clientId;
-        }
-        if (this.db && this.initialized) {
-            const stmt = this.db.prepare(`
-        UPDATE sessions
-        SET client_id = ?
-        WHERE id = ?
-      `);
-            stmt.run(clientId, sessionId);
-        }
-    }
-    /**
-     * Remove client assignment from a session
-     * @param sessionId - Session ID
-     */
-    unassignClient(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (session) {
-            session.clientId = null;
-        }
-        if (this.db && this.initialized) {
-            const stmt = this.db.prepare(`
-        UPDATE sessions
-        SET client_id = NULL
-        WHERE id = ?
-      `);
-            stmt.run(sessionId);
-        }
-    }
-    /**
-     * Get session count
-     * @returns Number of active sessions
-     */
-    getSessionCount() {
-        return this.sessions.size;
-    }
-    /**
-     * Terminate all active sessions
-     * @returns Number of sessions terminated
-     */
-    async terminateAll() {
-        const sessionIds = Array.from(this.sessions.keys());
-        let count = 0;
-        for (const sessionId of sessionIds) {
-            if (await this.terminateSession(sessionId)) {
-                count++;
-            }
-        }
-        return count;
-    }
-    /**
-     * Setup daemon event handlers
-     * @private
-     */
-    _setupDaemonHandlers(sessionId, daemon) {
-        daemon.on('exit', () => {
-            // Update database on daemon exit
-            if (this.db && this.initialized) {
-                const stmt = this.db.prepare(`
-          UPDATE sessions
-          SET status = 'terminated', last_active = datetime('now')
-          WHERE id = ?
-        `);
-                stmt.run(sessionId);
-            }
-            // Remove from memory
-            this.sessions.delete(sessionId);
-            console.error(`[SessionManager] Session ${sessionId} daemon exited, cleaned up`);
-        });
-        daemon.on('error', (err) => {
-            console.error(`[SessionManager] Session ${sessionId} daemon error:`, err.error);
-        });
-    }
-    /**
-     * Setup process cleanup handlers
-     * @private
-     */
-    _setupProcessCleanup() {
-        if (this.cleanupHandlersRegistered) {
-            return;
-        }
-        const cleanup = () => {
-            if (this.cleanupPromise) {
-                return;
-            }
-            if (this.handleProcessExit) {
-                process.off('exit', this.handleProcessExit);
-            }
-            this.cleanupPromise = Promise.resolve();
-            console.error('[SessionManager] Process exiting, cleaning up sessions...');
-            if (this.db && this.initialized) {
-                for (const [sessionId, session] of this.sessions.entries()) {
-                    try {
-                        session.daemon.kill();
-                    }
-                    catch {
-                        // Best effort - process is already exiting.
-                    }
-                    this.sessions.delete(sessionId);
-                    const stmt = this.db.prepare(`
-            UPDATE sessions
-            SET status = 'terminated', last_active = datetime('now')
-            WHERE id = ?
-          `);
-                    stmt.run(sessionId);
-                }
-            }
-            this.close();
-        };
-        this.handleProcessExit = cleanup;
-        process.on('exit', this.handleProcessExit);
-        this.cleanupHandlersRegistered = true;
-    }
-    /**
-     * Close the database connection
-     */
-    close() {
-        if (this.db) {
-            const db = this.db;
-            this.db = null;
-            this.initialized = false;
-            db.close();
-        }
-    }
-}
-exports.SessionManager = SessionManager;
-//# sourceMappingURL=session-manager.js.map

package/dist/embedding-server/mobile/websocket-handler.d.ts

@@ -1,137 +0,0 @@
-/**
- * @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
- * });
- */
-import { WebSocketServer, WebSocket } from 'ws';
-import type { Server as HTTPServer } from 'http';
-/**
- * Message router interface
- */
-interface StreamCallbacks {
-    onDelta?: (text: string) => void;
-    onToolUse?: (toolName: string, input: Record<string, unknown>) => void;
-    onToolComplete?: (toolName: string, toolUseId: string, isError: boolean) => void;
-    onFinal?: (response: unknown) => void;
-    onError?: (error: Error) => void;
-}
-interface MessageRouter {
-    process(message: NormalizedMessage, options?: {
-        onQueued?: () => void;
-        onStream?: StreamCallbacks;
-    }): Promise<RouterResult>;
-}
-/**
- * Session store interface
- */
-interface SessionStore {
-    getHistoryByChannel?(source: string, channelId: string): Array<{
-        user?: string;
-        bot?: string;
-        timestamp?: number;
-    }>;
-    getHistory?(sessionId: string): Array<{
-        user?: string;
-        bot?: string;
-        timestamp?: number;
-    }>;
-}
-/**
- * Normalized message for router
- */
-interface NormalizedMessage {
-    source: string;
-    channelId: string;
-    channelName: string;
-    userId: string;
-    text: string;
-    contentBlocks?: ContentBlock[];
-    metadata: {
-        clientId: string;
-        sessionId?: string;
-        osAgentMode?: boolean;
-        timestamp: number;
-    };
-}
-/**
- * Content block types
- */
-interface ImageContentBlock {
-    type: 'image';
-    source: {
-        type: 'base64';
-        media_type: string;
-        data: string;
-    };
-}
-interface TextContentBlock {
-    type: 'text';
-    text: string;
-}
-type ContentBlock = ImageContentBlock | TextContentBlock;
-/**
- * Router result
- */
-interface RouterResult {
-    response: string;
-    sessionId: string;
-    duration: number;
-}
-/**
- * Client info stored in clients Map
- */
-interface ClientInfo {
-    clientId: string;
-    userId: string;
-    ws: WebSocket;
-    isAlive: boolean;
-    connectedAt: string;
-    sessionId?: string;
-    osAgentMode?: boolean;
-    language?: string;
-}
-/**
- * WebSocket handler options
- */
-export interface WebSocketHandlerOptions {
-    httpServer: HTTPServer;
-    messageRouter: MessageRouter;
-    sessionStore: SessionStore;
-    authToken?: string;
-}
-/**
- * Extended WebSocketServer with helper methods
- */
-type ExtendedWebSocketServer = WebSocketServer & {
-    getClients: () => Map<string, ClientInfo>;
-    getClientCount: () => number;
-};
-/**
- * Create WebSocket handler with MessageRouter integration
- */
-export declare function createWebSocketHandler({ httpServer, messageRouter, sessionStore, authToken: _authToken, }: WebSocketHandlerOptions): ExtendedWebSocketServer;
-/**
- * WebSocketHandler class (backwards compatibility)
- * @deprecated Use createWebSocketHandler() instead
- */
-export declare class WebSocketHandler {
-    private wss;
-    constructor(httpServer: HTTPServer, options: Partial<WebSocketHandlerOptions>);
-    getClients(): Map<string, ClientInfo>;
-    getClientCount(): number;
-    close(): void;
-}
-export {};
-//# sourceMappingURL=websocket-handler.d.ts.map