genbox-agent 1.0.123 → 1.0.125

package/dist/genbox-agent.js

@@ -0,0 +1,1170 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Unified Genbox Agent Daemon
+ *
+ * WebSocket client that runs on each genbox VM and supports multiple AI CLI tools:
+ * - Claude Code
+ * - Gemini CLI
+ * - OpenAI Codex CLI
+ *
+ * Features:
+ * 1. Connects to the backend monitoring service
+ * 2. Receives remote commands (send_prompt, send_keystroke, create_session)
+ * 3. Manages dtach sessions for all supported AI CLIs
+ * 4. Streams terminal output back to the dashboard
+ * 5. Auto-detects installed AI CLIs
+ */
+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 });
+// Handle --version and --help BEFORE any imports or env checks
+const earlyArgs = process.argv.slice(2);
+if (earlyArgs.includes('--version') || earlyArgs.includes('-v') || earlyArgs.includes('-V')) {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const pkg = require('../package.json');
+    console.log(pkg.version);
+    process.exit(0);
+}
+if (earlyArgs.includes('--help') || earlyArgs.includes('-h')) {
+    console.log(`
+genbox-agent - Unified agent for AI CLI sessions
+
+Usage:
+  genbox-agent --native [--server]    Run in local/native mode
+  genbox-agent --version              Show version number
+  genbox-agent --help                 Show this help message
+
+Options:
+  --native          Run in local mode (no cloud connection required)
+  --server, -s      Enable HTTP/WebSocket server for desktop app
+  --port <port>     Server port (default: 47191)
+  --no-sync         Disable background sync
+  --control-token   Set authentication token for server
+
+Environment Variables (for cloud mode):
+  GENBOX_ID         The genbox instance ID
+  GENBOX_TOKEN      Authentication token for backend
+
+Examples:
+  genbox-agent --native --server      Start daemon for desktop app
+  genbox-agent --native               Start daemon without server
+`);
+    process.exit(0);
+}
+const socket_io_client_1 = require("socket.io-client");
+const child_process_1 = require("child_process");
+const providers_1 = require("./providers");
+// Configuration from environment
+const GENBOX_ID = process.env.GENBOX_ID || '';
+const GENBOX_TOKEN = process.env.GENBOX_TOKEN || '';
+const MONITORING_WS_URL = process.env.MONITORING_WS_URL || 'http://localhost:3001';
+// Output polling interval (ms) - lower for smoother terminal updates
+const OUTPUT_POLL_INTERVAL = 500;
+// System stats reporting interval (ms)
+const STATS_INTERVAL = 10000; // 10 seconds
+/**
+ * Collect system stats from the local machine (cross-platform: macOS + Linux)
+ */
+function collectSystemStats() {
+    try {
+        const isMacOS = process.platform === 'darwin';
+        let load1 = 0, load5 = 0, load15 = 0;
+        let diskTotal = 0, diskUsed = 0, diskPct = 0;
+        let memTotal = 0, memUsed = 0, memPct = 0;
+        let swapTotal = 0, swapUsed = 0, swapPct = 0;
+        let procCount = 0;
+        let uptimeSec = 0;
+        if (isMacOS) {
+            // macOS: Load averages from sysctl
+            try {
+                const loadAvgRaw = (0, child_process_1.execSync)("sysctl -n vm.loadavg", { encoding: 'utf8' }).trim();
+                // Output format: { 1.23 1.45 1.67 }
+                const match = loadAvgRaw.match(/\{\s*([\d.]+)\s+([\d.]+)\s+([\d.]+)\s*\}/);
+                if (match) {
+                    [, load1, load5, load15] = match.map(v => parseFloat(v) || 0);
+                }
+            }
+            catch { /* ignore */ }
+            // macOS: Disk usage (use -m for megabytes instead of -BM)
+            try {
+                const dfOutput = (0, child_process_1.execSync)("df -m / | tail -1", { encoding: 'utf8' }).trim();
+                const dfParts = dfOutput.split(/\s+/);
+                // macOS df -m output: Filesystem 512-blocks Used Available Capacity ...
+                diskTotal = parseInt(dfParts[1] || '0', 10);
+                diskUsed = parseInt(dfParts[2] || '0', 10);
+                diskPct = parseInt(dfParts[4]?.replace('%', '') || '0', 10);
+            }
+            catch { /* ignore */ }
+            // macOS: Memory usage via vm_stat
+            try {
+                const vmStatOutput = (0, child_process_1.execSync)("vm_stat", { encoding: 'utf8' });
+                const pageSize = 16384; // Default page size on macOS (can also get from vm_stat output)
+                const pageSizeMatch = vmStatOutput.match(/page size of (\d+) bytes/);
+                const actualPageSize = pageSizeMatch ? parseInt(pageSizeMatch[1], 10) : pageSize;
+                const freeMatch = vmStatOutput.match(/Pages free:\s+(\d+)/);
+                const activeMatch = vmStatOutput.match(/Pages active:\s+(\d+)/);
+                const inactiveMatch = vmStatOutput.match(/Pages inactive:\s+(\d+)/);
+                const wiredMatch = vmStatOutput.match(/Pages wired down:\s+(\d+)/);
+                const compressedMatch = vmStatOutput.match(/Pages occupied by compressor:\s+(\d+)/);
+                const freePages = parseInt(freeMatch?.[1] || '0', 10);
+                const activePages = parseInt(activeMatch?.[1] || '0', 10);
+                const inactivePages = parseInt(inactiveMatch?.[1] || '0', 10);
+                const wiredPages = parseInt(wiredMatch?.[1] || '0', 10);
+                const compressedPages = parseInt(compressedMatch?.[1] || '0', 10);
+                // Get total memory from sysctl
+                const totalMemBytes = parseInt((0, child_process_1.execSync)("sysctl -n hw.memsize", { encoding: 'utf8' }).trim(), 10);
+                memTotal = Math.round(totalMemBytes / 1024 / 1024); // Convert to MB
+                const usedPages = activePages + wiredPages + compressedPages;
+                memUsed = Math.round((usedPages * actualPageSize) / 1024 / 1024);
+                memPct = memTotal > 0 ? Math.round((memUsed * 100) / memTotal) : 0;
+            }
+            catch { /* ignore */ }
+            // macOS: Swap usage via sysctl
+            try {
+                const swapUsageOutput = (0, child_process_1.execSync)("sysctl -n vm.swapusage", { encoding: 'utf8' }).trim();
+                // Output format: total = 2048.00M  used = 1024.00M  free = 1024.00M  ...
+                const totalMatch = swapUsageOutput.match(/total\s*=\s*([\d.]+)M/);
+                const usedMatch = swapUsageOutput.match(/used\s*=\s*([\d.]+)M/);
+                swapTotal = Math.round(parseFloat(totalMatch?.[1] || '0'));
+                swapUsed = Math.round(parseFloat(usedMatch?.[1] || '0'));
+                swapPct = swapTotal > 0 ? Math.round((swapUsed * 100) / swapTotal) : 0;
+            }
+            catch { /* ignore */ }
+            // macOS: Uptime via sysctl
+            try {
+                const bootTimeOutput = (0, child_process_1.execSync)("sysctl -n kern.boottime", { encoding: 'utf8' }).trim();
+                // Output format: { sec = 1234567890, usec = 123456 } ...
+                const secMatch = bootTimeOutput.match(/sec\s*=\s*(\d+)/);
+                if (secMatch) {
+                    const bootTimeSec = parseInt(secMatch[1], 10);
+                    uptimeSec = Math.floor(Date.now() / 1000) - bootTimeSec;
+                }
+            }
+            catch { /* ignore */ }
+        }
+        else {
+            // Linux: Load averages from /proc/loadavg
+            const loadAvgRaw = (0, child_process_1.execSync)("cat /proc/loadavg | awk '{print $1,$2,$3}'", { encoding: 'utf8' }).trim();
+            [load1, load5, load15] = loadAvgRaw.split(' ').map(parseFloat);
+            // Linux: Disk usage (root filesystem)
+            const dfOutput = (0, child_process_1.execSync)("df -BM / | tail -1", { encoding: 'utf8' }).trim();
+            const dfParts = dfOutput.split(/\s+/);
+            diskTotal = parseInt(dfParts[1]?.replace('M', '') || '0', 10);
+            diskUsed = parseInt(dfParts[2]?.replace('M', '') || '0', 10);
+            diskPct = parseInt(dfParts[4]?.replace('%', '') || '0', 10);
+            // Linux: Memory usage
+            const memOutput = (0, child_process_1.execSync)("free -m | grep Mem", { encoding: 'utf8' }).trim();
+            const memParts = memOutput.split(/\s+/);
+            memTotal = parseInt(memParts[1] || '0', 10);
+            memUsed = parseInt(memParts[2] || '0', 10);
+            memPct = memTotal > 0 ? Math.round((memUsed * 100) / memTotal) : 0;
+            // Linux: Swap usage
+            const swapOutput = (0, child_process_1.execSync)("free -m | grep Swap", { encoding: 'utf8' }).trim();
+            const swapParts = swapOutput.split(/\s+/);
+            swapTotal = parseInt(swapParts[1] || '0', 10);
+            swapUsed = parseInt(swapParts[2] || '0', 10);
+            swapPct = swapTotal > 0 ? Math.round((swapUsed * 100) / swapTotal) : 0;
+            // Linux: Uptime in seconds
+            uptimeSec = parseInt((0, child_process_1.execSync)("awk '{print int($1)}' /proc/uptime", { encoding: 'utf8' }).trim(), 10);
+        }
+        // Cross-platform: Process count
+        procCount = parseInt((0, child_process_1.execSync)("ps aux | wc -l", { encoding: 'utf8' }).trim(), 10);
+        // Docker services
+        let dockerServices = [];
+        try {
+            const dockerOutput = (0, child_process_1.execSync)("docker ps -a --format '{{.Names}}|{{.Status}}' 2>/dev/null | head -20", { encoding: 'utf8', timeout: 5000 }).trim();
+            if (dockerOutput) {
+                dockerServices = dockerOutput.split('\n').filter(Boolean).map(line => {
+                    const [name, status] = line.split('|');
+                    let health;
+                    if (status?.includes('(healthy)'))
+                        health = 'healthy';
+                    else if (status?.includes('(unhealthy)'))
+                        health = 'unhealthy';
+                    else if (status?.includes('(health:'))
+                        health = 'starting';
+                    return { name: name || '', status: status || '', ...(health && { health }) };
+                });
+            }
+        }
+        catch {
+            // Docker not available or command failed
+        }
+        // PM2 services
+        let pm2Services = [];
+        try {
+            const pm2Output = (0, child_process_1.execSync)("source /home/dev/.nvm/nvm.sh 2>/dev/null && pm2 jlist 2>/dev/null", { encoding: 'utf8', shell: '/bin/bash', timeout: 5000 }).trim();
+            if (pm2Output) {
+                const pm2Data = JSON.parse(pm2Output);
+                pm2Services = pm2Data.map((app) => ({
+                    name: app.name || '',
+                    status: app.pm2_env?.status || 'unknown',
+                    cpu: app.monit?.cpu || 0,
+                    memory: Math.round((app.monit?.memory || 0) / 1024 / 1024), // Convert to MB
+                }));
+            }
+        }
+        catch {
+            // PM2 not available or command failed
+        }
+        return {
+            loadAvg: [load1 || 0, load5 || 0, load15 || 0],
+            diskUsagePercent: diskPct,
+            diskUsedGb: Math.round(diskUsed / 1024),
+            diskTotalGb: Math.round(diskTotal / 1024),
+            memoryUsagePercent: memPct,
+            memoryUsedMb: memUsed,
+            memoryTotalMb: memTotal,
+            swapUsagePercent: swapPct,
+            processCount: procCount,
+            uptimeSeconds: uptimeSec,
+            dockerServices,
+            pm2Services,
+        };
+    }
+    catch (error) {
+        console.error('Failed to collect system stats:', error);
+        return null;
+    }
+}
+class UnifiedGenboxDaemon {
+    genboxId;
+    token;
+    wsUrl;
+    socket = null;
+    sessionManager;
+    registry;
+    running = false;
+    outputPollers = new Map();
+    statsInterval = null;
+    // Mapping from session IDs (from hooks) to dtach socket paths
+    knownSessions = new Map();
+    // Storage manager for message sync (ContinuousJsonlSync handles file watching)
+    storageManager = null;
+    /**
+     * Find a known session by ID, supporting both exact and partial matches
+     * (dashboard may show truncated IDs like "84a7b76b" instead of full UUID)
+     */
+    findKnownSession(sessionId) {
+        // Try exact match first
+        const exact = this.knownSessions.get(sessionId);
+        if (exact)
+            return exact;
+        // Try partial match (sessionId might be truncated or full UUID might start with it)
+        for (const [fullId, mapping] of this.knownSessions.entries()) {
+            if (fullId.startsWith(sessionId) || sessionId.startsWith(fullId)) {
+                return mapping;
+            }
+        }
+        return undefined;
+    }
+    constructor(genboxId, token, wsUrl) {
+        this.genboxId = genboxId;
+        this.token = token;
+        this.wsUrl = wsUrl;
+        this.registry = providers_1.ProviderRegistry.getInstance();
+        this.sessionManager = new providers_1.UnifiedSessionManager(genboxId);
+    }
+    async connect() {
+        return new Promise((resolve) => {
+            console.log(`[${this.genboxId}] Connecting to ${this.wsUrl}/ai-monitoring...`);
+            this.socket = (0, socket_io_client_1.io)(`${this.wsUrl}/ai-monitoring`, {
+                query: { genboxId: this.genboxId, type: 'genbox' },
+                auth: { genboxId: this.genboxId, token: this.token },
+                transports: ['websocket', 'polling'],
+                reconnection: true,
+                reconnectionAttempts: Infinity,
+                reconnectionDelay: 1000,
+                reconnectionDelayMax: 30000,
+            });
+            this.socket.on('connect', () => {
+                console.log(`[${this.genboxId}] Connected to monitoring server`);
+                this.running = true;
+                this.onConnect();
+                resolve(true);
+            });
+            this.socket.on('disconnect', (reason) => {
+                console.log(`[${this.genboxId}] Disconnected: ${reason}`);
+                this.running = false;
+            });
+            this.socket.on('connect_error', (error) => {
+                console.error(`[${this.genboxId}] Connection error:`, error.message);
+            });
+            // Register event handlers
+            this.socket.on('send_prompt', this.onSendPrompt.bind(this));
+            this.socket.on('send_keystroke', this.onSendKeystroke.bind(this));
+            this.socket.on('create_session', this.onCreateSession.bind(this));
+            this.socket.on('get_output', this.onGetOutput.bind(this));
+            this.socket.on('kill_session', this.onKillSession.bind(this));
+            this.socket.on('list_sessions', this.onListSessions.bind(this));
+            this.socket.on('get_providers', this.onGetProviders.bind(this));
+            this.socket.on('known_sessions', this.onKnownSessions.bind(this));
+            this.socket.on('error', this.onError.bind(this));
+            // Timeout after 10 seconds
+            setTimeout(() => {
+                if (!this.socket?.connected) {
+                    console.error('Connection timeout');
+                    resolve(false);
+                }
+            }, 10000);
+        });
+    }
+    onConnect() {
+        // Get detected providers
+        const detectedProviders = this.sessionManager.getDetectedProviders();
+        const providers = [];
+        for (const [provider, detection] of detectedProviders) {
+            if (detection.detected) {
+                providers.push({ provider, version: detection.version });
+            }
+        }
+        // Register as genbox agent with provider info
+        this.socket?.emit('register_agent', {
+            genboxId: this.genboxId,
+            token: this.token,
+            providers,
+        });
+        // Send initial session list
+        const sessions = this.sessionManager.listAllSessions();
+        this.socket?.emit('agent_sessions', {
+            genboxId: this.genboxId,
+            sessions,
+        });
+        // Start output polling for all existing sessions
+        // Note: JSONL message sync is handled by ContinuousJsonlSync (not per-session watchers)
+        for (const session of sessions) {
+            this.startOutputPolling(session.sessionId);
+        }
+        if (sessions.length > 0) {
+            console.log(`[${this.genboxId}] Started output polling for ${sessions.length} existing sessions`);
+        }
+        // Start system stats polling
+        this.startStatsPolling();
+        // Send initial stats immediately
+        this.sendSystemStats();
+        console.log(`[${this.genboxId}] Detected providers:`, providers.map(p => p.provider).join(', '));
+    }
+    startStatsPolling() {
+        // Clear any existing interval
+        this.stopStatsPolling();
+        this.statsInterval = setInterval(() => {
+            if (this.running && this.socket?.connected) {
+                this.sendSystemStats();
+            }
+        }, STATS_INTERVAL);
+        console.log(`[${this.genboxId}] Started system stats polling (every ${STATS_INTERVAL / 1000}s)`);
+    }
+    stopStatsPolling() {
+        if (this.statsInterval) {
+            clearInterval(this.statsInterval);
+            this.statsInterval = null;
+        }
+    }
+    sendSystemStats() {
+        const stats = collectSystemStats();
+        if (stats && this.socket?.connected) {
+            this.socket.emit('system_stats', {
+                genboxId: this.genboxId,
+                stats,
+            });
+        }
+    }
+    onSendPrompt(data) {
+        const { sessionId, prompt, requestId } = data;
+        if (!sessionId || !prompt)
+            return;
+        console.log(`[${this.genboxId}] Sending prompt to ${sessionId}: ${prompt.slice(0, 50)}...`);
+        let success = false;
+        const knownSession = this.findKnownSession(sessionId);
+        if (knownSession?.dtachSocket) {
+            // Use direct dtach commands for known sessions
+            success = this.sendPromptToDtach(knownSession.dtachSocket, prompt);
+        }
+        else {
+            // Fall back to session manager
+            success = this.sessionManager.sendPrompt(sessionId, prompt);
+        }
+        this.socket?.emit('prompt_result', {
+            genboxId: this.genboxId,
+            sessionId,
+            requestId,
+            success,
+        });
+        // Capture output after a delay
+        if (success) {
+            setTimeout(() => this.captureAndSendOutput(sessionId), 1000);
+        }
+    }
+    onSendKeystroke(data) {
+        const { sessionId, key, requestId } = data;
+        if (!sessionId || !key)
+            return;
+        console.log(`[${this.genboxId}] Sending keystroke to ${sessionId}: ${key}`);
+        let success = false;
+        const knownSession = this.findKnownSession(sessionId);
+        if (knownSession?.dtachSocket) {
+            // Use direct dtach commands for known sessions
+            success = this.sendKeystrokeToDtach(knownSession.dtachSocket, key);
+        }
+        else {
+            // Fall back to session manager
+            success = this.sessionManager.sendKeystroke(sessionId, key);
+        }
+        this.socket?.emit('keystroke_result', {
+            genboxId: this.genboxId,
+            sessionId,
+            requestId,
+            success,
+        });
+    }
+    /**
+     * Key mapping for dtach (raw terminal byte sequences)
+     */
+    keyMap = {
+        enter: '\r',
+        escape: '\x1b',
+        up: '\x1b[A',
+        down: '\x1b[B',
+        left: '\x1b[D',
+        right: '\x1b[C',
+        tab: '\t',
+        backspace: '\x7f',
+        delete: '\x1b[3~',
+        'ctrl-c': '\x03',
+        'ctrl-d': '\x04',
+        'ctrl-z': '\x1a',
+        y: 'y',
+        n: 'n',
+    };
+    sendPromptToDtach(socketPath, prompt) {
+        const { spawnSync } = require('child_process');
+        // Send the prompt text followed by Enter (carriage return)
+        const data = prompt + '\r';
+        const result = spawnSync('dtach', ['-p', socketPath], {
+            input: data,
+            timeout: 5000,
+            stdio: ['pipe', 'ignore', 'ignore'],
+        });
+        return result.status === 0;
+    }
+    sendKeystrokeToDtach(socketPath, key) {
+        const { spawnSync } = require('child_process');
+        // Map friendly key name to raw bytes
+        const keyBytes = this.keyMap[key.toLowerCase()] || key;
+        const result = spawnSync('dtach', ['-p', socketPath], {
+            input: keyBytes,
+            timeout: 5000,
+            stdio: ['pipe', 'ignore', 'ignore'],
+        });
+        return result.status === 0;
+    }
+    async onCreateSession(data) {
+        const { projectPath = '/home/dev', provider, requestId } = data;
+        console.log(`[${this.genboxId}] Creating new ${provider || 'default'} session at ${projectPath}`);
+        const session = await this.sessionManager.createSession(projectPath, provider);
+        if (session) {
+            this.socket?.emit('session_created', {
+                genboxId: this.genboxId,
+                sessionId: session.sessionId,
+                sessionName: session.sessionName,
+                provider: session.provider,
+                projectPath: session.projectPath,
+                requestId,
+                success: true,
+            });
+            // Start output polling for this session
+            this.startOutputPolling(session.sessionId);
+        }
+        else {
+            this.socket?.emit('session_created', {
+                genboxId: this.genboxId,
+                requestId,
+                success: false,
+                error: 'Failed to create session',
+            });
+        }
+    }
+    /**
+     * Check if a dtach socket is alive
+     */
+    isDtachSocketAlive(socketPath) {
+        const { spawnSync } = require('child_process');
+        const fs = require('fs');
+        if (!fs.existsSync(socketPath)) {
+            return false;
+        }
+        try {
+            const result = spawnSync('dtach', ['-p', socketPath], {
+                input: '',
+                timeout: 2000,
+                stdio: ['pipe', 'ignore', 'ignore'],
+            });
+            return result.status === 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Read output from a dtach session's log file
+     */
+    readDtachOutput(socketPath, lines) {
+        const fs = require('fs');
+        const logPath = socketPath.replace('.sock', '.log');
+        if (!fs.existsSync(logPath)) {
+            return null;
+        }
+        try {
+            const content = fs.readFileSync(logPath, 'utf-8');
+            const allLines = content.split('\n');
+            return allLines.slice(-lines).join('\n');
+        }
+        catch {
+            return null;
+        }
+    }
+    onGetOutput(data) {
+        const { sessionId, lines = 100, requestId } = data;
+        if (!sessionId)
+            return;
+        console.log(`[${this.genboxId}] get_output request for session ${sessionId}`);
+        let output = null;
+        let status = 'idle';
+        // Check if we have a known session mapping (session ID may have changed from original)
+        // Support both exact match and partial match (first 8 chars of UUID)
+        const knownSession = this.findKnownSession(sessionId);
+        console.log(`[${this.genboxId}] Known session lookup result:`, knownSession ? `found dtach=${knownSession.dtachSocket}` : 'not found');
+        if (knownSession?.dtachSocket) {
+            // Check if dtach socket is alive
+            if (!this.isDtachSocketAlive(knownSession.dtachSocket)) {
+                // Session doesn't exist - it ended
+                console.log(`[${this.genboxId}] Dtach socket ${knownSession.dtachSocket} not alive, session ended`);
+                status = 'ended';
+                output = ''; // Session ended, no live output available
+            }
+            else {
+                // Read from dtach session's log file
+                const capturedOutput = this.readDtachOutput(knownSession.dtachSocket, lines);
+                if (capturedOutput !== null) {
+                    output = capturedOutput;
+                    status = this.analyzeClaudeOutput(capturedOutput);
+                }
+            }
+        }
+        else {
+            // Fall back to session manager
+            output = this.sessionManager.getOutput(sessionId, lines);
+            status = this.sessionManager.getSessionStatus(sessionId);
+        }
+        this.socket?.emit('output_update', {
+            genboxId: this.genboxId,
+            sessionId,
+            requestId,
+            output: output || '',
+            status,
+        });
+    }
+    onKillSession(data) {
+        const { sessionId, requestId } = data;
+        if (!sessionId)
+            return;
+        console.log(`[${this.genboxId}] Killing session ${sessionId}`);
+        const success = this.sessionManager.killSession(sessionId);
+        this.stopOutputPolling(sessionId);
+        this.socket?.emit('session_killed', {
+            genboxId: this.genboxId,
+            sessionId,
+            requestId,
+            success,
+        });
+    }
+    onListSessions(data) {
+        const { requestId } = data;
+        const sessions = this.sessionManager.listAllSessions();
+        this.socket?.emit('sessions_list', {
+            genboxId: this.genboxId,
+            requestId,
+            sessions,
+        });
+    }
+    onGetProviders(data) {
+        const { requestId } = data;
+        const detectedProviders = this.sessionManager.getDetectedProviders();
+        const providers = [];
+        for (const [provider, detection] of detectedProviders) {
+            providers.push({
+                provider,
+                detected: detection.detected,
+                version: detection.version,
+            });
+        }
+        this.socket?.emit('providers_list', {
+            genboxId: this.genboxId,
+            requestId,
+            providers,
+        });
+    }
+    onError(data) {
+        console.error(`[${this.genboxId}] Error from server:`, data);
+    }
+    /**
+     * Handle known sessions from the API (sessions created via hooks, not daemon)
+     * These need session ID -> dtach socket mappings to poll output
+     *
+     * IMPORTANT: When Claude starts in a daemon-created dtach session, Claude uses
+     * its own internal session ID. The API updates the session ID and sends us
+     * the new mapping. We need to:
+     * 1. Stop polling for the old session ID (if any)
+     * 2. Update our mapping
+     * 3. Start polling with the new session ID
+     *
+     * Note: API may still send 'tmuxSession' field for backwards compatibility,
+     * but we treat it as a dtach socket path.
+     */
+    onKnownSessions(data) {
+        if (!data.sessions || !Array.isArray(data.sessions))
+            return;
+        for (const session of data.sessions) {
+            // Support both old 'tmuxSession' and new 'dtachSocket' field names
+            const socketPath = session.dtachSocket || session.tmuxSession;
+            if (session.sessionId && socketPath) {
+                // Check if we already have a mapping for this socket with a different session ID
+                // This happens when daemon creates session, then Claude starts with its own session ID
+                let oldSessionId;
+                for (const [existingSessionId, mapping] of this.knownSessions.entries()) {
+                    if (mapping.dtachSocket === socketPath && existingSessionId !== session.sessionId) {
+                        oldSessionId = existingSessionId;
+                        break;
+                    }
+                }
+                // Also check outputPollers for sessions that poll this socket
+                // The daemon-created sessions use sessionId that matches socket name suffix
+                const socketSuffix = socketPath.replace(/.*\/(claude-|gemini-|codex-)/, '').replace('.sock', '');
+                if (this.outputPollers.has(socketSuffix) && socketSuffix !== session.sessionId) {
+                    console.log(`[${this.genboxId}] Session ID changed: ${socketSuffix} -> ${session.sessionId} (socket: ${socketPath})`);
+                    this.stopOutputPolling(socketSuffix);
+                }
+                if (oldSessionId) {
+                    console.log(`[${this.genboxId}] Session ID changed: ${oldSessionId} -> ${session.sessionId} (socket: ${socketPath})`);
+                    this.stopOutputPolling(oldSessionId);
+                    this.knownSessions.delete(oldSessionId);
+                }
+                // Store the new mapping
+                console.log(`[${this.genboxId}] Storing session mapping: ${session.sessionId} -> ${socketPath}`);
+                this.knownSessions.set(session.sessionId, {
+                    dtachSocket: socketPath,
+                    projectPath: session.projectPath,
+                });
+                // Start output polling for this session
+                // Note: JSONL message sync is handled by ContinuousJsonlSync (not per-session watchers)
+                if (session.status !== 'ended') {
+                    this.startOutputPollingForKnownSession(session.sessionId, socketPath);
+                }
+            }
+        }
+        if (data.sessions.length > 0) {
+            console.log(`[${this.genboxId}] Received ${data.sessions.length} known sessions from API`);
+        }
+    }
+    startOutputPolling(sessionId) {
+        if (this.outputPollers.has(sessionId))
+            return;
+        let lastOutput = '';
+        const poller = setInterval(() => {
+            if (!this.running) {
+                this.stopOutputPolling(sessionId);
+                return;
+            }
+            const output = this.sessionManager.getOutput(sessionId, 100);
+            const status = this.sessionManager.getSessionStatus(sessionId);
+            // Only send if output changed
+            if (output && output !== lastOutput) {
+                lastOutput = output;
+                this.socket?.emit('output_update', {
+                    genboxId: this.genboxId,
+                    sessionId,
+                    output,
+                    status,
+                });
+            }
+            // Stop polling if session ended
+            if (status === 'ended') {
+                this.stopOutputPolling(sessionId);
+            }
+        }, OUTPUT_POLL_INTERVAL);
+        this.outputPollers.set(sessionId, poller);
+    }
+    /**
+     * Start output polling for a known session (from API, not discovered by daemon)
+     * Uses the dtach socket path directly for session monitoring
+     */
+    startOutputPollingForKnownSession(sessionId, socketPath) {
+        if (this.outputPollers.has(sessionId))
+            return;
+        console.log(`[${this.genboxId}] Starting output polling for session ${sessionId}, socket=${socketPath}`);
+        let lastOutput = '';
+        const poller = setInterval(() => {
+            if (!this.running) {
+                this.stopOutputPolling(sessionId);
+                return;
+            }
+            // Check if dtach socket is alive
+            if (!this.isDtachSocketAlive(socketPath)) {
+                // Session doesn't exist, emit ended status and stop polling
+                console.log(`[${this.genboxId}] Dtach socket ${socketPath} not alive, emitting ended status for ${sessionId}`);
+                this.socket?.emit('output_update', {
+                    genboxId: this.genboxId,
+                    sessionId,
+                    output: lastOutput, // Keep last known output
+                    status: 'ended',
+                });
+                this.stopOutputPolling(sessionId);
+                return;
+            }
+            // Read output from the log file
+            const output = this.readDtachOutput(socketPath, 100);
+            if (output === null) {
+                return;
+            }
+            // Only send if output changed
+            if (output && output !== lastOutput) {
+                lastOutput = output;
+                // Analyze status from output
+                const status = this.analyzeClaudeOutput(output);
+                console.log(`[${this.genboxId}] Emitting output_update for ${sessionId}, status=${status}, outputLen=${output.length}`);
+                this.socket?.emit('output_update', {
+                    genboxId: this.genboxId,
+                    sessionId,
+                    output,
+                    status,
+                });
+            }
+        }, OUTPUT_POLL_INTERVAL);
+        this.outputPollers.set(sessionId, poller);
+    }
+    /**
+     * Analyze Claude output to determine session status
+     */
+    analyzeClaudeOutput(output) {
+        const lowerOutput = output.toLowerCase();
+        const lines = output.split('\n');
+        const nonEmptyLines = lines.filter(l => l.trim());
+        const lastFewLines = nonEmptyLines.slice(-5);
+        // Check for prompt indicators
+        for (const line of lastFewLines) {
+            if (line.trim().startsWith('>') || line.includes('> Try')) {
+                return 'waiting_input';
+            }
+            if (line.includes('? for shortcuts')) {
+                return 'waiting_input';
+            }
+        }
+        if (lowerOutput.includes('welcome back') || lowerOutput.includes('claude code v')) {
+            return 'waiting_input';
+        }
+        if (lowerOutput.includes('thinking') || lowerOutput.includes('analyzing')) {
+            return 'active';
+        }
+        return 'idle';
+    }
+    stopOutputPolling(sessionId) {
+        const poller = this.outputPollers.get(sessionId);
+        if (poller) {
+            clearInterval(poller);
+            this.outputPollers.delete(sessionId);
+        }
+    }
+    /**
+     * Set storage manager for message sync
+     * Note: JSONL message sync is now handled by ContinuousJsonlSync, not per-session watchers
+     */
+    setStorageManager(storageManager) {
+        this.storageManager = storageManager;
+        console.log(`[${this.genboxId}] Storage manager initialized for session file watching`);
+    }
+    captureAndSendOutput(sessionId) {
+        let output = null;
+        let status = 'idle';
+        const knownSession = this.findKnownSession(sessionId);
+        if (knownSession?.dtachSocket) {
+            // Read from dtach session's log file
+            const capturedOutput = this.readDtachOutput(knownSession.dtachSocket, 100);
+            if (capturedOutput !== null) {
+                output = capturedOutput;
+                status = this.analyzeClaudeOutput(capturedOutput);
+            }
+        }
+        else {
+            output = this.sessionManager.getOutput(sessionId, 100);
+            status = this.sessionManager.getSessionStatus(sessionId);
+        }
+        if (output && this.socket?.connected) {
+            this.socket.emit('output_update', {
+                genboxId: this.genboxId,
+                sessionId,
+                output,
+                status,
+            });
+        }
+    }
+    async run() {
+        console.log(`Starting Unified Genbox Agent Daemon for ${this.genboxId}`);
+        const connected = await this.connect();
+        if (!connected) {
+            console.log('Initial connection failed, will keep retrying...');
+        }
+        // Keep running
+        await new Promise((resolve) => {
+            const shutdown = () => {
+                console.log('Shutting down...');
+                this.running = false;
+                // Stop stats polling
+                this.stopStatsPolling();
+                // Stop all output pollers
+                for (const sessionId of this.outputPollers.keys()) {
+                    this.stopOutputPolling(sessionId);
+                }
+                // Note: JSONL sync is handled by ContinuousJsonlSync which is stopped separately
+                this.socket?.disconnect();
+                resolve();
+            };
+            process.on('SIGTERM', shutdown);
+            process.on('SIGINT', shutdown);
+        });
+    }
+}
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const result = {
+        local: false,
+        native: false,
+        server: false,
+        noSync: false,
+    };
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--local' || arg === '-l') {
+            result.local = true;
+        }
+        else if (arg === '--native') {
+            result.native = true;
+        }
+        else if (arg === '--server' || arg === '-s') {
+            result.server = true;
+        }
+        else if (arg === '--port' && args[i + 1]) {
+            result.port = parseInt(args[++i], 10);
+        }
+        else if (arg === '--control-token' && args[i + 1]) {
+            result.controlToken = args[++i];
+        }
+        else if (arg === '--no-sync') {
+            result.noSync = true;
+        }
+        else if (arg === '--session-id' && args[i + 1]) {
+            result.sessionId = args[++i];
+        }
+        else if (arg === '--session-name' && args[i + 1]) {
+            result.sessionName = args[++i];
+        }
+        else if (arg === '--dashboard-url' && args[i + 1]) {
+            result.dashboardUrl = args[++i];
+        }
+        else if (arg === '--user-id' && args[i + 1]) {
+            result.userId = args[++i];
+        }
+        else if ((arg === '--dtach-socket' || arg === '--tmux-session') && args[i + 1]) {
+            // Support both --dtach-socket and legacy --tmux-session for backwards compatibility
+            result.dtachSocket = args[++i];
+        }
+        else if (arg === 'start') {
+            // Ignore 'start' command
+        }
+    }
+    return result;
+}
+// Main entry point
+async function main() {
+    const cliArgs = parseArgs();
+    // Import server components
+    const { AgentServer } = await Promise.resolve().then(() => __importStar(require('./server')));
+    const { generateControlToken } = await Promise.resolve().then(() => __importStar(require('./server/auth')));
+    const { getStorageManager, closeStorageManager } = await Promise.resolve().then(() => __importStar(require('./storage/manager')));
+    const { BackgroundSync } = await Promise.resolve().then(() => __importStar(require('./sync/background-sync')));
+    const { ContinuousJsonlSync } = await Promise.resolve().then(() => __importStar(require('./sync/continuous-jsonl-sync')));
+    const { StateWatchdog } = await Promise.resolve().then(() => __importStar(require('./state-watchdog')));
+    const { isDaemonRunning, BASE_PORT } = await Promise.resolve().then(() => __importStar(require('./server/port-finder')));
+    const os = await Promise.resolve().then(() => __importStar(require('os')));
+    const path = await Promise.resolve().then(() => __importStar(require('path')));
+    // Local/Native mode: run with local server, optionally sync to cloud
+    if (cliArgs.local || cliArgs.native) {
+        // Import killExistingDaemons
+        const { killExistingDaemons } = await Promise.resolve().then(() => __importStar(require('./server/port-finder')));
+        // CRITICAL: Kill any existing daemon processes to ensure single instance
+        // This is more aggressive than just checking - it ensures clean startup
+        const killed = killExistingDaemons();
+        if (killed > 0) {
+            console.log(`[native] Killed ${killed} existing daemon process(es)`);
+            // Wait a moment for ports to be released
+            await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+        // Double-check if daemon is still running (in case kill failed)
+        const existingDaemon = isDaemonRunning();
+        if (existingDaemon.running) {
+            console.log(`[native] Daemon still running on port ${BASE_PORT}` +
+                (existingDaemon.pid ? ` (PID: ${existingDaemon.pid})` : '') +
+                ` - detected via ${existingDaemon.source || 'unknown'}`);
+            console.log('[native] Could not kill existing daemon. Exiting.');
+            console.log('[native] Manual cleanup: kill ' + (existingDaemon.pid || '<PID>') +
+                ` && rm -f ~/.genbox/locks/port-${BASE_PORT}.lock`);
+            process.exit(1);
+        }
+        console.log('Starting Genbox Agent in local/native mode...');
+        const genboxId = cliArgs.sessionId || process.env.GENBOX_ID || `native-${Date.now()}`;
+        const controlToken = cliArgs.controlToken || process.env.CONTROL_TOKEN || generateControlToken();
+        // Create session manager for the server handlers
+        const registry = providers_1.ProviderRegistry.getInstance();
+        const sessionManager = new providers_1.UnifiedSessionManager(genboxId);
+        // Ensure Claude hooks are configured globally
+        const claudeProvider = registry.getProvider('claude', genboxId);
+        if (claudeProvider && 'ensureGlobalHooks' in claudeProvider) {
+            claudeProvider.ensureGlobalHooks();
+        }
+        // Initialize OpenCode provider and recover any persisted sessions
+        const opencodeProvider = registry.getProvider('opencode', genboxId);
+        if (opencodeProvider && 'loadPersistedSessions' in opencodeProvider) {
+            console.log('[native] Recovering OpenCode sessions...');
+            opencodeProvider.loadPersistedSessions();
+        }
+        // Initialize storage manager (before handlers so we can use it)
+        const storageManager = getStorageManager();
+        console.log('[native] Storage initialized');
+        // Create server handlers
+        const handlers = {
+            listSessions: () => sessionManager.listAllSessions(),
+            getSession: (sessionId) => {
+                const sessions = sessionManager.listAllSessions();
+                return sessions.find(s => s.sessionId === sessionId) || null;
+            },
+            getSessionOutput: (sessionId, lines) => sessionManager.getOutput(sessionId, lines || 100),
+            getSessionStatus: (sessionId) => sessionManager.getSessionStatus(sessionId),
+            sendPrompt: (sessionId, prompt) => {
+                // Update session state to 'thinking' BEFORE sending prompt
+                // This ensures the dtach session is in processing state when Claude hook fires
+                storageManager.sessions.updateState(sessionId, 'thinking');
+                return sessionManager.sendPrompt(sessionId, prompt);
+            },
+            sendKeystroke: (sessionId, key) => sessionManager.sendKeystroke(sessionId, key),
+            createSession: (projectPath, provider, model) => sessionManager.createSession(projectPath, provider, model),
+            resumeSession: (sessionId, projectPath, provider, model) => sessionManager.resumeSession(sessionId, projectPath, provider, model),
+            killSession: (sessionId) => sessionManager.killSession(sessionId),
+            getSystemStats: () => collectSystemStats(),
+            getAvailableModels: () => sessionManager.getAvailableModels(),
+        };
+        // Start server
+        const server = new AgentServer({
+            port: cliArgs.port,
+            genboxId,
+            controlToken,
+            enableCors: true,
+        }, handlers);
+        // Set storage manager on server for event recording
+        server.setStorageManager(storageManager);
+        // Start continuous JSONL sync (replaces old event-driven JSONLWatcher)
+        const claudeProjectsDir = path.join(os.homedir(), '.claude', 'projects');
+        const continuousSync = new ContinuousJsonlSync(storageManager, {
+            syncInterval: 5000, // Sync every 5 seconds
+            claudeProjectsDir,
+            enabled: true,
+        });
+        continuousSync.setBroadcastCallback((event) => server.broadcastEvent(event));
+        continuousSync.start();
+        console.log('[native] Continuous JSONL sync started (5s interval)');
+        // Start state watchdog to recover stuck sessions (60s threshold)
+        const stateWatchdog = new StateWatchdog(storageManager, {
+            checkIntervalMs: 15000, // Check every 15 seconds
+            stuckThresholdMs: 60000, // 60 seconds = stuck
+        });
+        stateWatchdog.setBroadcastCallback((event) => server.broadcastEvent(event));
+        stateWatchdog.start();
+        console.log('[native] State watchdog started (60s threshold)');
+        const port = await server.start();
+        console.log(`[native] Server running on http://localhost:${port}`);
+        console.log(`[native] Control token: ${controlToken}`);
+        console.log(`[native] Genbox ID: ${genboxId}`);
+        // Optionally sync to cloud if not disabled
+        let backgroundSync = null;
+        if (!cliArgs.noSync && MONITORING_WS_URL && MONITORING_WS_URL !== 'http://localhost:3001') {
+            console.log(`[native] Cloud sync enabled to ${MONITORING_WS_URL}`);
+            backgroundSync = new BackgroundSync(storageManager, {
+                apiUrl: MONITORING_WS_URL,
+                genboxId,
+                genboxToken: controlToken,
+                enabled: true,
+                syncInterval: 30000, // 30 seconds
+            });
+            backgroundSync.start();
+        }
+        else {
+            console.log('[native] Cloud sync disabled (--no-sync or no MONITORING_WS_URL)');
+        }
+        // Keep running until shutdown
+        await new Promise((resolve) => {
+            const shutdown = async () => {
+                console.log('[native] Shutting down...');
+                if (backgroundSync) {
+                    backgroundSync.stop();
+                }
+                stateWatchdog.stop();
+                continuousSync.stop();
+                await server.stop();
+                closeStorageManager();
+                resolve();
+            };
+            process.on('SIGTERM', shutdown);
+            process.on('SIGINT', shutdown);
+        });
+        return;
+    }
+    // Cloud mode: require GENBOX_ID and GENBOX_TOKEN
+    if (!GENBOX_ID) {
+        console.error('Error: GENBOX_ID environment variable not set');
+        console.error('For local mode, use: genbox-agent --native');
+        console.error('For local mode with server, use: genbox-agent --native --server');
+        process.exit(1);
+    }
+    if (!GENBOX_TOKEN) {
+        console.error('Error: GENBOX_TOKEN environment variable not set');
+        console.error('For local mode, use: genbox-agent --native');
+        process.exit(1);
+    }
+    // Cloud mode with optional local server
+    const daemon = new UnifiedGenboxDaemon(GENBOX_ID, GENBOX_TOKEN, MONITORING_WS_URL);
+    // Initialize OpenCode provider for cloud mode (recover persisted sessions)
+    const cloudRegistry = providers_1.ProviderRegistry.getInstance();
+    const cloudOpencodeProvider = cloudRegistry.getProvider('opencode', GENBOX_ID);
+    if (cloudOpencodeProvider && 'loadPersistedSessions' in cloudOpencodeProvider) {
+        console.log('[cloud] Recovering OpenCode sessions...');
+        cloudOpencodeProvider.loadPersistedSessions();
+    }
+    // Start local server if --server flag is set
+    if (cliArgs.server) {
+        const controlToken = cliArgs.controlToken || process.env.CONTROL_TOKEN || generateControlToken();
+        // Initialize storage manager (before handlers so we can use it)
+        const storageManager = getStorageManager();
+        console.log('[cloud] Storage initialized');
+        const handlers = {
+            listSessions: () => daemon['sessionManager'].listAllSessions(),
+            getSession: (sessionId) => {
+                const sessions = daemon['sessionManager'].listAllSessions();
+                return sessions.find(s => s.sessionId === sessionId) || null;
+            },
+            getSessionOutput: (sessionId, lines) => daemon['sessionManager'].getOutput(sessionId, lines || 100),
+            getSessionStatus: (sessionId) => daemon['sessionManager'].getSessionStatus(sessionId),
+            sendPrompt: (sessionId, prompt) => {
+                // Update session state to 'thinking' BEFORE sending prompt
+                storageManager.sessions.updateState(sessionId, 'thinking');
+                return daemon['sessionManager'].sendPrompt(sessionId, prompt);
+            },
+            sendKeystroke: (sessionId, key) => daemon['sessionManager'].sendKeystroke(sessionId, key),
+            createSession: (projectPath, provider, model) => daemon['sessionManager'].createSession(projectPath, provider, model),
+            killSession: (sessionId) => daemon['sessionManager'].killSession(sessionId),
+            getSystemStats: () => collectSystemStats(),
+            getAvailableModels: () => daemon['sessionManager'].getAvailableModels(),
+        };
+        const server = new AgentServer({
+            port: cliArgs.port,
+            genboxId: GENBOX_ID,
+            controlToken,
+            enableCors: true,
+        }, handlers);
+        // Set storage manager on server for event recording
+        server.setStorageManager(storageManager);
+        // Set storage manager on daemon for session file watching
+        daemon.setStorageManager(storageManager);
+        // Start continuous JSONL sync (replaces old event-driven JSONLWatcher)
+        const claudeProjectsDirCloud = path.join(os.homedir(), '.claude', 'projects');
+        const continuousSyncCloud = new ContinuousJsonlSync(storageManager, {
+            syncInterval: 5000, // Sync every 5 seconds
+            claudeProjectsDir: claudeProjectsDirCloud,
+            enabled: true,
+        });
+        continuousSyncCloud.setBroadcastCallback((event) => server.broadcastEvent(event));
+        continuousSyncCloud.start();
+        console.log('[cloud] Continuous JSONL sync started (5s interval)');
+        // Start state watchdog to recover stuck sessions (60s threshold)
+        const stateWatchdogCloud = new StateWatchdog(storageManager, {
+            checkIntervalMs: 15000, // Check every 15 seconds
+            stuckThresholdMs: 60000, // 60 seconds = stuck
+        });
+        stateWatchdogCloud.setBroadcastCallback((event) => server.broadcastEvent(event));
+        stateWatchdogCloud.start();
+        console.log('[cloud] State watchdog started (60s threshold)');
+        const port = await server.start();
+        console.log(`[cloud] Local server running on http://localhost:${port}`);
+        console.log(`[cloud] Control token: ${controlToken}`);
+        // Start background sync (cloud mode always syncs)
+        const backgroundSync = new BackgroundSync(storageManager, {
+            apiUrl: MONITORING_WS_URL,
+            genboxId: GENBOX_ID,
+            genboxToken: GENBOX_TOKEN,
+            enabled: true,
+            syncInterval: 30000, // 30 seconds
+        });
+        backgroundSync.start();
+        // Add shutdown handler for server
+        const originalShutdown = process.listeners('SIGTERM')[0];
+        process.removeAllListeners('SIGTERM');
+        process.removeAllListeners('SIGINT');
+        const shutdown = async () => {
+            console.log('[cloud] Shutting down server...');
+            backgroundSync.stop();
+            stateWatchdogCloud.stop();
+            continuousSyncCloud.stop();
+            await server.stop();
+            closeStorageManager();
+            if (originalShutdown)
+                originalShutdown();
+        };
+        process.on('SIGTERM', shutdown);
+        process.on('SIGINT', shutdown);
+    }
+    await daemon.run();
+}
+main().catch((error) => {
+    console.error('Fatal error:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=genbox-agent.js.map