@soleri/core 2.10.0 → 2.11.0

package/dist/runtime/facades/chat-facade.js

@@ -0,0 +1,808 @@
+/**
+ * Chat facade — session management, response chunking, auth for chat transports.
+ */
+import { z } from 'zod';
+import { ChatSessionManager } from '../../chat/chat-session.js';
+import { ChatAuthManager } from '../../chat/auth-manager.js';
+import { TaskCancellationManager } from '../../chat/cancellation.js';
+import { SelfUpdateManager } from '../../chat/self-update.js';
+import { NotificationEngine } from '../../chat/notifications.js';
+import { detectFileIntent, buildMultimodalContent, cleanupTempFiles, } from '../../chat/file-handler.js';
+import { transcribeAudio, synthesizeSpeech } from '../../chat/voice.js';
+import { MessageQueue } from '../../chat/queue.js';
+import { BrowserSessionManager } from '../../chat/browser-session.js';
+import { chunkResponse } from '../../chat/response-chunker.js';
+import { McpToolBridge } from '../../chat/mcp-bridge.js';
+import { createOutputCompressor } from '../../chat/output-compressor.js';
+function getOrCreateSessions(state, config) {
+    if (!state.sessions) {
+        state.sessions = new ChatSessionManager(config);
+        state.sessions.startReaper();
+    }
+    return state.sessions;
+}
+function getOrCreateAuth(state, config) {
+    if (!state.auth) {
+        state.auth = new ChatAuthManager(config);
+    }
+    return state.auth;
+}
+export function createChatFacadeOps(_runtime) {
+    const state = {
+        sessions: null,
+        auth: null,
+        bridge: null,
+        cancellation: null,
+        updater: null,
+        notifications: null,
+        queue: null,
+        browser: null,
+    };
+    return [
+        // ─── Session Ops ──────────────────────────────────────────────
+        {
+            name: 'chat_session_init',
+            description: 'Initialize chat session management. Must be called before other session ops. Provide the storage directory path.',
+            auth: 'write',
+            schema: z.object({
+                storageDir: z.string().describe('Directory for session persistence.'),
+                ttlMs: z.number().optional().describe('Session TTL in ms. Default: 7200000 (2 hours).'),
+                compactionThreshold: z
+                    .number()
+                    .optional()
+                    .describe('Messages before compaction. Default: 100.'),
+                compactionKeep: z
+                    .number()
+                    .optional()
+                    .describe('Messages to keep after compaction. Default: 40.'),
+            }),
+            handler: async (params) => {
+                const config = {
+                    storageDir: params.storageDir,
+                    ttlMs: params.ttlMs,
+                    compactionThreshold: params.compactionThreshold,
+                    compactionKeep: params.compactionKeep,
+                };
+                const sessions = getOrCreateSessions(state, config);
+                return {
+                    initialized: true,
+                    activeSessions: sessions.size,
+                    storageDir: config.storageDir,
+                };
+            },
+        },
+        {
+            name: 'chat_session_get',
+            description: 'Get or create a chat session by ID. Returns session with message history.',
+            auth: 'read',
+            schema: z.object({
+                sessionId: z.string().describe('Session/chat ID.'),
+                storageDir: z.string().describe('Storage directory (auto-initializes if needed).'),
+            }),
+            handler: async (params) => {
+                const sessions = getOrCreateSessions(state, {
+                    storageDir: params.storageDir,
+                });
+                const session = sessions.getOrCreate(params.sessionId);
+                return {
+                    id: session.id,
+                    messageCount: session.messages.length,
+                    createdAt: session.createdAt,
+                    lastActiveAt: session.lastActiveAt,
+                    meta: session.meta,
+                };
+            },
+        },
+        {
+            name: 'chat_session_append',
+            description: 'Append a message to a chat session.',
+            auth: 'write',
+            schema: z.object({
+                sessionId: z.string().describe('Session/chat ID.'),
+                storageDir: z.string().describe('Storage directory.'),
+                role: z.enum(['user', 'assistant', 'system', 'tool']).describe('Message role.'),
+                content: z.string().describe('Message content.'),
+            }),
+            handler: async (params) => {
+                const sessions = getOrCreateSessions(state, {
+                    storageDir: params.storageDir,
+                });
+                sessions.appendMessage(params.sessionId, {
+                    role: params.role,
+                    content: params.content,
+                    timestamp: Date.now(),
+                });
+                return {
+                    sessionId: params.sessionId,
+                    messageCount: sessions.messageCount(params.sessionId),
+                };
+            },
+        },
+        {
+            name: 'chat_session_clear',
+            description: 'Clear message history for a session (keeps session alive).',
+            auth: 'write',
+            schema: z.object({
+                sessionId: z.string().describe('Session/chat ID.'),
+                storageDir: z.string().describe('Storage directory.'),
+            }),
+            handler: async (params) => {
+                const sessions = getOrCreateSessions(state, {
+                    storageDir: params.storageDir,
+                });
+                sessions.clear(params.sessionId);
+                return { cleared: true, sessionId: params.sessionId };
+            },
+        },
+        {
+            name: 'chat_session_delete',
+            description: 'Delete a session entirely (memory + disk).',
+            auth: 'write',
+            schema: z.object({
+                sessionId: z.string().describe('Session/chat ID.'),
+                storageDir: z.string().describe('Storage directory.'),
+            }),
+            handler: async (params) => {
+                const sessions = getOrCreateSessions(state, {
+                    storageDir: params.storageDir,
+                });
+                sessions.delete(params.sessionId);
+                return { deleted: true, sessionId: params.sessionId };
+            },
+        },
+        {
+            name: 'chat_session_list',
+            description: 'List all session IDs (active + persisted).',
+            auth: 'read',
+            schema: z.object({
+                storageDir: z.string().describe('Storage directory.'),
+            }),
+            handler: async (params) => {
+                const sessions = getOrCreateSessions(state, {
+                    storageDir: params.storageDir,
+                });
+                const ids = sessions.listAll();
+                return { sessions: ids, count: ids.length, active: sessions.size };
+            },
+        },
+        // ─── Response Chunking ────────────────────────────────────────
+        {
+            name: 'chat_chunk_response',
+            description: 'Split a long response into chunks for chat platforms. Converts Markdown to HTML by default.',
+            auth: 'read',
+            schema: z.object({
+                text: z.string().describe('The response text to chunk.'),
+                maxChunkSize: z.number().optional().describe('Max characters per chunk. Default: 4000.'),
+                format: z
+                    .enum(['html', 'markdown', 'plain'])
+                    .optional()
+                    .describe('Output format. Default: html.'),
+            }),
+            handler: async (params) => {
+                const config = {
+                    maxChunkSize: params.maxChunkSize,
+                    format: params.format,
+                };
+                const chunks = chunkResponse(params.text, config);
+                return { chunks, count: chunks.length };
+            },
+        },
+        // ─── Authentication ───────────────────────────────────────────
+        {
+            name: 'chat_auth_init',
+            description: 'Initialize chat authentication. Provide passphrase and optional allowlist.',
+            auth: 'write',
+            schema: z.object({
+                storagePath: z.string().describe('Path to auth persistence file.'),
+                passphrase: z.string().optional().describe('Auth passphrase. If unset, auth is disabled.'),
+                allowedUsers: z
+                    .array(z.union([z.string(), z.number()]))
+                    .optional()
+                    .describe('Allowed user IDs. Empty = any user.'),
+            }),
+            handler: async (params) => {
+                const config = {
+                    storagePath: params.storagePath,
+                    passphrase: params.passphrase,
+                    allowedUsers: params.allowedUsers,
+                };
+                const auth = getOrCreateAuth(state, config);
+                return {
+                    initialized: true,
+                    enabled: auth.enabled,
+                    authenticatedCount: auth.authenticatedCount,
+                };
+            },
+        },
+        {
+            name: 'chat_auth_check',
+            description: 'Check if a user is authenticated.',
+            auth: 'read',
+            schema: z.object({
+                userId: z.union([z.string(), z.number()]).describe('User ID to check.'),
+                storagePath: z.string().describe('Auth storage path (auto-initializes if needed).'),
+            }),
+            handler: async (params) => {
+                const auth = getOrCreateAuth(state, {
+                    storagePath: params.storagePath,
+                });
+                const userId = params.userId;
+                return {
+                    userId,
+                    authenticated: auth.isAuthenticated(userId),
+                    lockedOut: auth.isLockedOut(userId),
+                };
+            },
+        },
+        {
+            name: 'chat_auth_authenticate',
+            description: 'Attempt to authenticate a user with a passphrase.',
+            auth: 'write',
+            schema: z.object({
+                userId: z.union([z.string(), z.number()]).describe('User ID.'),
+                passphrase: z.string().describe('Passphrase to verify.'),
+                storagePath: z.string().describe('Auth storage path.'),
+            }),
+            handler: async (params) => {
+                const auth = getOrCreateAuth(state, {
+                    storagePath: params.storagePath,
+                });
+                const success = auth.authenticate(params.userId, params.passphrase);
+                return {
+                    userId: params.userId,
+                    success,
+                    lockedOut: auth.isLockedOut(params.userId),
+                };
+            },
+        },
+        {
+            name: 'chat_auth_revoke',
+            description: 'Revoke authentication for a user.',
+            auth: 'write',
+            schema: z.object({
+                userId: z.union([z.string(), z.number()]).describe('User ID to revoke.'),
+                storagePath: z.string().describe('Auth storage path.'),
+            }),
+            handler: async (params) => {
+                const auth = getOrCreateAuth(state, {
+                    storagePath: params.storagePath,
+                });
+                auth.revoke(params.userId);
+                return { revoked: true, userId: params.userId };
+            },
+        },
+        {
+            name: 'chat_auth_status',
+            description: 'Get authentication status — enabled, user count, list.',
+            auth: 'read',
+            schema: z.object({
+                storagePath: z.string().describe('Auth storage path.'),
+            }),
+            handler: async (params) => {
+                const auth = getOrCreateAuth(state, {
+                    storagePath: params.storagePath,
+                });
+                return {
+                    enabled: auth.enabled,
+                    authenticatedCount: auth.authenticatedCount,
+                    authenticatedUsers: auth.listAuthenticated(),
+                };
+            },
+        },
+        // ─── MCP Bridge Ops ─────────────────────────────────────────────
+        {
+            name: 'chat_bridge_init',
+            description: 'Initialize the MCP tool bridge for local tool execution. Optional allowlist filters which tools are registered.',
+            auth: 'write',
+            schema: z.object({
+                allowlist: z
+                    .array(z.string())
+                    .optional()
+                    .describe('Tool name allowlist. If unset, all tools are allowed.'),
+                maxOutput: z
+                    .number()
+                    .optional()
+                    .describe('Max output length per tool call. Default: 10000.'),
+            }),
+            handler: async (params) => {
+                state.bridge = new McpToolBridge({
+                    allowlist: params.allowlist,
+                    compressor: createOutputCompressor(),
+                    maxOutput: params.maxOutput,
+                });
+                return { initialized: true, toolCount: 0 };
+            },
+        },
+        {
+            name: 'chat_bridge_register',
+            description: 'Register a tool with the MCP bridge.',
+            auth: 'write',
+            schema: z.object({
+                name: z.string().describe('Tool name.'),
+                description: z.string().describe('Tool description.'),
+                inputSchema: z.record(z.unknown()).describe('JSON Schema for tool input.'),
+            }),
+            handler: async (params) => {
+                if (!state.bridge) {
+                    state.bridge = new McpToolBridge({ compressor: createOutputCompressor() });
+                }
+                // Handler is a no-op since we can't pass functions through JSON
+                // Real handler registration happens in code, not via ops
+                state.bridge.register({
+                    name: params.name,
+                    description: params.description,
+                    inputSchema: params.inputSchema,
+                    handler: async () => ({ message: 'Registered via op — handler is a placeholder' }),
+                });
+                return { registered: true, name: params.name, totalTools: state.bridge.size };
+            },
+        },
+        {
+            name: 'chat_bridge_list',
+            description: 'List all tools registered with the MCP bridge.',
+            auth: 'read',
+            handler: async () => {
+                if (!state.bridge)
+                    return { tools: [], count: 0 };
+                const tools = state.bridge.listTools();
+                return { tools, count: tools.length };
+            },
+        },
+        {
+            name: 'chat_bridge_execute',
+            description: 'Execute a registered tool via the MCP bridge.',
+            auth: 'write',
+            schema: z.object({
+                name: z.string().describe('Tool name to execute.'),
+                input: z.record(z.unknown()).optional().describe('Tool input parameters.'),
+            }),
+            handler: async (params) => {
+                if (!state.bridge)
+                    return { output: 'Bridge not initialized', isError: true };
+                const result = await state.bridge.execute(params.name, params.input ?? {});
+                return result;
+            },
+        },
+        {
+            name: 'chat_compress_output',
+            description: 'Compress verbose tool output for chat display. Uses JSON-aware truncation.',
+            auth: 'read',
+            schema: z.object({
+                toolName: z.string().describe('Tool name (for compressor lookup).'),
+                output: z.string().describe('Raw tool output to compress.'),
+                maxLength: z.number().optional().describe('Max output length. Default: 4000.'),
+            }),
+            handler: async (params) => {
+                const compressor = createOutputCompressor();
+                const compressed = compressor(params.toolName, params.output, params.maxLength);
+                return {
+                    compressed,
+                    originalLength: params.output.length,
+                    compressedLength: compressed.length,
+                };
+            },
+        },
+        // ─── Task Cancellation Ops ─────────────────────────────────────
+        {
+            name: 'chat_cancel_create',
+            description: 'Create an AbortSignal for a chat task. If a task is already running for this chat, it is cancelled first. Returns signal status.',
+            auth: 'write',
+            schema: z.object({
+                chatId: z.string().describe('Chat/session ID.'),
+                description: z.string().optional().describe('Description of what is running.'),
+            }),
+            handler: async (params) => {
+                if (!state.cancellation) {
+                    state.cancellation = new TaskCancellationManager();
+                }
+                const signal = state.cancellation.create(params.chatId, params.description);
+                return {
+                    chatId: params.chatId,
+                    created: true,
+                    aborted: signal.aborted,
+                    activeTasks: state.cancellation.size,
+                };
+            },
+        },
+        {
+            name: 'chat_cancel_stop',
+            description: 'Cancel the running task for a chat. Aborts the associated AbortController.',
+            auth: 'write',
+            schema: z.object({
+                chatId: z.string().describe('Chat/session ID to cancel.'),
+            }),
+            handler: async (params) => {
+                if (!state.cancellation) {
+                    return { cancelled: false, reason: 'No cancellation manager initialized.' };
+                }
+                const info = state.cancellation.cancel(params.chatId);
+                if (!info) {
+                    return { cancelled: false, reason: 'No running task for this chat.' };
+                }
+                return {
+                    cancelled: true,
+                    chatId: params.chatId,
+                    description: info.description ?? null,
+                    ranForMs: Date.now() - info.startedAt,
+                    activeTasks: state.cancellation.size,
+                };
+            },
+        },
+        {
+            name: 'chat_cancel_status',
+            description: 'Get cancellation status — running tasks, per-chat info.',
+            auth: 'read',
+            schema: z.object({
+                chatId: z.string().optional().describe('Specific chat to check. Omit for all.'),
+            }),
+            handler: async (params) => {
+                if (!state.cancellation) {
+                    return { activeTasks: 0, running: [] };
+                }
+                if (params.chatId) {
+                    const info = state.cancellation.getInfo(params.chatId);
+                    return {
+                        chatId: params.chatId,
+                        running: !!info,
+                        description: info?.description ?? null,
+                        startedAt: info?.startedAt ?? null,
+                        ranForMs: info ? Date.now() - info.startedAt : null,
+                    };
+                }
+                const running = state.cancellation.listRunning();
+                return {
+                    activeTasks: state.cancellation.size,
+                    running: running.map((id) => {
+                        const info = state.cancellation.getInfo(id);
+                        return {
+                            chatId: id,
+                            description: info?.description ?? null,
+                            startedAt: info?.startedAt ?? null,
+                        };
+                    }),
+                };
+            },
+        },
+        // ─── Self-Update Ops ───────────────────────────────────────────
+        {
+            name: 'chat_update_init',
+            description: 'Initialize self-update manager. Provide path for restart context persistence.',
+            auth: 'write',
+            schema: z.object({
+                contextPath: z.string().describe('Path for restart context JSON file.'),
+            }),
+            handler: async (params) => {
+                state.updater = new SelfUpdateManager(params.contextPath);
+                const pending = state.updater.loadContext();
+                return {
+                    initialized: true,
+                    hasPendingRestart: !!pending,
+                    pendingContext: pending,
+                };
+            },
+        },
+        {
+            name: 'chat_update_request',
+            description: 'Request a restart. Saves context for post-restart confirmation.',
+            auth: 'write',
+            schema: z.object({
+                chatId: z.string().describe('Chat ID for post-restart confirmation.'),
+                reason: z
+                    .enum(['self-update', 'rebuild', 'manual'])
+                    .optional()
+                    .describe('Restart reason. Default: manual.'),
+                commitSha: z.string().optional().describe('Git commit SHA if self-update.'),
+                contextPath: z.string().describe('Path for restart context.'),
+            }),
+            handler: async (params) => {
+                if (!state.updater) {
+                    state.updater = new SelfUpdateManager(params.contextPath);
+                }
+                return state.updater.requestRestart(params.chatId, params.reason ?? 'manual', params.commitSha);
+            },
+        },
+        {
+            name: 'chat_update_confirm',
+            description: 'Clear restart context after successful startup.',
+            auth: 'write',
+            schema: z.object({
+                contextPath: z.string().describe('Path for restart context.'),
+            }),
+            handler: async (params) => {
+                if (!state.updater) {
+                    state.updater = new SelfUpdateManager(params.contextPath);
+                }
+                const context = state.updater.loadContext();
+                state.updater.clearContext();
+                return { confirmed: true, previousContext: context };
+            },
+        },
+        // ─── File Handling Ops ─────────────────────────────────────────
+        {
+            name: 'chat_file_detect_intent',
+            description: 'Detect user intent for a file — vision, text, or intake.',
+            auth: 'read',
+            schema: z.object({
+                filename: z.string().describe('Original filename.'),
+                mimeType: z.string().describe('MIME type.'),
+                userText: z.string().optional().describe('Accompanying user message text.'),
+            }),
+            handler: async (params) => {
+                const intent = detectFileIntent(params.filename, params.mimeType, params.userText);
+                return { filename: params.filename, mimeType: params.mimeType, intent };
+            },
+        },
+        {
+            name: 'chat_file_build_content',
+            description: 'Build multimodal content from a file for the Anthropic API.',
+            auth: 'read',
+            schema: z.object({
+                filename: z.string().describe('Original filename.'),
+                mimeType: z.string().describe('MIME type.'),
+                dataBase64: z.string().describe('File content as base64.'),
+                intent: z.enum(['vision', 'text', 'intake']).describe('Detected intent.'),
+            }),
+            handler: async (params) => {
+                const file = {
+                    name: params.filename,
+                    mimeType: params.mimeType,
+                    size: Buffer.byteLength(params.dataBase64, 'base64'),
+                    data: Buffer.from(params.dataBase64, 'base64'),
+                };
+                return buildMultimodalContent(file, params.intent);
+            },
+        },
+        {
+            name: 'chat_file_cleanup',
+            description: 'Clean up temp files older than maxAgeMs.',
+            auth: 'write',
+            schema: z.object({
+                uploadDir: z.string().describe('Temp upload directory.'),
+                maxAgeMs: z.number().optional().describe('Max age in ms. Default: 1 hour.'),
+            }),
+            handler: async (params) => {
+                const removed = cleanupTempFiles(params.uploadDir, params.maxAgeMs);
+                return { removed, uploadDir: params.uploadDir };
+            },
+        },
+        // ─── Notification Ops ──────────────────────────────────────────
+        {
+            name: 'chat_notify_init',
+            description: 'Initialize the notification engine. Notifications are delivered via the provided callback pattern.',
+            auth: 'write',
+            schema: z.object({
+                intervalMs: z.number().optional().describe('Polling interval in ms. Default: 30 minutes.'),
+                defaultCooldownMs: z
+                    .number()
+                    .optional()
+                    .describe('Default cooldown between notifications. Default: 4 hours.'),
+            }),
+            handler: async (params) => {
+                // The onNotify callback can't be passed via JSON — it's set up in code.
+                // This op initializes with a no-op that logs to console.
+                state.notifications = new NotificationEngine({
+                    intervalMs: params.intervalMs,
+                    defaultCooldownMs: params.defaultCooldownMs,
+                    onNotify: async (checkId, message) => {
+                        console.log(`[notification] ${checkId}: ${message}`);
+                    },
+                });
+                return { initialized: true };
+            },
+        },
+        {
+            name: 'chat_notify_start',
+            description: 'Start the notification polling loop.',
+            auth: 'write',
+            handler: async () => {
+                if (!state.notifications) {
+                    return { started: false, reason: 'Notification engine not initialized.' };
+                }
+                state.notifications.start();
+                return { started: true, ...state.notifications.stats() };
+            },
+        },
+        {
+            name: 'chat_notify_stop',
+            description: 'Stop the notification polling loop.',
+            auth: 'write',
+            handler: async () => {
+                if (!state.notifications) {
+                    return { stopped: false, reason: 'Notification engine not initialized.' };
+                }
+                state.notifications.stop();
+                return { stopped: true, ...state.notifications.stats() };
+            },
+        },
+        {
+            name: 'chat_notify_poll',
+            description: 'Run all notification checks once (manual trigger).',
+            auth: 'write',
+            handler: async () => {
+                if (!state.notifications) {
+                    return { polled: false, reason: 'Notification engine not initialized.' };
+                }
+                const notified = await state.notifications.poll();
+                return { polled: true, notified, ...state.notifications.stats() };
+            },
+        },
+        {
+            name: 'chat_notify_status',
+            description: 'Get notification engine status.',
+            auth: 'read',
+            handler: async () => {
+                if (!state.notifications) {
+                    return { initialized: false, checks: 0, running: false, sent: 0, lastPollAt: null };
+                }
+                return { initialized: true, ...state.notifications.stats() };
+            },
+        },
+        // ─── Voice Ops ─────────────────────────────────────────────────
+        {
+            name: 'chat_voice_transcribe',
+            description: 'Transcribe audio using OpenAI Whisper. Provide base64-encoded audio.',
+            auth: 'write',
+            schema: z.object({
+                audioBase64: z.string().describe('Base64-encoded audio data.'),
+                openaiApiKey: z.string().describe('OpenAI API key.'),
+                filename: z.string().optional().describe('Audio filename. Default: audio.ogg.'),
+            }),
+            handler: async (params) => {
+                const buffer = Buffer.from(params.audioBase64, 'base64');
+                return transcribeAudio(buffer, {
+                    openaiApiKey: params.openaiApiKey,
+                }, params.filename);
+            },
+        },
+        {
+            name: 'chat_voice_synthesize',
+            description: 'Synthesize speech from text using OpenAI TTS. Returns base64 MP3.',
+            auth: 'write',
+            schema: z.object({
+                text: z.string().describe('Text to synthesize.'),
+                openaiApiKey: z.string().describe('OpenAI API key.'),
+                voice: z.string().optional().describe('Voice ID. Default: onyx.'),
+            }),
+            handler: async (params) => {
+                const result = await synthesizeSpeech(params.text, {
+                    openaiApiKey: params.openaiApiKey,
+                    ttsVoice: params.voice,
+                });
+                if (!result)
+                    return { success: false, reason: 'No API key.' };
+                return {
+                    success: result.success,
+                    audioBase64: result.audio.toString('base64'),
+                    audioSize: result.audio.length,
+                };
+            },
+        },
+        // ─── Queue Ops ─────────────────────────────────────────────────
+        {
+            name: 'chat_queue_init',
+            description: 'Initialize the message queue for disk-based chat relay.',
+            auth: 'write',
+            schema: z.object({
+                queueDir: z.string().describe('Base directory for inbox/outbox.'),
+            }),
+            handler: async (params) => {
+                state.queue = new MessageQueue({ queueDir: params.queueDir });
+                return {
+                    initialized: true,
+                    inbox: state.queue.inboxCount(),
+                    outbox: state.queue.outboxCount(),
+                };
+            },
+        },
+        {
+            name: 'chat_queue_inbox',
+            description: 'Read pending messages from the queue inbox.',
+            auth: 'read',
+            schema: z.object({
+                queueDir: z.string().describe('Queue directory (auto-initializes).'),
+            }),
+            handler: async (params) => {
+                if (!state.queue) {
+                    state.queue = new MessageQueue({ queueDir: params.queueDir });
+                }
+                const messages = state.queue.readInbox();
+                return { messages, count: messages.length, formatted: state.queue.formatInbox() };
+            },
+        },
+        {
+            name: 'chat_queue_reply',
+            description: 'Send a reply to a queued message. Removes from inbox, writes to outbox.',
+            auth: 'write',
+            schema: z.object({
+                messageId: z.string().describe('Original message ID.'),
+                chatId: z.string().describe('Target chat ID.'),
+                text: z.string().describe('Response text.'),
+                queueDir: z.string().describe('Queue directory.'),
+            }),
+            handler: async (params) => {
+                if (!state.queue) {
+                    state.queue = new MessageQueue({ queueDir: params.queueDir });
+                }
+                const response = state.queue.sendResponse(params.messageId, params.chatId, params.text);
+                return { sent: true, response };
+            },
+        },
+        {
+            name: 'chat_queue_drain',
+            description: 'Drain outbox — read and remove all pending responses.',
+            auth: 'write',
+            schema: z.object({
+                queueDir: z.string().describe('Queue directory.'),
+            }),
+            handler: async (params) => {
+                if (!state.queue) {
+                    state.queue = new MessageQueue({ queueDir: params.queueDir });
+                }
+                const responses = state.queue.drainOutbox();
+                return { responses, count: responses.length };
+            },
+        },
+        // ─── Browser Session Ops ───────────────────────────────────────
+        {
+            name: 'chat_browser_init',
+            description: 'Initialize the browser session manager for per-chat Playwright isolation.',
+            auth: 'write',
+            schema: z.object({
+                maxSessions: z.number().optional().describe('Max concurrent sessions. Default: 3.'),
+                idleTimeoutMs: z.number().optional().describe('Idle timeout in ms. Default: 5 minutes.'),
+            }),
+            handler: async (params) => {
+                state.browser = new BrowserSessionManager({
+                    maxSessions: params.maxSessions,
+                    idleTimeoutMs: params.idleTimeoutMs,
+                });
+                return { initialized: true, maxSessions: params.maxSessions ?? 3 };
+            },
+        },
+        {
+            name: 'chat_browser_acquire',
+            description: 'Get or create a browser session for a chat. Spawns Playwright if needed.',
+            auth: 'write',
+            schema: z.object({
+                chatId: z.string().describe('Chat ID for isolation.'),
+            }),
+            handler: async (params) => {
+                if (!state.browser) {
+                    state.browser = new BrowserSessionManager();
+                }
+                const session = state.browser.acquire(params.chatId);
+                return {
+                    chatId: params.chatId,
+                    pid: session.process.pid ?? null,
+                    activeSessions: state.browser.size,
+                };
+            },
+        },
+        {
+            name: 'chat_browser_release',
+            description: 'Release a browser session for a chat.',
+            auth: 'write',
+            schema: z.object({
+                chatId: z.string().describe('Chat ID to release.'),
+            }),
+            handler: async (params) => {
+                if (!state.browser)
+                    return { released: false, reason: 'No browser manager.' };
+                const released = state.browser.release(params.chatId);
+                return { released, activeSessions: state.browser.size };
+            },
+        },
+        {
+            name: 'chat_browser_status',
+            description: 'Get browser session status — active sessions, per-chat info.',
+            auth: 'read',
+            handler: async () => {
+                if (!state.browser)
+                    return { initialized: false, activeSessions: 0, sessions: [] };
+                const sessions = state.browser.listSessions().map((id) => (Object.assign({ chatId: id }, state.browser.getInfo(id))));
+                return { initialized: true, activeSessions: state.browser.size, sessions };
+            },
+        },
+    ];
+}
+//# sourceMappingURL=chat-facade.js.map