@jungjaehoon/mama-core 1.1.1 → 1.1.3

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

@@ -0,0 +1,333 @@
+"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_dir TEXT NOT NULL,
+    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;
+    /**
+     * 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;
+    }
+    /**
+     * Initialize the SQLite database and create sessions table
+     */
+    async initDB() {
+        if (this.initialized) {
+            return;
+        }
+        try {
+            // Dynamically import better-sqlite3 to handle cases where it's not installed
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const Database = require('better-sqlite3');
+            this.db = new Database(this.dbPath);
+            // Create sessions table if not exists
+            this.db.exec(exports.CREATE_SESSIONS_TABLE);
+            this.db.exec(CREATE_STATUS_INDEX);
+            // 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_dir, 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_dir, started_at, last_active_at, status, pid, client_id
+      FROM sessions
+      WHERE status = 'active'
+      ORDER BY started_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_dir,
+                createdAt: row.started_at,
+                lastActive: row.last_active_at,
+                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() {
+        const cleanup = async () => {
+            console.error('[SessionManager] Process exiting, cleaning up sessions...');
+            await this.terminateAll();
+            if (this.db) {
+                this.db.close();
+            }
+        };
+        process.on('exit', () => void cleanup());
+        process.on('SIGINT', () => void cleanup());
+        process.on('SIGTERM', () => void cleanup());
+    }
+    /**
+     * Close the database connection
+     */
+    close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+            this.initialized = false;
+        }
+    }
+}
+exports.SessionManager = SessionManager;
+//# sourceMappingURL=session-manager.js.map

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

@@ -0,0 +1,127 @@
+/**
+ * @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 MessageRouter {
+    process(message: NormalizedMessage): 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