@hexidecibel/companion 0.0.1

package/dist/websocket.js

@@ -0,0 +1,1695 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketHandler = void 0;
+const ws_1 = require("ws");
+const uuid_1 = require("uuid");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const crypto = __importStar(require("crypto"));
+const tmux_manager_1 = require("./tmux-manager");
+const parser_1 = require("./parser");
+const config_1 = require("./config");
+const anthropic_usage_1 = require("./anthropic-usage");
+const tool_config_1 = require("./tool-config");
+const templates_1 = require("./scaffold/templates");
+const generator_1 = require("./scaffold/generator");
+// File for persisting tmux session configs
+const TMUX_CONFIGS_FILE = path.join(os.homedir(), '.companion', 'tmux-sessions.json');
+class WebSocketHandler {
+    wss;
+    clients = new Map();
+    token;
+    watcher;
+    subAgentWatcher;
+    injector;
+    push;
+    tmux;
+    tmuxSessionConfigs = new Map();
+    config;
+    clientErrors = [];
+    MAX_CLIENT_ERRORS = 50;
+    scrollLogs = [];
+    MAX_SCROLL_LOGS = 200;
+    autoApproveEnabled = false;
+    constructor(server, config, watcher, injector, push, tmux, subAgentWatcher) {
+        this.config = config;
+        this.token = config.token;
+        this.watcher = watcher;
+        this.subAgentWatcher = subAgentWatcher || null;
+        this.injector = injector;
+        this.push = push;
+        this.tmux = tmux || new tmux_manager_1.TmuxManager('companion');
+        this.wss = new ws_1.WebSocketServer({ server });
+        this.wss.on('connection', (ws, req) => this.handleConnection(ws, req));
+        // Forward watcher events to subscribed clients
+        this.watcher.on('conversation-update', (data) => {
+            this.broadcast('conversation_update', data);
+        });
+        this.watcher.on('status-change', (data) => {
+            this.broadcast('status_change', data);
+            // Schedule push notification if waiting for input (include session info)
+            if (data.isWaitingForInput && data.lastMessage) {
+                this.push.scheduleWaitingNotification(data.lastMessage.content, data.sessionId || undefined, this.injector.getActiveSession() || undefined);
+            }
+            else {
+                this.push.cancelPendingNotification();
+            }
+        });
+        // Notify about activity in other (non-active) sessions
+        this.watcher.on('other-session-activity', (data) => {
+            this.broadcast('other_session_activity', data);
+        });
+        // Notify about conversation compaction (for archiving)
+        this.watcher.on('compaction', (data) => {
+            this.broadcast('compaction', data);
+        });
+        // Load saved tmux session configs
+        this.loadTmuxSessionConfigs();
+        console.log('WebSocket: Server initialized');
+    }
+    loadTmuxSessionConfigs() {
+        try {
+            if (fs.existsSync(TMUX_CONFIGS_FILE)) {
+                const content = fs.readFileSync(TMUX_CONFIGS_FILE, 'utf-8');
+                const configs = JSON.parse(content);
+                for (const config of configs) {
+                    this.tmuxSessionConfigs.set(config.name, config);
+                }
+                console.log(`WebSocket: Loaded ${configs.length} saved tmux session configs`);
+            }
+        }
+        catch (err) {
+            console.error('Failed to load tmux session configs:', err);
+        }
+    }
+    saveTmuxSessionConfigs() {
+        try {
+            const dir = path.dirname(TMUX_CONFIGS_FILE);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            const configs = Array.from(this.tmuxSessionConfigs.values());
+            fs.writeFileSync(TMUX_CONFIGS_FILE, JSON.stringify(configs, null, 2));
+        }
+        catch (err) {
+            console.error('Failed to save tmux session configs:', err);
+        }
+    }
+    storeTmuxSessionConfig(name, workingDir, startCli = true) {
+        this.tmuxSessionConfigs.set(name, {
+            name,
+            workingDir,
+            startCli,
+            lastUsed: Date.now(),
+        });
+        this.saveTmuxSessionConfigs();
+        console.log(`WebSocket: Stored tmux session config for "${name}" (${workingDir})`);
+    }
+    handleConnection(ws, req) {
+        const clientId = (0, uuid_1.v4)();
+        const client = {
+            id: clientId,
+            ws,
+            authenticated: false,
+            subscribed: false,
+        };
+        this.clients.set(clientId, client);
+        console.log(`WebSocket: Client connected (${clientId})`);
+        ws.on('message', (data) => {
+            try {
+                const message = JSON.parse(data.toString());
+                this.handleMessage(client, message);
+            }
+            catch (err) {
+                this.sendError(ws, 'Invalid JSON message');
+            }
+        });
+        ws.on('close', () => {
+            this.clients.delete(clientId);
+            console.log(`WebSocket: Client disconnected (${clientId})`);
+        });
+        ws.on('error', (err) => {
+            console.error(`WebSocket: Client error (${clientId}):`, err);
+            this.clients.delete(clientId);
+        });
+        // Send connection acknowledgment
+        this.send(ws, {
+            type: 'connected',
+            success: true,
+            payload: { clientId },
+        });
+    }
+    handleMessage(client, message) {
+        const { type, token, payload, requestId } = message;
+        const reqStart = Date.now();
+        if (type !== 'ping') {
+            console.log(`WebSocket: >> recv ${type} (${requestId || 'no-id'}) from ${client.id}`);
+        }
+        // Authenticate first
+        if (type === 'authenticate') {
+            if (token === this.token) {
+                client.authenticated = true;
+                client.deviceId = payload?.deviceId;
+                this.send(client.ws, {
+                    type: 'authenticated',
+                    success: true,
+                    requestId,
+                });
+                console.log(`WebSocket: Client authenticated (${client.id})`);
+            }
+            else {
+                this.send(client.ws, {
+                    type: 'authenticated',
+                    success: false,
+                    error: 'Invalid token',
+                    requestId,
+                });
+            }
+            return;
+        }
+        // All other messages require authentication
+        if (!client.authenticated) {
+            this.send(client.ws, {
+                type: 'error',
+                success: false,
+                error: 'Not authenticated',
+                requestId,
+            });
+            return;
+        }
+        // Handle authenticated messages
+        switch (type) {
+            case 'subscribe':
+                const subscribePayload = payload;
+                client.subscribed = true;
+                // Track which session the client is subscribed to
+                if (subscribePayload?.sessionId) {
+                    client.subscribedSessionId = subscribePayload.sessionId;
+                }
+                else {
+                    // Default to current active session
+                    client.subscribedSessionId = this.watcher.getActiveSessionId() || undefined;
+                }
+                console.log(`WebSocket: Client subscribed (${client.id}) to session ${client.subscribedSessionId}`);
+                this.send(client.ws, {
+                    type: 'subscribed',
+                    success: true,
+                    sessionId: client.subscribedSessionId,
+                    requestId,
+                });
+                break;
+            case 'unsubscribe':
+                client.subscribed = false;
+                this.send(client.ws, {
+                    type: 'unsubscribed',
+                    success: true,
+                    requestId,
+                });
+                break;
+            case 'get_highlights': {
+                const hlParams = payload;
+                const t0 = Date.now();
+                const messages = this.watcher.getMessages();
+                const t1 = Date.now();
+                const allHighlights = (0, parser_1.extractHighlights)(messages);
+                const t2 = Date.now();
+                const hlSessionId = this.watcher.getActiveSessionId();
+                const total = allHighlights.length;
+                // Paginate: return most recent `limit` items, with optional offset from end
+                let resultHighlights = allHighlights;
+                let hasMore = false;
+                if (hlParams?.limit && hlParams.limit > 0) {
+                    const offset = hlParams.offset || 0;
+                    const startIdx = Math.max(0, total - offset - hlParams.limit);
+                    const endIdx = total - offset;
+                    resultHighlights = allHighlights.slice(startIdx, endIdx);
+                    hasMore = startIdx > 0;
+                }
+                console.log(`WebSocket: get_highlights - getMessages: ${t1 - t0}ms, extractHighlights: ${t2 - t1}ms, ${messages.length} msgs, returning ${resultHighlights.length}/${total}`);
+                this.send(client.ws, {
+                    type: 'highlights',
+                    success: true,
+                    payload: { highlights: resultHighlights, total, hasMore },
+                    sessionId: hlSessionId,
+                    requestId,
+                });
+                break;
+            }
+            case 'get_full': {
+                const t0 = Date.now();
+                const fullMessages = this.watcher.getMessages();
+                const t1 = Date.now();
+                const fullSessionId = this.watcher.getActiveSessionId();
+                console.log(`WebSocket: get_full - getMessages: ${t1 - t0}ms, ${fullMessages.length} msgs`);
+                this.send(client.ws, {
+                    type: 'full',
+                    success: true,
+                    payload: { messages: fullMessages },
+                    sessionId: fullSessionId,
+                    requestId,
+                });
+                break;
+            }
+            case 'get_status': {
+                const t0 = Date.now();
+                const status = this.watcher.getStatus();
+                const t1 = Date.now();
+                const statusSessionId = this.watcher.getActiveSessionId();
+                console.log(`WebSocket: get_status - ${t1 - t0}ms`);
+                this.send(client.ws, {
+                    type: 'status',
+                    success: true,
+                    payload: status,
+                    sessionId: statusSessionId,
+                    requestId,
+                });
+                break;
+            }
+            case 'get_server_summary':
+                // Get tmux sessions to filter - only show conversations with active tmux sessions
+                this.tmux.listSessions().then(async (tmuxSessions) => {
+                    const summary = await this.watcher.getServerSummary(tmuxSessions);
+                    this.send(client.ws, {
+                        type: 'server_summary',
+                        success: true,
+                        payload: summary,
+                        requestId,
+                    });
+                }).catch((err) => {
+                    console.error('Failed to get server summary:', err);
+                    this.send(client.ws, {
+                        type: 'server_summary',
+                        success: false,
+                        error: 'Failed to get server summary',
+                        requestId,
+                    });
+                });
+                break;
+            case 'get_sessions':
+                const sessions = this.watcher.getSessions();
+                const activeSessionId = this.watcher.getActiveSessionId();
+                this.send(client.ws, {
+                    type: 'sessions',
+                    success: true,
+                    payload: { sessions, activeSessionId },
+                    requestId,
+                });
+                break;
+            case 'get_tasks':
+                // Get tasks for a specific session
+                const tasksPayload = payload;
+                const tasksSessionId = tasksPayload?.sessionId || this.watcher.getActiveSessionId();
+                if (tasksSessionId) {
+                    const sessionSessions = this.watcher.getSessions();
+                    const session = sessionSessions.find(s => s.id === tasksSessionId);
+                    if (session?.conversationPath) {
+                        try {
+                            const fs = require('fs');
+                            const content = fs.readFileSync(session.conversationPath, 'utf-8');
+                            const tasks = (0, parser_1.extractTasks)(content);
+                            this.send(client.ws, {
+                                type: 'tasks',
+                                success: true,
+                                payload: { tasks, sessionId: tasksSessionId },
+                                requestId,
+                            });
+                        }
+                        catch (err) {
+                            this.send(client.ws, {
+                                type: 'tasks',
+                                success: false,
+                                error: 'Failed to read session file',
+                                requestId,
+                            });
+                        }
+                    }
+                    else {
+                        this.send(client.ws, {
+                            type: 'tasks',
+                            success: true,
+                            payload: { tasks: [], sessionId: tasksSessionId },
+                            requestId,
+                        });
+                    }
+                }
+                else {
+                    this.send(client.ws, {
+                        type: 'tasks',
+                        success: false,
+                        error: 'No session specified',
+                        requestId,
+                    });
+                }
+                break;
+            case 'switch_session':
+                // Handle switch_session asynchronously but await completion
+                this.handleSwitchSession(client, payload, requestId);
+                break;
+            case 'send_input':
+                this.handleSendInput(client, payload, requestId);
+                break;
+            case 'send_image':
+                this.handleSendImage(client, payload, requestId);
+                break;
+            case 'upload_image':
+                // Just upload and save, don't send yet
+                this.handleUploadImage(client, payload, requestId);
+                break;
+            case 'send_with_images':
+                // Send message with image paths combined
+                this.handleSendWithImages(client, payload, requestId);
+                break;
+            case 'register_push':
+                const pushPayload = payload;
+                if (pushPayload?.fcmToken && pushPayload?.deviceId) {
+                    const isExpoToken = pushPayload.fcmToken.startsWith('ExponentPushToken');
+                    console.log(`Push registration: device=${pushPayload.deviceId}, type=${isExpoToken ? 'expo' : 'fcm'}, token=${pushPayload.fcmToken.substring(0, 30)}...`);
+                    // Link deviceId to this client for instant notify
+                    client.deviceId = pushPayload.deviceId;
+                    this.push.registerDevice(pushPayload.deviceId, pushPayload.fcmToken);
+                    this.send(client.ws, {
+                        type: 'push_registered',
+                        success: true,
+                        requestId,
+                    });
+                }
+                else {
+                    this.send(client.ws, {
+                        type: 'push_registered',
+                        success: false,
+                        error: 'Missing fcmToken or deviceId',
+                        requestId,
+                    });
+                }
+                break;
+            case 'unregister_push':
+                const unregPayload = payload;
+                if (unregPayload?.deviceId) {
+                    this.push.unregisterDevice(unregPayload.deviceId);
+                    this.send(client.ws, {
+                        type: 'push_unregistered',
+                        success: true,
+                        requestId,
+                    });
+                }
+                break;
+            case 'set_instant_notify':
+                const instantPayload = payload;
+                if (client.deviceId) {
+                    this.push.setInstantNotify(client.deviceId, instantPayload?.enabled ?? false);
+                    this.send(client.ws, {
+                        type: 'instant_notify_set',
+                        success: true,
+                        payload: { enabled: instantPayload?.enabled ?? false },
+                        requestId,
+                    });
+                }
+                else {
+                    this.send(client.ws, {
+                        type: 'instant_notify_set',
+                        success: false,
+                        error: 'Device not registered for push',
+                        requestId,
+                    });
+                }
+                break;
+            case 'set_auto_approve': {
+                const autoApprovePayload = payload;
+                this.autoApproveEnabled = autoApprovePayload?.enabled ?? false;
+                console.log(`Auto-approve ${this.autoApproveEnabled ? 'enabled' : 'disabled'} by client`);
+                this.send(client.ws, {
+                    type: 'auto_approve_set',
+                    success: true,
+                    payload: { enabled: this.autoApproveEnabled },
+                    requestId,
+                });
+                // When toggled ON, immediately check for pending tools that should be auto-approved
+                if (this.autoApproveEnabled) {
+                    this.watcher.checkAndEmitPendingApproval();
+                }
+                break;
+            }
+            case 'set_notification_prefs':
+                const notifPrefs = payload;
+                if (client.deviceId) {
+                    this.push.setNotificationPrefs(client.deviceId, {
+                        quietHoursEnabled: notifPrefs?.quietHoursEnabled ?? false,
+                        quietHoursStart: notifPrefs?.quietHoursStart ?? '22:00',
+                        quietHoursEnd: notifPrefs?.quietHoursEnd ?? '08:00',
+                        throttleMinutes: notifPrefs?.throttleMinutes ?? 0,
+                    });
+                    this.send(client.ws, {
+                        type: 'notification_prefs_set',
+                        success: true,
+                        requestId,
+                    });
+                }
+                else {
+                    this.send(client.ws, {
+                        type: 'notification_prefs_set',
+                        success: false,
+                        error: 'Device not registered for push',
+                        requestId,
+                    });
+                }
+                break;
+            case 'ping':
+                if (client.deviceId) {
+                    this.push.updateDeviceLastSeen(client.deviceId);
+                }
+                this.send(client.ws, {
+                    type: 'pong',
+                    success: true,
+                    requestId,
+                });
+                break;
+            case 'rotate_token':
+                this.handleRotateToken(client, requestId);
+                break;
+            // Tmux session management
+            case 'list_tmux_sessions':
+                console.log('WebSocket: Received list_tmux_sessions request');
+                this.handleListTmuxSessions(client, requestId);
+                break;
+            case 'get_terminal_output': {
+                const termPayload = payload;
+                if (termPayload?.sessionName) {
+                    this.tmux.capturePane(termPayload.sessionName, termPayload.lines || 100)
+                        .then((output) => {
+                        this.send(client.ws, {
+                            type: 'terminal_output',
+                            success: true,
+                            payload: { output, sessionName: termPayload.sessionName },
+                            requestId,
+                        });
+                    })
+                        .catch(() => {
+                        this.send(client.ws, {
+                            type: 'terminal_output',
+                            success: false,
+                            error: 'Failed to capture terminal output',
+                            requestId,
+                        });
+                    });
+                }
+                else {
+                    this.send(client.ws, {
+                        type: 'terminal_output',
+                        success: false,
+                        error: 'Missing sessionName',
+                        requestId,
+                    });
+                }
+                break;
+            }
+            case 'get_tool_config':
+                this.send(client.ws, {
+                    type: 'tool_config',
+                    success: true,
+                    payload: { tools: tool_config_1.DEFAULT_TOOL_CONFIG },
+                    requestId,
+                });
+                break;
+            case 'create_tmux_session':
+                this.handleCreateTmuxSession(client, payload, requestId);
+                break;
+            case 'kill_tmux_session':
+                this.handleKillTmuxSession(client, payload, requestId);
+                break;
+            case 'switch_tmux_session':
+                this.handleSwitchTmuxSession(client, payload, requestId);
+                break;
+            case 'recreate_tmux_session':
+                this.handleRecreateTmuxSession(client, payload, requestId);
+                break;
+            case 'browse_directories':
+                this.handleBrowseDirectories(client, payload, requestId);
+                break;
+            case 'read_file':
+                this.handleReadFile(client, payload, requestId);
+                break;
+            case 'download_file':
+                this.handleDownloadFile(client, payload, requestId);
+                break;
+            case 'get_usage':
+                this.handleGetUsage(client, requestId);
+                break;
+            case 'get_api_usage':
+                this.handleGetApiUsage(client, payload, requestId);
+                break;
+            case 'get_agent_tree':
+                this.handleGetAgentTree(client, payload, requestId);
+                break;
+            case 'get_agent_detail':
+                this.handleGetAgentDetail(client, payload, requestId);
+                break;
+            case 'client_error':
+                this.handleClientError(client, payload, requestId);
+                break;
+            case 'get_client_errors':
+                this.handleGetClientErrors(client, requestId);
+                break;
+            case 'scroll_log':
+                this.handleScrollLog(payload);
+                // No response needed - fire and forget
+                break;
+            case 'get_scroll_logs':
+                this.handleGetScrollLogs(client, requestId);
+                break;
+            case 'clear_scroll_logs':
+                this.scrollLogs = [];
+                this.send(client.ws, { type: 'scroll_logs_cleared', success: true, requestId });
+                break;
+            // Scaffold endpoints
+            case 'get_scaffold_templates':
+                this.send(client.ws, {
+                    type: 'scaffold_templates',
+                    success: true,
+                    payload: {
+                        templates: templates_1.templates.map(t => ({
+                            id: t.id,
+                            name: t.name,
+                            description: t.description,
+                            type: t.type,
+                            icon: t.icon,
+                            tags: t.tags,
+                        })),
+                    },
+                    requestId,
+                });
+                break;
+            case 'scaffold_preview':
+                (async () => {
+                    const previewConfig = payload;
+                    const previewResult = await (0, generator_1.previewScaffold)(previewConfig);
+                    this.send(client.ws, {
+                        type: 'scaffold_preview',
+                        success: !('error' in previewResult),
+                        payload: previewResult,
+                        requestId,
+                    });
+                })();
+                break;
+            case 'scaffold_create':
+                (async () => {
+                    try {
+                        const createConfig = payload;
+                        console.log('Scaffold: Creating project', createConfig.name, 'at', createConfig.location);
+                        const createResult = await (0, generator_1.scaffoldProject)(createConfig, (progress) => {
+                            console.log('Scaffold progress:', progress.step, progress.detail || '');
+                            // Send progress updates
+                            this.send(client.ws, {
+                                type: 'scaffold_progress',
+                                success: true,
+                                payload: progress,
+                            });
+                        });
+                        console.log('Scaffold result:', createResult.success ? 'success' : createResult.error);
+                        this.send(client.ws, {
+                            type: 'scaffold_result',
+                            success: createResult.success,
+                            payload: createResult,
+                            requestId,
+                        });
+                    }
+                    catch (err) {
+                        console.error('Scaffold error:', err);
+                        this.send(client.ws, {
+                            type: 'scaffold_result',
+                            success: false,
+                            error: err instanceof Error ? err.message : String(err),
+                            requestId,
+                        });
+                    }
+                })();
+                break;
+            default:
+                this.send(client.ws, {
+                    type: 'error',
+                    success: false,
+                    error: `Unknown message type: ${type}`,
+                    requestId,
+                });
+        }
+    }
+    async handleSendInput(client, payload, requestId) {
+        if (!payload?.input) {
+            this.send(client.ws, {
+                type: 'input_sent',
+                success: false,
+                error: 'Missing input',
+                requestId,
+            });
+            return;
+        }
+        // Cancel any pending push notification since user is responding
+        this.push.cancelPendingNotification();
+        // Check if the target session exists before trying to send
+        const activeSession = this.injector.getActiveSession();
+        const sessionExists = await this.injector.checkSessionExists(activeSession);
+        if (!sessionExists) {
+            // Check if we have a stored config for this session
+            const savedConfig = this.tmuxSessionConfigs.get(activeSession);
+            this.send(client.ws, {
+                type: 'input_sent',
+                success: false,
+                error: 'tmux_session_not_found',
+                payload: {
+                    sessionName: activeSession,
+                    canRecreate: !!savedConfig,
+                    savedConfig: savedConfig ? {
+                        name: savedConfig.name,
+                        workingDir: savedConfig.workingDir,
+                    } : undefined,
+                },
+                requestId,
+            });
+            return;
+        }
+        const success = await this.injector.sendInput(payload.input);
+        this.send(client.ws, {
+            type: 'input_sent',
+            success,
+            error: success ? undefined : 'Failed to send input to session',
+            requestId,
+        });
+    }
+    async handleSendImage(client, payload, requestId) {
+        if (!payload?.base64) {
+            this.send(client.ws, {
+                type: 'image_sent',
+                success: false,
+                error: 'Missing image data',
+                requestId,
+            });
+            return;
+        }
+        try {
+            // Determine file extension from mime type
+            const ext = payload.mimeType === 'image/png' ? 'png' : 'jpg';
+            const filename = `companion-${Date.now()}.${ext}`;
+            const filepath = path.join(os.tmpdir(), filename);
+            // Save image to temp file
+            const buffer = Buffer.from(payload.base64, 'base64');
+            fs.writeFileSync(filepath, buffer);
+            console.log(`Image saved to: ${filepath}`);
+            // Cancel any pending push notification
+            this.push.cancelPendingNotification();
+            // Send the file path to the coding session
+            const success = await this.injector.sendInput(`Please look at this image: ${filepath}`);
+            this.send(client.ws, {
+                type: 'image_sent',
+                success,
+                payload: { filepath },
+                error: success ? undefined : 'Failed to send image path to session',
+                requestId,
+            });
+        }
+        catch (err) {
+            console.error('Error saving image:', err);
+            this.send(client.ws, {
+                type: 'image_sent',
+                success: false,
+                error: 'Failed to save image',
+                requestId,
+            });
+        }
+    }
+    async handleUploadImage(client, payload, requestId) {
+        if (!payload?.base64) {
+            this.send(client.ws, {
+                type: 'image_uploaded',
+                success: false,
+                error: 'Missing image data',
+                requestId,
+            });
+            return;
+        }
+        try {
+            const ext = payload.mimeType === 'image/png' ? 'png' : 'jpg';
+            const filename = `companion-${Date.now()}.${ext}`;
+            const filepath = path.join(os.tmpdir(), filename);
+            const buffer = Buffer.from(payload.base64, 'base64');
+            fs.writeFileSync(filepath, buffer);
+            console.log(`Image uploaded to: ${filepath}`);
+            this.send(client.ws, {
+                type: 'image_uploaded',
+                success: true,
+                payload: { filepath },
+                requestId,
+            });
+        }
+        catch (err) {
+            console.error('Error uploading image:', err);
+            this.send(client.ws, {
+                type: 'image_uploaded',
+                success: false,
+                error: 'Failed to save image',
+                requestId,
+            });
+        }
+    }
+    async handleSendWithImages(client, payload, requestId) {
+        if (!payload) {
+            this.send(client.ws, {
+                type: 'message_sent',
+                success: false,
+                error: 'Missing payload',
+                requestId,
+            });
+            return;
+        }
+        // Cancel any pending push notification
+        this.push.cancelPendingNotification();
+        // Build combined message: image paths + user message
+        const parts = [];
+        if (payload.imagePaths && payload.imagePaths.length > 0) {
+            for (const imgPath of payload.imagePaths) {
+                parts.push(`[image: ${imgPath}]`);
+            }
+        }
+        if (payload.message && payload.message.trim()) {
+            parts.push(payload.message.trim());
+        }
+        const combinedMessage = parts.join(' ');
+        if (!combinedMessage) {
+            this.send(client.ws, {
+                type: 'message_sent',
+                success: false,
+                error: 'No content to send',
+                requestId,
+            });
+            return;
+        }
+        const success = await this.injector.sendInput(combinedMessage);
+        this.send(client.ws, {
+            type: 'message_sent',
+            success,
+            error: success ? undefined : 'Failed to send message',
+            requestId,
+        });
+    }
+    /**
+     * Handle session switch synchronously - waits for tmux switch to complete
+     * before returning success. This prevents race conditions.
+     */
+    async handleSwitchSession(client, payload, requestId) {
+        if (!payload?.sessionId) {
+            this.send(client.ws, {
+                type: 'session_switched',
+                success: false,
+                error: 'Missing sessionId',
+                requestId,
+            });
+            return;
+        }
+        const { sessionId, epoch } = payload;
+        console.log(`WebSocket: Switching to session ${sessionId} (epoch: ${epoch})`);
+        // 1. Switch the watcher's active session
+        const switched = this.watcher.setActiveSession(sessionId);
+        if (!switched) {
+            this.send(client.ws, {
+                type: 'session_switched',
+                success: false,
+                error: 'Session not found',
+                sessionId,
+                requestId,
+            });
+            return;
+        }
+        // 2. Update client's subscription to this session
+        client.subscribedSessionId = sessionId;
+        // 3. Find and switch to corresponding tmux session
+        let tmuxSessionName;
+        try {
+            const convSession = this.watcher.getSessions().find(s => s.id === sessionId);
+            if (convSession?.projectPath) {
+                const tmuxSessions = await this.tmux.listSessions();
+                const matchingTmux = tmuxSessions.find(ts => ts.workingDir === convSession.projectPath);
+                if (matchingTmux) {
+                    this.injector.setActiveSession(matchingTmux.name);
+                    tmuxSessionName = matchingTmux.name;
+                }
+            }
+        }
+        catch (err) {
+            console.error('Failed to switch tmux session:', err);
+            // Continue anyway - watcher switch succeeded
+        }
+        // 4. Return success with session context
+        this.send(client.ws, {
+            type: 'session_switched',
+            success: true,
+            payload: {
+                sessionId,
+                tmuxSession: tmuxSessionName,
+                epoch, // Echo back epoch for client validation
+            },
+            sessionId, // Include at top level for validation
+            requestId,
+        });
+    }
+    handleRotateToken(client, requestId) {
+        try {
+            // Generate new token
+            const newToken = crypto.randomBytes(32).toString('hex');
+            // Update config file
+            const config = (0, config_1.loadConfig)();
+            config.token = newToken;
+            (0, config_1.saveConfig)(config);
+            // Update in-memory token
+            this.token = newToken;
+            // Notify the requesting client of the new token
+            this.send(client.ws, {
+                type: 'token_rotated',
+                success: true,
+                payload: { newToken },
+                requestId,
+            });
+            console.log('WebSocket: Token rotated successfully');
+            // Disconnect all other clients (they need to re-authenticate)
+            for (const [id, c] of this.clients) {
+                if (id !== client.id && c.authenticated) {
+                    this.send(c.ws, {
+                        type: 'token_invalidated',
+                        success: true,
+                        payload: { reason: 'Token has been rotated' },
+                    });
+                    c.authenticated = false;
+                    c.subscribed = false;
+                }
+            }
+        }
+        catch (err) {
+            console.error('Failed to rotate token:', err);
+            this.send(client.ws, {
+                type: 'token_rotated',
+                success: false,
+                error: 'Failed to rotate token',
+                requestId,
+            });
+        }
+    }
+    // Tmux session management handlers
+    async handleListTmuxSessions(client, requestId) {
+        try {
+            const sessions = await this.tmux.listSessions();
+            const activeSession = this.injector.getActiveSession();
+            this.send(client.ws, {
+                type: 'tmux_sessions',
+                success: true,
+                payload: {
+                    sessions,
+                    activeSession,
+                    homeDir: this.tmux.getHomeDir(),
+                },
+                requestId,
+            });
+        }
+        catch (err) {
+            this.send(client.ws, {
+                type: 'tmux_sessions',
+                success: false,
+                error: 'Failed to list sessions',
+                requestId,
+            });
+        }
+    }
+    async handleCreateTmuxSession(client, payload, requestId) {
+        if (!payload?.workingDir) {
+            this.send(client.ws, {
+                type: 'tmux_session_created',
+                success: false,
+                error: 'Missing workingDir',
+                requestId,
+            });
+            return;
+        }
+        // Validate directory exists
+        if (!fs.existsSync(payload.workingDir)) {
+            this.send(client.ws, {
+                type: 'tmux_session_created',
+                success: false,
+                error: `Directory does not exist: ${payload.workingDir}`,
+                requestId,
+            });
+            return;
+        }
+        const sessionName = payload.name || this.tmux.generateSessionName(payload.workingDir);
+        const startCli = payload.startCli !== false; // Default true
+        console.log(`WebSocket: Creating tmux session "${sessionName}" in ${payload.workingDir}`);
+        const result = await this.tmux.createSession(sessionName, payload.workingDir, startCli);
+        if (result.success) {
+            // Store the session config for potential recreation later
+            this.storeTmuxSessionConfig(sessionName, payload.workingDir, startCli);
+            // Switch input target to the new session
+            this.injector.setActiveSession(sessionName);
+            // Clear the watcher's active session - no conversation exists yet
+            // This prevents returning old session data until the new conversation is created
+            this.watcher.clearActiveSession();
+            console.log(`WebSocket: Cleared active session after creating tmux session "${sessionName}"`);
+            // Immediately refresh tmux paths so the watcher recognizes the new session's
+            // conversation files as soon as they appear (otherwise waits up to 5s)
+            await this.watcher.refreshTmuxPaths();
+            this.send(client.ws, {
+                type: 'tmux_session_created',
+                success: true,
+                payload: {
+                    sessionName,
+                    workingDir: payload.workingDir,
+                },
+                requestId,
+            });
+            // Broadcast to all clients that sessions changed
+            this.broadcast('tmux_sessions_changed', { action: 'created', sessionName });
+        }
+        else {
+            this.send(client.ws, {
+                type: 'tmux_session_created',
+                success: false,
+                error: result.error,
+                requestId,
+            });
+        }
+    }
+    async handleKillTmuxSession(client, payload, requestId) {
+        if (!payload?.sessionName) {
+            this.send(client.ws, {
+                type: 'tmux_session_killed',
+                success: false,
+                error: 'Missing sessionName',
+                requestId,
+            });
+            return;
+        }
+        console.log(`WebSocket: Killing tmux session "${payload.sessionName}"`);
+        const result = await this.tmux.killSession(payload.sessionName);
+        if (result.success) {
+            // If we killed the active session, switch to another
+            if (this.injector.getActiveSession() === payload.sessionName) {
+                const remaining = await this.tmux.listSessions();
+                if (remaining.length > 0) {
+                    this.injector.setActiveSession(remaining[0].name);
+                }
+            }
+            this.send(client.ws, {
+                type: 'tmux_session_killed',
+                success: true,
+                payload: { sessionName: payload.sessionName },
+                requestId,
+            });
+            // Broadcast to all clients
+            this.broadcast('tmux_sessions_changed', { action: 'killed', sessionName: payload.sessionName });
+        }
+        else {
+            this.send(client.ws, {
+                type: 'tmux_session_killed',
+                success: false,
+                error: result.error,
+                requestId,
+            });
+        }
+    }
+    async handleSwitchTmuxSession(client, payload, requestId) {
+        if (!payload?.sessionName) {
+            this.send(client.ws, {
+                type: 'tmux_session_switched',
+                success: false,
+                error: 'Missing sessionName',
+                requestId,
+            });
+            return;
+        }
+        // Verify session exists
+        const exists = await this.tmux.sessionExists(payload.sessionName);
+        if (!exists) {
+            this.send(client.ws, {
+                type: 'tmux_session_switched',
+                success: false,
+                error: `Session "${payload.sessionName}" does not exist`,
+                requestId,
+            });
+            return;
+        }
+        // Switch input target to this tmux session
+        this.injector.setActiveSession(payload.sessionName);
+        console.log(`WebSocket: Switched to tmux session "${payload.sessionName}"`);
+        // Tag the session as managed by Companion (adopt if not already tagged)
+        await this.tmux.tagSession(payload.sessionName);
+        // Refresh tmux paths so watcher picks up the newly tagged session
+        await this.watcher.refreshTmuxPaths();
+        // Try to find and switch to the corresponding conversation session
+        // Get the tmux session's working directory
+        const sessions = await this.tmux.listSessions();
+        const tmuxSession = sessions.find(s => s.name === payload.sessionName);
+        let conversationSessionId;
+        if (tmuxSession?.workingDir) {
+            // Store the session config for potential recreation later
+            this.storeTmuxSessionConfig(payload.sessionName, tmuxSession.workingDir, true);
+            // Encode the working directory the same way the CLI does: /a/b/c -> -a-b-c
+            const encodedPath = tmuxSession.workingDir.replace(/\//g, '-');
+            // Find conversation session whose ID matches or starts with this encoded path
+            const convSessions = this.watcher.getSessions();
+            const matchingConv = convSessions.find(cs => cs.id === encodedPath);
+            if (matchingConv) {
+                this.watcher.setActiveSession(matchingConv.id);
+                conversationSessionId = matchingConv.id;
+                console.log(`WebSocket: Switched conversation to "${matchingConv.id}" for project ${tmuxSession.workingDir}`);
+            }
+            else {
+                // No conversation yet for this project - clear active session so old data stops flowing
+                this.watcher.clearActiveSession();
+                console.log(`WebSocket: No conversation found for ${encodedPath}, cleared active session. Available: ${convSessions.map(c => c.id).join(', ')}`);
+            }
+        }
+        else {
+            // No working directory - clear active session
+            this.watcher.clearActiveSession();
+            console.log(`WebSocket: No working directory for tmux session, cleared active session`);
+        }
+        this.send(client.ws, {
+            type: 'tmux_session_switched',
+            success: true,
+            payload: {
+                sessionName: payload.sessionName,
+                conversationSessionId,
+            },
+            requestId,
+        });
+    }
+    async handleRecreateTmuxSession(client, payload, requestId) {
+        // Use provided session name or the currently active one
+        const sessionName = payload?.sessionName || this.injector.getActiveSession();
+        const savedConfig = this.tmuxSessionConfigs.get(sessionName);
+        if (!savedConfig) {
+            this.send(client.ws, {
+                type: 'tmux_session_recreated',
+                success: false,
+                error: `No saved configuration for session "${sessionName}"`,
+                requestId,
+            });
+            return;
+        }
+        // Check if directory still exists
+        if (!fs.existsSync(savedConfig.workingDir)) {
+            this.send(client.ws, {
+                type: 'tmux_session_recreated',
+                success: false,
+                error: `Working directory no longer exists: ${savedConfig.workingDir}`,
+                requestId,
+            });
+            return;
+        }
+        // Check if session already exists (maybe it was recreated manually)
+        const exists = await this.tmux.sessionExists(sessionName);
+        if (exists) {
+            this.send(client.ws, {
+                type: 'tmux_session_recreated',
+                success: true,
+                payload: {
+                    sessionName,
+                    workingDir: savedConfig.workingDir,
+                    alreadyExisted: true,
+                },
+                requestId,
+            });
+            return;
+        }
+        console.log(`WebSocket: Recreating tmux session "${sessionName}" in ${savedConfig.workingDir}`);
+        const result = await this.tmux.createSession(savedConfig.name, savedConfig.workingDir, savedConfig.startCli);
+        if (result.success) {
+            // Update the last used timestamp
+            this.storeTmuxSessionConfig(savedConfig.name, savedConfig.workingDir, savedConfig.startCli);
+            // Ensure we're targeting this session
+            this.injector.setActiveSession(sessionName);
+            this.send(client.ws, {
+                type: 'tmux_session_recreated',
+                success: true,
+                payload: {
+                    sessionName,
+                    workingDir: savedConfig.workingDir,
+                },
+                requestId,
+            });
+            // Broadcast to all clients
+            this.broadcast('tmux_sessions_changed', { action: 'recreated', sessionName });
+        }
+        else {
+            this.send(client.ws, {
+                type: 'tmux_session_recreated',
+                success: false,
+                error: result.error,
+                requestId,
+            });
+        }
+    }
+    async handleBrowseDirectories(client, payload, requestId) {
+        const basePath = payload?.path || this.tmux.getHomeDir();
+        try {
+            // Get directory contents
+            const entries = [];
+            // Add parent directory option if not at root
+            if (basePath !== '/') {
+                entries.push({
+                    name: '..',
+                    path: path.dirname(basePath),
+                    isDirectory: true,
+                });
+            }
+            const items = fs.readdirSync(basePath, { withFileTypes: true });
+            for (const item of items) {
+                // Skip hidden files and common non-project directories
+                if (item.name.startsWith('.') && item.name !== '..')
+                    continue;
+                if (['node_modules', '__pycache__', 'venv', '.git'].includes(item.name))
+                    continue;
+                if (item.isDirectory()) {
+                    entries.push({
+                        name: item.name,
+                        path: path.join(basePath, item.name),
+                        isDirectory: true,
+                    });
+                }
+            }
+            // Sort: directories first, then alphabetically
+            entries.sort((a, b) => {
+                if (a.name === '..')
+                    return -1;
+                if (b.name === '..')
+                    return 1;
+                return a.name.localeCompare(b.name);
+            });
+            this.send(client.ws, {
+                type: 'directory_listing',
+                success: true,
+                payload: {
+                    currentPath: basePath,
+                    entries: entries.slice(0, 100), // Limit to 100 entries
+                },
+                requestId,
+            });
+        }
+        catch (err) {
+            this.send(client.ws, {
+                type: 'directory_listing',
+                success: false,
+                error: `Cannot read directory: ${basePath}`,
+                requestId,
+            });
+        }
+    }
+    async handleReadFile(client, payload, requestId) {
+        const filePath = payload?.path;
+        if (!filePath) {
+            this.send(client.ws, {
+                type: 'file_content',
+                success: false,
+                error: 'No file path provided',
+                requestId,
+            });
+            return;
+        }
+        try {
+            const homeDir = this.tmux.getHomeDir();
+            let resolvedPath;
+            // Handle different path formats
+            if (filePath.startsWith('~/')) {
+                // Expand ~ to home directory
+                resolvedPath = path.join(homeDir, filePath.slice(2));
+            }
+            else if (filePath.startsWith('/')) {
+                // Absolute path
+                resolvedPath = filePath;
+            }
+            else {
+                // Relative path - resolve against active tmux session's working directory
+                // (more reliable than decoded project path which can mangle hyphenated names)
+                const sessions = await this.tmux.listSessions();
+                const activeSessionId = this.watcher.getActiveSessionId();
+                // Try to find matching tmux session by encoded path
+                let workingDir = homeDir;
+                if (activeSessionId) {
+                    // The session ID is the encoded path like -Users-foo-project
+                    // Match it against tmux session working directories
+                    const matchingSession = sessions.find(s => {
+                        if (!s.workingDir)
+                            return false;
+                        const encoded = s.workingDir.replace(/\//g, '-');
+                        return encoded === activeSessionId || s.name === activeSessionId;
+                    });
+                    if (matchingSession?.workingDir) {
+                        workingDir = matchingSession.workingDir;
+                    }
+                }
+                resolvedPath = path.resolve(workingDir, filePath);
+            }
+            // Normalize the path
+            resolvedPath = path.normalize(resolvedPath);
+            // Security: only allow reading files in certain directories
+            const allowedPaths = [
+                homeDir,
+                '/tmp',
+                '/var/tmp',
+            ];
+            const isAllowed = allowedPaths.some(allowed => resolvedPath.startsWith(allowed));
+            if (!isAllowed) {
+                this.send(client.ws, {
+                    type: 'file_content',
+                    success: false,
+                    error: `Access denied: file outside allowed directories (resolved: ${resolvedPath})`,
+                    requestId,
+                });
+                return;
+            }
+            // Check file exists and is readable
+            const stats = fs.statSync(resolvedPath);
+            if (stats.isDirectory()) {
+                this.send(client.ws, {
+                    type: 'file_content',
+                    success: false,
+                    error: 'Path is a directory, not a file',
+                    requestId,
+                });
+                return;
+            }
+            // Limit file size to 1MB
+            if (stats.size > 1024 * 1024) {
+                this.send(client.ws, {
+                    type: 'file_content',
+                    success: false,
+                    error: 'File too large (max 1MB)',
+                    requestId,
+                });
+                return;
+            }
+            const content = fs.readFileSync(resolvedPath, 'utf-8');
+            this.send(client.ws, {
+                type: 'file_content',
+                success: true,
+                payload: { content, path: resolvedPath },
+                requestId,
+            });
+        }
+        catch (err) {
+            this.send(client.ws, {
+                type: 'file_content',
+                success: false,
+                error: `Cannot read file: ${err instanceof Error ? err.message : 'Unknown error'}`,
+                requestId,
+            });
+        }
+    }
+    async handleDownloadFile(client, payload, requestId) {
+        const filePath = payload?.path;
+        if (!filePath) {
+            this.send(client.ws, {
+                type: 'file_download',
+                success: false,
+                error: 'No file path provided',
+                requestId,
+            });
+            return;
+        }
+        try {
+            const homeDir = this.tmux.getHomeDir();
+            let resolvedPath;
+            // Handle different path formats
+            if (filePath.startsWith('~/')) {
+                resolvedPath = path.join(homeDir, filePath.slice(2));
+            }
+            else if (filePath.startsWith('/')) {
+                resolvedPath = filePath;
+            }
+            else {
+                // Relative path - resolve against home
+                resolvedPath = path.resolve(homeDir, filePath);
+            }
+            resolvedPath = path.normalize(resolvedPath);
+            // Security: only allow downloading files in certain directories
+            const allowedPaths = [homeDir, '/tmp', '/var/tmp'];
+            const isAllowed = allowedPaths.some(allowed => resolvedPath.startsWith(allowed));
+            if (!isAllowed) {
+                this.send(client.ws, {
+                    type: 'file_download',
+                    success: false,
+                    error: `Access denied: file outside allowed directories`,
+                    requestId,
+                });
+                return;
+            }
+            // Only allow specific file types for download
+            const allowedExtensions = ['.apk', '.ipa', '.zip', '.tar.gz', '.tgz'];
+            const ext = path.extname(resolvedPath).toLowerCase();
+            const isApkOrZip = allowedExtensions.some(e => resolvedPath.toLowerCase().endsWith(e));
+            if (!isApkOrZip) {
+                this.send(client.ws, {
+                    type: 'file_download',
+                    success: false,
+                    error: `File type not allowed for download. Allowed: ${allowedExtensions.join(', ')}`,
+                    requestId,
+                });
+                return;
+            }
+            const stats = fs.statSync(resolvedPath);
+            if (stats.isDirectory()) {
+                this.send(client.ws, {
+                    type: 'file_download',
+                    success: false,
+                    error: 'Path is a directory, not a file',
+                    requestId,
+                });
+                return;
+            }
+            // Limit to 150MB for APKs
+            const maxSize = 150 * 1024 * 1024;
+            if (stats.size > maxSize) {
+                this.send(client.ws, {
+                    type: 'file_download',
+                    success: false,
+                    error: `File too large (max 150MB, file is ${Math.round(stats.size / 1024 / 1024)}MB)`,
+                    requestId,
+                });
+                return;
+            }
+            // Read file as binary and encode as base64
+            const content = fs.readFileSync(resolvedPath);
+            const base64 = content.toString('base64');
+            const fileName = path.basename(resolvedPath);
+            console.log(`WebSocket: Sending file download: ${fileName} (${Math.round(stats.size / 1024)}KB)`);
+            this.send(client.ws, {
+                type: 'file_download',
+                success: true,
+                payload: {
+                    fileName,
+                    size: stats.size,
+                    mimeType: ext === '.apk' ? 'application/vnd.android.package-archive' : 'application/octet-stream',
+                    data: base64,
+                },
+                requestId,
+            });
+        }
+        catch (err) {
+            this.send(client.ws, {
+                type: 'file_download',
+                success: false,
+                error: `Cannot download file: ${err instanceof Error ? err.message : 'Unknown error'}`,
+                requestId,
+            });
+        }
+    }
+    async handleGetApiUsage(client, payload, requestId) {
+        const adminApiKey = this.config.anthropicAdminApiKey;
+        if (!adminApiKey) {
+            this.send(client.ws, {
+                type: 'api_usage',
+                success: false,
+                error: 'No Anthropic Admin API key configured. Add "anthropicAdminApiKey" to your config.json (key starts with sk-ant-admin-...)',
+                requestId,
+            });
+            return;
+        }
+        try {
+            const period = payload?.period || 'today';
+            let stats;
+            if (period === 'today') {
+                stats = await (0, anthropic_usage_1.fetchTodayUsage)(adminApiKey);
+            }
+            else if (period === 'month') {
+                stats = await (0, anthropic_usage_1.fetchMonthUsage)(adminApiKey);
+            }
+            else if (period === 'custom' && payload?.startDate && payload?.endDate) {
+                stats = await (0, anthropic_usage_1.fetchAnthropicUsage)(adminApiKey, new Date(payload.startDate), new Date(payload.endDate));
+            }
+            else {
+                stats = await (0, anthropic_usage_1.fetchTodayUsage)(adminApiKey);
+            }
+            this.send(client.ws, {
+                type: 'api_usage',
+                success: true,
+                payload: stats,
+                requestId,
+            });
+        }
+        catch (err) {
+            console.error('Failed to get API usage:', err);
+            this.send(client.ws, {
+                type: 'api_usage',
+                success: false,
+                error: `Failed to fetch API usage: ${err instanceof Error ? err.message : 'Unknown error'}`,
+                requestId,
+            });
+        }
+    }
+    handleGetAgentTree(client, payload, requestId) {
+        if (!this.subAgentWatcher) {
+            this.send(client.ws, {
+                type: 'agent_tree',
+                success: false,
+                error: 'Sub-agent watcher not initialized',
+                requestId,
+            });
+            return;
+        }
+        try {
+            const tree = this.subAgentWatcher.getAgentTree(payload?.sessionId);
+            this.send(client.ws, {
+                type: 'agent_tree',
+                success: true,
+                payload: tree,
+                requestId,
+            });
+        }
+        catch (err) {
+            console.error('Failed to get agent tree:', err);
+            this.send(client.ws, {
+                type: 'agent_tree',
+                success: false,
+                error: 'Failed to get agent tree',
+                requestId,
+            });
+        }
+    }
+    handleGetAgentDetail(client, payload, requestId) {
+        if (!this.subAgentWatcher) {
+            this.send(client.ws, {
+                type: 'agent_detail',
+                success: false,
+                error: 'Sub-agent watcher not initialized',
+                requestId,
+            });
+            return;
+        }
+        if (!payload?.agentId) {
+            this.send(client.ws, {
+                type: 'agent_detail',
+                success: false,
+                error: 'Missing agentId',
+                requestId,
+            });
+            return;
+        }
+        try {
+            const detail = this.subAgentWatcher.getAgentDetail(payload.agentId);
+            if (!detail) {
+                this.send(client.ws, {
+                    type: 'agent_detail',
+                    success: false,
+                    error: 'Agent not found',
+                    requestId,
+                });
+                return;
+            }
+            this.send(client.ws, {
+                type: 'agent_detail',
+                success: true,
+                payload: detail,
+                requestId,
+            });
+        }
+        catch (err) {
+            console.error('Failed to get agent detail:', err);
+            this.send(client.ws, {
+                type: 'agent_detail',
+                success: false,
+                error: 'Failed to get agent detail',
+                requestId,
+            });
+        }
+    }
+    handleClientError(client, payload, requestId) {
+        // Log to console (goes to journalctl)
+        console.error('Client error:', payload.message);
+        if (payload.stack) {
+            console.error('Stack:', payload.stack);
+        }
+        // Store in memory for later retrieval
+        const error = {
+            message: payload.message,
+            stack: payload.stack,
+            componentStack: payload.componentStack,
+            timestamp: payload.timestamp || Date.now(),
+            deviceId: client.deviceId,
+        };
+        this.clientErrors.unshift(error);
+        if (this.clientErrors.length > this.MAX_CLIENT_ERRORS) {
+            this.clientErrors = this.clientErrors.slice(0, this.MAX_CLIENT_ERRORS);
+        }
+        this.send(client.ws, {
+            type: 'client_error',
+            success: true,
+            requestId,
+        });
+    }
+    handleGetClientErrors(client, requestId) {
+        this.send(client.ws, {
+            type: 'client_errors',
+            success: true,
+            payload: {
+                errors: this.clientErrors,
+                count: this.clientErrors.length,
+            },
+            requestId,
+        });
+    }
+    handleScrollLog(payload) {
+        this.scrollLogs.push(payload);
+        if (this.scrollLogs.length > this.MAX_SCROLL_LOGS) {
+            this.scrollLogs = this.scrollLogs.slice(-this.MAX_SCROLL_LOGS);
+        }
+        // Also log to console for real-time viewing via journalctl
+        console.log(`[SCROLL] ${payload.event}:`, JSON.stringify(payload));
+    }
+    handleGetScrollLogs(client, requestId) {
+        this.send(client.ws, {
+            type: 'scroll_logs',
+            success: true,
+            payload: {
+                logs: this.scrollLogs,
+                count: this.scrollLogs.length,
+            },
+            requestId,
+        });
+    }
+    handleGetUsage(client, requestId) {
+        try {
+            const sessions = this.watcher.getSessions();
+            const sessionUsages = [];
+            let totalInputTokens = 0;
+            let totalOutputTokens = 0;
+            let totalCacheCreationTokens = 0;
+            let totalCacheReadTokens = 0;
+            for (const session of sessions) {
+                if (session.conversationPath) {
+                    const usage = (0, parser_1.extractUsageFromFile)(session.conversationPath, session.name);
+                    sessionUsages.push(usage);
+                    totalInputTokens += usage.totalInputTokens;
+                    totalOutputTokens += usage.totalOutputTokens;
+                    totalCacheCreationTokens += usage.totalCacheCreationTokens;
+                    totalCacheReadTokens += usage.totalCacheReadTokens;
+                }
+            }
+            this.send(client.ws, {
+                type: 'usage',
+                success: true,
+                payload: {
+                    sessions: sessionUsages,
+                    totalInputTokens,
+                    totalOutputTokens,
+                    totalCacheCreationTokens,
+                    totalCacheReadTokens,
+                    periodStart: Date.now() - 24 * 60 * 60 * 1000, // Last 24h
+                    periodEnd: Date.now(),
+                },
+                requestId,
+            });
+        }
+        catch (err) {
+            console.error('Failed to get usage:', err);
+            this.send(client.ws, {
+                type: 'usage',
+                success: false,
+                error: 'Failed to get usage statistics',
+                requestId,
+            });
+        }
+    }
+    send(ws, response) {
+        if (ws.readyState === ws_1.WebSocket.OPEN) {
+            const data = JSON.stringify(response);
+            if (response.type !== 'pong' && response.requestId) {
+                console.log(`WebSocket: << send ${response.type} (${response.requestId}) ${data.length} bytes`);
+            }
+            ws.send(data);
+        }
+        else {
+            console.log(`WebSocket: !! send FAILED - ws not open (state: ${ws.readyState}) for ${response.type}`);
+        }
+    }
+    sendError(ws, error) {
+        this.send(ws, {
+            type: 'error',
+            success: false,
+            error,
+        });
+    }
+    broadcast(type, payload, sessionId) {
+        // Get the session ID to include in the message
+        const activeSessionId = sessionId || this.watcher.getActiveSessionId();
+        const message = JSON.stringify({
+            type,
+            success: true,
+            payload,
+            sessionId: activeSessionId, // Always include session context
+        });
+        for (const client of this.clients.values()) {
+            if (client.authenticated && client.subscribed && client.ws.readyState === ws_1.WebSocket.OPEN) {
+                // Only send to clients subscribed to this session (or all if no session filter)
+                if (!client.subscribedSessionId || client.subscribedSessionId === activeSessionId) {
+                    client.ws.send(message);
+                }
+            }
+        }
+    }
+    getConnectedClientCount() {
+        return this.clients.size;
+    }
+    getAuthenticatedClientCount() {
+        return Array.from(this.clients.values()).filter((c) => c.authenticated).length;
+    }
+}
+exports.WebSocketHandler = WebSocketHandler;
+//# sourceMappingURL=websocket.js.map