@ekkos/cli 0.2.18 → 1.0.0

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/eviction-client.d.ts

@@ -0,0 +1,139 @@
+/**
+ * EVICTION CLIENT
+ * ================
+ *
+ * Client module for the Handshake Eviction Protocol.
+ * Provides functions to call ekkOS_EvictPrepare and ekkOS_EvictConfirm
+ * ensuring zero data loss during context eviction.
+ *
+ * Protocol:
+ * 1. prepareEviction() - Write to R2, get ACK
+ * 2. (caller deletes locally)
+ * 3. confirmEviction() - Mark as committed
+ *
+ * Features:
+ * - Retry with exponential backoff
+ * - Timeout handling
+ * - Fallback detection
+ * - Idempotency via clientNonce
+ */
+/**
+ * Queue a failed eviction for retry when R2 reconnects
+ */
+export declare function queueEvictionForRetry(messages: Message[], indices: number[], estimatedTokens: number, reason: 'threshold' | 'emergency' | 'manual', options: HandshakeEvictionOptions): void;
+/**
+ * Drain the retry queue — called after a successful handshake
+ * Non-blocking: runs in background, doesn't delay current eviction
+ */
+export declare function drainRetryQueue(apiUrl: string, authToken: string): Promise<{
+    drained: number;
+    failed: number;
+    remaining: number;
+}>;
+/**
+ * Get retry queue stats (for monitoring)
+ */
+export declare function getRetryQueueStats(): {
+    size: number;
+    oldestAge: number | null;
+};
+interface ContentBlock {
+    type: 'text' | 'image' | 'tool_use' | 'tool_result' | 'thinking';
+    text?: string;
+    id?: string;
+    name?: string;
+    input?: Record<string, unknown>;
+    tool_use_id?: string;
+    content?: string | ContentBlock[];
+    thinking?: string;
+}
+export interface Message {
+    role: 'user' | 'assistant';
+    content: string | ContentBlock[];
+}
+interface EvictionManifest {
+    evictionId: string;
+    messageIndices: number[];
+    fingerprints: string[];
+    estimatedTokens: number;
+    evictionReason: 'threshold' | 'emergency' | 'manual';
+}
+interface PrepareResult {
+    success: boolean;
+    evictionId: string;
+    r2Key?: string;
+    bytesWritten?: number;
+    checksum?: string;
+    status?: 'prepared' | 'already_exists';
+    error?: string;
+    clientNonce: string;
+}
+interface ConfirmResult {
+    success: boolean;
+    status?: 'committed' | 'already_committed' | 'not_found';
+    error?: string;
+}
+/**
+ * Create deterministic eviction ID from messages
+ * Same messages = same evictionId (enables dedup)
+ */
+export declare function createEvictionId(messages: Message[]): string;
+/**
+ * Create fingerprint for a message
+ */
+export declare function createFingerprint(msg: Message): string;
+/**
+ * Check if the eviction API is available
+ * Returns true if proxy is reachable and healthy
+ */
+export declare function checkEvictionHealth(apiUrl: string, authToken: string): Promise<boolean>;
+/**
+ * Prepare eviction by writing to R2 via the proxy.
+ * Returns ACK with evictionId if successful.
+ * Caller must NOT delete locally until this succeeds.
+ */
+export declare function prepareEviction(apiUrl: string, authToken: string, sessionId: string, sessionName: string, userId: string, tenantId: string, messages: Message[], manifest: EvictionManifest, projectPath?: string): Promise<PrepareResult>;
+/**
+ * Confirm eviction after local deletion.
+ * This is optional but recommended for audit completeness.
+ * Failure here is non-critical - data is already safe in R2.
+ */
+export declare function confirmEviction(apiUrl: string, authToken: string, evictionId: string, clientNonce: string, localDeletedCount: number): Promise<ConfirmResult>;
+export interface HandshakeEvictionOptions {
+    apiUrl: string;
+    authToken: string;
+    sessionId: string;
+    sessionName: string;
+    userId: string;
+    tenantId: string;
+    projectPath?: string;
+}
+export interface HandshakeEvictionResult {
+    success: boolean;
+    evictionId: string;
+    r2Key?: string;
+    bytesWritten?: number;
+    status: 'prepared' | 'committed' | 'failed' | 'skipped';
+    error?: string;
+    clientNonce?: string;
+}
+/**
+ * Full handshake eviction - call this instead of fire-and-forget
+ *
+ * Returns:
+ * - success=true, status='prepared' → Safe to delete locally, then call confirmEviction
+ * - success=false → DO NOT delete locally
+ */
+export declare function handshakeEviction(messages: Message[], indices: number[], estimatedTokens: number, reason: 'threshold' | 'emergency' | 'manual', options: HandshakeEvictionOptions): Promise<HandshakeEvictionResult>;
+declare const _default: {
+    prepareEviction: typeof prepareEviction;
+    confirmEviction: typeof confirmEviction;
+    handshakeEviction: typeof handshakeEviction;
+    checkEvictionHealth: typeof checkEvictionHealth;
+    createEvictionId: typeof createEvictionId;
+    createFingerprint: typeof createFingerprint;
+    queueEvictionForRetry: typeof queueEvictionForRetry;
+    drainRetryQueue: typeof drainRetryQueue;
+    getRetryQueueStats: typeof getRetryQueueStats;
+};
+export default _default;