@ekkos/cli 0.3.3 → 1.0.1

package/dist/agent/health-check.js

@@ -0,0 +1,243 @@
+"use strict";
+/**
+ * Health check for ekkOS agent daemon
+ *
+ * Verifies:
+ * - Service is installed and loaded
+ * - Process is running
+ * - Recent activity in logs
+ * - Network connectivity to relay server
+ */
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkDaemonHealth = checkDaemonHealth;
+exports.formatHealthStatus = formatHealthStatus;
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const ws_1 = __importDefault(require("ws"));
+const RELAY_URL = process.env.RELAY_WS_URL || 'wss://ekkos-relay-production.up.railway.app';
+/**
+ * Check agent daemon health
+ */
+async function checkDaemonHealth() {
+    const status = {
+        ok: true,
+        service: {
+            installed: false,
+            loaded: false,
+            running: false,
+        },
+        logs: {
+            recentErrors: [],
+        },
+        relay: {
+            reachable: false,
+        },
+    };
+    // Check if service is installed
+    const plistPath = path.join(os.homedir(), 'Library', 'LaunchAgents', 'dev.ekkos.agent.plist');
+    status.service.installed = fs.existsSync(plistPath);
+    // Check if service is loaded
+    try {
+        const output = (0, child_process_1.execSync)('launchctl list | grep dev.ekkos.agent', { encoding: 'utf-8' }).trim();
+        status.service.loaded = !!output;
+        // Extract PID if running
+        const pidMatch = output.match(/^(\d+)\s+/);
+        if (pidMatch) {
+            status.service.pid = parseInt(pidMatch[1], 10);
+            status.service.running = status.service.pid > 0;
+        }
+    }
+    catch {
+        // Service not loaded
+        status.service.loaded = false;
+        status.service.running = false;
+    }
+    // Check logs
+    const logDir = path.join(os.homedir(), '.ekkos');
+    const errLogPath = path.join(logDir, 'agent.err.log');
+    const outLogPath = path.join(logDir, 'agent.out.log');
+    if (fs.existsSync(errLogPath)) {
+        try {
+            const errLog = fs.readFileSync(errLogPath, 'utf-8');
+            if (errLog) {
+                status.logs.lastActivity = new Date(fs.statSync(errLogPath).mtime);
+                status.logs.recentErrors = extractRecentErrors(errLog, 10);
+            }
+        }
+        catch {
+            // Ignore log read errors
+        }
+    }
+    if (fs.existsSync(outLogPath)) {
+        try {
+            const stat = fs.statSync(outLogPath);
+            const mtime = new Date(stat.mtime);
+            if (!status.logs.lastActivity || mtime > status.logs.lastActivity) {
+                status.logs.lastActivity = mtime;
+            }
+        }
+        catch {
+            // Ignore
+        }
+    }
+    // Check relay connectivity
+    try {
+        status.relay.reachable = await checkRelayConnectivity();
+    }
+    catch (err) {
+        status.relay.reachable = false;
+        status.relay.lastError = err.message;
+    }
+    // Overall health
+    status.ok = status.service.running && status.relay.reachable && status.logs.recentErrors.length === 0;
+    return status;
+}
+/**
+ * Check if relay server is reachable
+ */
+async function checkRelayConnectivity() {
+    return new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+            ws.terminate();
+            resolve(false);
+        }, 5000);
+        const ws = new ws_1.default(`${RELAY_URL}/health`);
+        ws.on('open', () => {
+            clearTimeout(timeout);
+            ws.close();
+            resolve(true);
+        });
+        ws.on('error', () => {
+            clearTimeout(timeout);
+            resolve(false);
+        });
+        ws.on('close', () => {
+            clearTimeout(timeout);
+            resolve(false);
+        });
+    });
+}
+/**
+ * Extract recent error lines from log
+ */
+function extractRecentErrors(log, count) {
+    return log
+        .split('\n')
+        .filter((line) => {
+        const lower = line.toLowerCase();
+        return lower.includes('error') || lower.includes('failed') || lower.includes('exception');
+    })
+        .slice(-count);
+}
+/**
+ * Format health status for console output
+ */
+function formatHealthStatus(status) {
+    const lines = [];
+    lines.push('ekkOS Agent Daemon Health Check');
+    lines.push('================================\n');
+    // Service status
+    lines.push(`Service Installation: ${status.service.installed ? '✓' : '✗'} ${status.service.installed ? 'Installed' : 'Not installed'}`);
+    lines.push(`Service Loaded: ${status.service.loaded ? '✓' : '✗'} ${status.service.loaded ? 'Loaded' : 'Not loaded'}`);
+    if (status.service.running) {
+        lines.push(`Service Running: ✓ Running (PID ${status.service.pid})`);
+    }
+    else {
+        lines.push('Service Running: ✗ Not running');
+    }
+    lines.push('');
+    // Logs status
+    if (status.logs.lastActivity) {
+        const now = new Date();
+        const age = now.getTime() - status.logs.lastActivity.getTime();
+        const ageStr = formatAge(age);
+        lines.push(`Last Activity: ${ageStr} ago (${status.logs.lastActivity.toISOString()})`);
+    }
+    else {
+        lines.push('Last Activity: No logs found');
+    }
+    if (status.logs.recentErrors.length > 0) {
+        lines.push(`Recent Errors (${status.logs.recentErrors.length}):`);
+        for (const err of status.logs.recentErrors) {
+            lines.push(`  - ${err.substring(0, 100)}`);
+        }
+    }
+    lines.push('');
+    // Relay status
+    lines.push(`Relay Server: ${status.relay.reachable ? '✓' : '✗'} ${status.relay.reachable ? 'Reachable' : 'Unreachable'}`);
+    if (status.relay.lastError) {
+        lines.push(`  Error: ${status.relay.lastError}`);
+    }
+    lines.push('');
+    // Overall status
+    if (status.ok) {
+        lines.push('Overall: ✓ Healthy - All systems operational');
+    }
+    else {
+        lines.push('Overall: ✗ Unhealthy - Issues detected');
+        if (!status.service.running) {
+            lines.push('  → Service is not running. Run: launchctl start dev.ekkos.agent');
+        }
+        if (!status.relay.reachable) {
+            lines.push('  → Cannot reach relay server. Check network connectivity.');
+        }
+        if (status.logs.recentErrors.length > 0) {
+            lines.push('  → Recent errors found in logs. Check ~/.ekkos/agent.err.log');
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Format age duration
+ */
+function formatAge(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    const days = Math.floor(hours / 24);
+    if (days > 0)
+        return `${days}d ${hours % 24}h`;
+    if (hours > 0)
+        return `${hours}h ${minutes % 60}m`;
+    if (minutes > 0)
+        return `${minutes}m ${seconds % 60}s`;
+    return `${seconds}s`;
+}

package/dist/agent/pty-runner.d.ts

@@ -12,6 +12,7 @@ interface PTYRunnerConfig {
     cols?: number;
     rows?: number;
     cwd?: string;
+    env?: NodeJS.ProcessEnv;
     verbose?: boolean;
 }
 export declare class PTYRunner {

package/dist/agent/pty-runner.js

@@ -85,6 +85,7 @@ class PTYRunner {
             cwd: this.config.cwd || process.cwd(),
             env: {
                 ...process.env,
+                ...(this.config.env || {}),
                 TERM: 'xterm-256color',
                 COLORTERM: 'truecolor',
             },
@@ -107,7 +108,10 @@ class PTYRunner {
             this.spawnProcess = (0, child_process_1.spawn)('cmd.exe', ['/c', this.config.command, ...this.config.args], {
                 stdio: ['pipe', 'pipe', 'pipe'],
                 cwd,
-                env: process.env,
+                env: {
+                    ...process.env,
+                    ...(this.config.env || {}),
+                },
             });
         }
         else {
@@ -120,6 +124,7 @@ class PTYRunner {
                 cwd,
                 env: {
                     ...process.env,
+                    ...(this.config.env || {}),
                     TERM: 'xterm-256color',
                 },
             });

package/dist/capture/transcript-repair.d.ts

@@ -24,6 +24,7 @@ export interface RepairResult {
 export declare function countOrphansInJsonl(jsonlPath: string): {
     orphans: number;
     orphanIds: string[];
+    lineCount: number;
 };
 /**
  * Main entry point: repair or rollback a transcript with orphan tool_results.

package/dist/capture/transcript-repair.js

@@ -98,7 +98,7 @@ function countOrphansInJsonl(jsonlPath) {
             }
         }
     }
-    return { orphans: orphanIds.length, orphanIds };
+    return { orphans: orphanIds.length, orphanIds, lineCount: lines.length };
 }
 /**
  * Find plausible backups for a jsonl file.
@@ -258,6 +258,17 @@ function repairOrRollbackTranscript(jsonlPath) {
                 orphans: v.orphans,
             });
             if (v.orphans === 0) {
+                // SAFETY CHECK: Prevent session amnesia (rollback > 20 lines)
+                const lostLines = (initial.lineCount || 0) - (v.lineCount || 0);
+                if (lostLines > 20) {
+                    debugLog('REPAIR_BACKUP_SKIPPED', 'Backup too old - skipping to prevent data loss', {
+                        backup,
+                        currentLines: initial.lineCount,
+                        backupLines: v.lineCount,
+                        lostLines
+                    });
+                    continue;
+                }
                 atomicReplace(jsonlPath, backup);
                 debugLog('REPAIR_ROLLBACK_SUCCESS', 'Rolled back to valid backup', { backup });
                 return { action: 'rollback', orphansFound: initial.orphans, backupUsed: backup };

package/dist/commands/agent.d.ts

@@ -42,3 +42,9 @@ export declare function agentUninstall(options?: AgentOptions): Promise<void>;
 export declare function agentLogs(options?: {
     follow?: boolean;
 }): Promise<void>;
+/**
+ * Check agent daemon health and diagnose connection issues
+ */
+export declare function agentHealth(options?: {
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/agent.js

@@ -54,6 +54,7 @@ exports.agentRestart = agentRestart;
 exports.agentStatus = agentStatus;
 exports.agentUninstall = agentUninstall;
 exports.agentLogs = agentLogs;
+exports.agentHealth = agentHealth;
 const chalk_1 = __importDefault(require("chalk"));
 const os = __importStar(require("os"));
 const fs = __importStar(require("fs"));
@@ -298,3 +299,246 @@ async function agentLogs(options = {}) {
         console.log(lines.join('\n'));
     }
 }
+/**
+ * Check agent daemon health and diagnose connection issues
+ */
+async function agentHealth(options = {}) {
+    const platform = os.platform();
+    const deviceFilePath = path.join(state_1.EKKOS_DIR, 'device.json');
+    const logPath = path.join(state_1.EKKOS_DIR, 'agent.out.log');
+    const pidFilePath = path.join(state_1.EKKOS_DIR, 'agent.pid');
+    const health = {
+        timestamp: new Date().toISOString(),
+        status: 'unknown',
+        checks: {
+            configured: false,
+            paired: false,
+            serviceRunning: false,
+            processRunning: false,
+            logsWriting: false,
+            cloudConnected: false,
+            networkHealthy: false,
+        },
+        issues: [],
+        suggestions: [],
+    };
+    // Check 1: Device configured
+    if (fs.existsSync(deviceFilePath)) {
+        const deviceData = JSON.parse(fs.readFileSync(deviceFilePath, 'utf-8'));
+        health.checks.configured = true;
+        health.device = {
+            name: deviceData.deviceName,
+            id: deviceData.deviceId.slice(0, 8) + '...',
+            platform: deviceData.platform,
+            arch: deviceData.arch,
+        };
+        // Check 2: Device paired
+        if (deviceData.deviceToken) {
+            health.checks.paired = true;
+            health.pairedAt = deviceData.pairedAt;
+        }
+        else {
+            health.checks.paired = false;
+            health.issues.push('Device not paired');
+            health.suggestions.push('Run `ekkos setup-remote` to pair device');
+        }
+        // Check 3: Service running
+        try {
+            if (platform === 'darwin') {
+                const output = (0, child_process_1.execSync)('launchctl list | grep dev.ekkos.agent || true', { encoding: 'utf-8' });
+                health.checks.serviceRunning = output.includes('dev.ekkos.agent');
+            }
+            else if (platform === 'win32') {
+                const output = (0, child_process_1.execSync)('schtasks /query /tn "ekkOS Agent" 2>nul || true', { encoding: 'utf-8' });
+                health.checks.serviceRunning = output.includes('Running');
+            }
+            else if (platform === 'linux') {
+                const output = (0, child_process_1.execSync)('systemctl --user is-active ekkos-agent 2>/dev/null || true', { encoding: 'utf-8' });
+                health.checks.serviceRunning = output.trim() === 'active';
+            }
+        }
+        catch {
+            health.checks.serviceRunning = false;
+        }
+        if (!health.checks.serviceRunning) {
+            health.issues.push('Service not running');
+            health.suggestions.push('Run `ekkos agent start` to start the service');
+        }
+        // Check 4: Process running
+        if (fs.existsSync(pidFilePath)) {
+            const pid = parseInt(fs.readFileSync(pidFilePath, 'utf-8').trim());
+            try {
+                // Check if process exists
+                (0, child_process_1.execSync)(`kill -0 ${pid} 2>/dev/null`, { stdio: 'pipe' });
+                health.checks.processRunning = true;
+            }
+            catch {
+                health.checks.processRunning = false;
+                health.issues.push(`Agent process (PID ${pid}) not running`);
+                health.suggestions.push('Run `ekkos agent restart` to restart');
+            }
+        }
+        else {
+            health.checks.processRunning = false;
+            health.issues.push('No PID file found');
+        }
+        // Check 5: Logs writing
+        if (fs.existsSync(logPath)) {
+            const stats = fs.statSync(logPath);
+            const lastModified = Date.now() - stats.mtime.getTime();
+            const fifteenMinutes = 15 * 60 * 1000;
+            health.checks.logsWriting = lastModified < fifteenMinutes;
+            health.lastLogWrite = {
+                timestamp: stats.mtime.toISOString(),
+                minutesAgo: Math.round(lastModified / 1000 / 60),
+            };
+            if (!health.checks.logsWriting) {
+                health.issues.push(`No logs written for ${Math.round(lastModified / 1000 / 60)} minutes`);
+                health.suggestions.push('Check if daemon crashed - run `ekkos agent logs -f` to monitor');
+            }
+            // Parse recent errors from logs
+            const content = fs.readFileSync(logPath, 'utf-8');
+            const lines = content.split('\n').slice(-100);
+            const errors = lines.filter(l => l.includes('ERROR') || l.includes('error') || l.includes('Connection failed'));
+            if (errors.length > 0) {
+                health.recentErrors = errors.slice(-5);
+            }
+        }
+        else {
+            health.checks.logsWriting = false;
+            health.issues.push('Log file not found');
+        }
+        // Check 6: Cloud connectivity
+        if (health.checks.paired) {
+            try {
+                const authToken = (0, state_1.getAuthToken)();
+                const state = (0, state_1.getState)();
+                if (authToken && state?.userId) {
+                    const MEMORY_API_URL = process.env.MEMORY_API_URL || 'https://api.ekkos.dev';
+                    const controller = new AbortController();
+                    const timeout = setTimeout(() => controller.abort(), 5000);
+                    try {
+                        const response = await fetch(`${MEMORY_API_URL}/api/v1/relay/devices/${state.userId}`, {
+                            headers: { 'Authorization': `Bearer ${authToken}` },
+                            signal: controller.signal,
+                        });
+                        clearTimeout(timeout);
+                        if (response.ok) {
+                            const data = await response.json();
+                            const device = data.devices?.find((d) => d.deviceId === deviceData.deviceId);
+                            health.checks.cloudConnected = device?.online === true;
+                            if (!health.checks.cloudConnected) {
+                                health.issues.push('Device shows offline in cloud');
+                                health.suggestions.push('Check network connection and agent logs');
+                            }
+                        }
+                        else {
+                            health.checks.cloudConnected = false;
+                            health.issues.push(`Cloud API returned ${response.status}`);
+                        }
+                    }
+                    catch (err) {
+                        clearTimeout(timeout);
+                        health.checks.cloudConnected = false;
+                        if (err.name === 'AbortError') {
+                            health.issues.push('Cloud connection timeout (>5s)');
+                        }
+                        else {
+                            health.issues.push(`Cloud connection error: ${err.message}`);
+                        }
+                        health.suggestions.push('Check internet connection');
+                    }
+                }
+                else {
+                    health.issues.push('Not logged in to ekkOS');
+                    health.suggestions.push('Run `ekkos init` to set up authentication');
+                }
+            }
+            catch {
+                health.checks.cloudConnected = false;
+                health.issues.push('Unable to check cloud connectivity');
+            }
+        }
+        // Check 7: Network health
+        if (health.checks.logsWriting && health.checks.cloudConnected) {
+            health.checks.networkHealthy = true;
+        }
+    }
+    else {
+        health.checks.configured = false;
+        health.issues.push('Device not configured');
+        health.suggestions.push('Run `ekkos setup-remote` to configure device');
+    }
+    // Determine overall status
+    if (health.issues.length === 0) {
+        health.status = 'healthy';
+    }
+    else if (health.checks.serviceRunning &&
+        health.checks.processRunning &&
+        health.checks.logsWriting) {
+        health.status = 'degraded';
+    }
+    else {
+        health.status = 'unhealthy';
+    }
+    if (options.json) {
+        console.log(JSON.stringify(health, null, 2));
+    }
+    else {
+        // Pretty print
+        console.log('');
+        console.log(chalk_1.default.cyan.bold('  ekkOS Agent Health Check'));
+        console.log('');
+        const statusColor = health.status === 'healthy' ? chalk_1.default.green :
+            health.status === 'degraded' ? chalk_1.default.yellow :
+                chalk_1.default.red;
+        console.log(`  Status: ${statusColor.bold(health.status.toUpperCase())}`);
+        console.log('');
+        // Device info
+        if (health.device) {
+            console.log(chalk_1.default.gray('  Device:'));
+            console.log(`    ${chalk_1.default.gray('Name:')} ${health.device.name}`);
+            console.log(`    ${chalk_1.default.gray('ID:')} ${health.device.id}`);
+            console.log(`    ${chalk_1.default.gray('Platform:')} ${health.device.platform}/${health.device.arch}`);
+            console.log('');
+        }
+        // Checks
+        console.log(chalk_1.default.gray('  Checks:'));
+        for (const [key, value] of Object.entries(health.checks)) {
+            const icon = value ? chalk_1.default.green('✓') : chalk_1.default.red('✗');
+            const label = key.replace(/([A-Z])/g, ' $1').trim();
+            console.log(`    ${icon} ${label}`);
+        }
+        console.log('');
+        // Issues
+        if (health.issues.length > 0) {
+            console.log(chalk_1.default.yellow('  Issues:'));
+            for (const issue of health.issues) {
+                console.log(`    ${chalk_1.default.yellow('⚠')} ${issue}`);
+            }
+            console.log('');
+        }
+        // Suggestions
+        if (health.suggestions.length > 0) {
+            console.log(chalk_1.default.cyan('  Suggestions:'));
+            for (const suggestion of health.suggestions) {
+                console.log(`    ${chalk_1.default.cyan('→')} ${suggestion}`);
+            }
+            console.log('');
+        }
+        // Recent errors
+        if (health.recentErrors && health.recentErrors.length > 0) {
+            console.log(chalk_1.default.red('  Recent Errors:'));
+            for (const err of health.recentErrors.slice(0, 3)) {
+                const preview = err.substring(0, 100) + (err.length > 100 ? '...' : '');
+                console.log(`    ${chalk_1.default.red('!')} ${preview}`);
+            }
+            console.log('');
+        }
+        // Logs info
+        if (health.lastLogWrite) {
+            console.log(chalk_1.default.gray(`  Last activity: ${health.lastLogWrite.minutesAgo} minutes ago`));
+            console.log('');
+        }
+    }
+}

package/dist/commands/dashboard.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ekkos dashboard [session-name]
+ *
+ * Live TUI dashboard for monitoring Claude Code session usage in real-time.
+ * Uses blessed-contrib for rich terminal widgets (gauges, charts, tables).
+ *
+ * Usage:
+ *   ekkos dashboard <session-name>   Watch specific session
+ *   ekkos dashboard --latest         Auto-detect latest active session
+ *   ekkos dashboard --wait-for-new   Wait for a brand-new session to appear
+ *   ekkos dashboard                  Interactive session picker
+ *
+ * Text Selection:
+ *   To select text separately from Claude Code, run the dashboard in a different
+ *   terminal window/pane. This prevents the blessed screen from interfering with
+ *   Claude Code's text selection. Use iTerm2 split panes or tmux windows.
+ *
+ * Scrolling:
+ *   Up/Down arrows or j/k    Scroll one line
+ *   PageUp/PageDown or u/d   Scroll one page
+ *   Home/End or g/G          Jump to top/bottom
+ *   Mouse wheel              Scroll with mouse
+ */
+import { Command } from 'commander';
+export declare const dashboardCommand: Command;