@ekkos/cli 0.2.10 → 0.2.11

package/dist/agent/daemon.d.ts

@@ -0,0 +1,86 @@
+/**
+ * ekkOS Agent Daemon
+ *
+ * Background daemon that:
+ * 1. Maintains WebSocket connection to cloud relay
+ * 2. Receives session start requests
+ * 3. Spawns `ekkos run -d` in PTY
+ * 4. Relays PTY I/O to cloud
+ */
+interface DaemonConfig {
+    deviceToken: string;
+    deviceId: string;
+    deviceName: string;
+    verbose?: boolean;
+}
+export declare class AgentDaemon {
+    private config;
+    private ws;
+    private reconnectAttempt;
+    private heartbeatTimer;
+    private ptyRunner;
+    private currentSessionId;
+    private running;
+    constructor(config: DaemonConfig);
+    /**
+     * Start the daemon
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the daemon
+     */
+    stop(): Promise<void>;
+    /**
+     * Connect to relay server
+     */
+    private connect;
+    /**
+     * Handle WebSocket open
+     */
+    private handleOpen;
+    /**
+     * Handle incoming message
+     */
+    private handleMessage;
+    /**
+     * Handle session start request
+     */
+    private handleSessionStart;
+    /**
+     * Handle session end request
+     */
+    private handleSessionEnd;
+    /**
+     * Handle input from browser
+     */
+    private handleInput;
+    /**
+     * Handle resize from browser
+     */
+    private handleResize;
+    /**
+     * Handle PTY exit
+     */
+    private handlePTYExit;
+    /**
+     * Send PTY output to server
+     */
+    private sendOutput;
+    /**
+     * Handle WebSocket close
+     */
+    private handleClose;
+    /**
+     * Handle WebSocket error
+     */
+    private handleError;
+    /**
+     * Send message to server
+     */
+    private sendMessage;
+    /**
+     * Log message
+     */
+    private log;
+}
+export {};

package/dist/agent/daemon.js

@@ -0,0 +1,297 @@
+"use strict";
+/**
+ * ekkOS Agent Daemon
+ *
+ * Background daemon that:
+ * 1. Maintains WebSocket connection to cloud relay
+ * 2. Receives session start requests
+ * 3. Spawns `ekkos run -d` in PTY
+ * 4. Relays PTY I/O to cloud
+ */
+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.AgentDaemon = void 0;
+const ws_1 = __importDefault(require("ws"));
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const pty_runner_1 = require("./pty-runner");
+const RELAY_URL = process.env.RELAY_WS_URL || 'wss://mcp.ekkos.dev';
+const HEARTBEAT_INTERVAL = 30000; // 30 seconds
+const RECONNECT_DELAYS = [1000, 2000, 4000, 8000, 16000, 32000, 60000]; // Exponential backoff
+class AgentDaemon {
+    constructor(config) {
+        this.ws = null;
+        this.reconnectAttempt = 0;
+        this.heartbeatTimer = null;
+        this.ptyRunner = null;
+        this.currentSessionId = null;
+        this.running = false;
+        this.config = config;
+    }
+    /**
+     * Start the daemon
+     */
+    async start() {
+        this.running = true;
+        this.log('Starting ekkOS agent daemon...');
+        this.connect();
+    }
+    /**
+     * Stop the daemon
+     */
+    async stop() {
+        this.running = false;
+        // Stop heartbeat
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        // Close PTY
+        if (this.ptyRunner) {
+            this.ptyRunner.kill();
+            this.ptyRunner = null;
+        }
+        // Close WebSocket
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this.log('Daemon stopped');
+    }
+    /**
+     * Connect to relay server
+     */
+    connect() {
+        if (!this.running)
+            return;
+        const url = `${RELAY_URL}/api/v1/relay/device`;
+        this.log(`Connecting to ${url}...`);
+        this.ws = new ws_1.default(url, {
+            headers: {
+                'X-Device-Token': this.config.deviceToken,
+            },
+        });
+        this.ws.on('open', () => this.handleOpen());
+        this.ws.on('message', (data) => this.handleMessage(data));
+        this.ws.on('close', (code, reason) => this.handleClose(code, reason.toString()));
+        this.ws.on('error', (err) => this.handleError(err));
+    }
+    /**
+     * Handle WebSocket open
+     */
+    handleOpen() {
+        this.log('Connected to relay server');
+        this.reconnectAttempt = 0;
+        // Start heartbeat
+        this.heartbeatTimer = setInterval(() => {
+            this.sendMessage({ type: 'heartbeat' });
+        }, HEARTBEAT_INTERVAL);
+    }
+    /**
+     * Handle incoming message
+     */
+    handleMessage(rawData) {
+        let message;
+        try {
+            message = JSON.parse(rawData.toString());
+        }
+        catch (err) {
+            this.log('Invalid message from server:', err);
+            return;
+        }
+        switch (message.type) {
+            case 'connected':
+                this.log('Registered with relay');
+                break;
+            case 'session_start':
+                this.handleSessionStart(message.sessionId);
+                break;
+            case 'session_end':
+                this.handleSessionEnd(message.sessionId);
+                break;
+            case 'input':
+                this.handleInput(message.data || '');
+                break;
+            case 'resize':
+                this.handleResize(message.cols || 80, message.rows || 24);
+                break;
+            case 'error':
+                this.log('Server error:', message.error);
+                break;
+        }
+    }
+    /**
+     * Handle session start request
+     */
+    handleSessionStart(sessionId) {
+        this.log(`Session start request: ${sessionId}`);
+        // Kill existing session if any
+        if (this.ptyRunner) {
+            this.ptyRunner.kill();
+            this.ptyRunner = null;
+        }
+        this.currentSessionId = sessionId;
+        // Start PTY with ekkos run -d
+        this.ptyRunner = new pty_runner_1.PTYRunner({
+            command: 'ekkos',
+            args: ['run', '-d', '-b'], // -d for doctor check, -b for bypass permissions
+            onData: (data) => this.sendOutput(data),
+            onExit: (code) => this.handlePTYExit(code),
+            verbose: this.config.verbose,
+        });
+        this.ptyRunner.start();
+        // Notify server that PTY is ready
+        this.sendMessage({
+            type: 'ready',
+            sessionId,
+        });
+    }
+    /**
+     * Handle session end request
+     */
+    handleSessionEnd(sessionId) {
+        if (sessionId && sessionId !== this.currentSessionId) {
+            return; // Not our session
+        }
+        this.log('Session ended');
+        if (this.ptyRunner) {
+            this.ptyRunner.kill();
+            this.ptyRunner = null;
+        }
+        this.currentSessionId = null;
+    }
+    /**
+     * Handle input from browser
+     */
+    handleInput(data) {
+        if (this.ptyRunner) {
+            this.ptyRunner.write(data);
+        }
+    }
+    /**
+     * Handle resize from browser
+     */
+    handleResize(cols, rows) {
+        if (this.ptyRunner) {
+            this.ptyRunner.resize(cols, rows);
+        }
+    }
+    /**
+     * Handle PTY exit
+     */
+    handlePTYExit(code) {
+        this.log(`PTY exited with code ${code}`);
+        this.sendMessage({
+            type: 'session_end',
+            sessionId: this.currentSessionId || undefined,
+        });
+        this.ptyRunner = null;
+        this.currentSessionId = null;
+    }
+    /**
+     * Send PTY output to server
+     */
+    sendOutput(data) {
+        this.sendMessage({
+            type: 'output',
+            sessionId: this.currentSessionId || undefined,
+            data,
+        });
+    }
+    /**
+     * Handle WebSocket close
+     */
+    handleClose(code, reason) {
+        this.log(`Disconnected: ${code} ${reason}`);
+        // Stop heartbeat
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        // Kill PTY if running
+        if (this.ptyRunner) {
+            this.ptyRunner.kill();
+            this.ptyRunner = null;
+        }
+        this.currentSessionId = null;
+        // Reconnect if still running
+        if (this.running) {
+            const delay = RECONNECT_DELAYS[Math.min(this.reconnectAttempt, RECONNECT_DELAYS.length - 1)];
+            this.reconnectAttempt++;
+            this.log(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempt})...`);
+            setTimeout(() => this.connect(), delay);
+        }
+    }
+    /**
+     * Handle WebSocket error
+     */
+    handleError(err) {
+        this.log('WebSocket error:', err.message);
+    }
+    /**
+     * Send message to server
+     */
+    sendMessage(message) {
+        if (this.ws && this.ws.readyState === ws_1.default.OPEN) {
+            this.ws.send(JSON.stringify(message));
+        }
+    }
+    /**
+     * Log message
+     */
+    log(...args) {
+        const timestamp = new Date().toISOString();
+        const message = `[${timestamp}] ${args.map(String).join(' ')}`;
+        if (this.config.verbose) {
+            console.log(message);
+        }
+        // Also log to file
+        try {
+            const logDir = path.join(os.homedir(), '.ekkos');
+            if (!fs.existsSync(logDir)) {
+                fs.mkdirSync(logDir, { recursive: true });
+            }
+            fs.appendFileSync(path.join(logDir, 'agent.log'), message + '\n');
+        }
+        catch {
+            // Ignore log errors
+        }
+    }
+}
+exports.AgentDaemon = AgentDaemon;

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

@@ -0,0 +1,51 @@
+/**
+ * PTY Runner for ekkOS Agent
+ *
+ * Spawns `ekkos run -d` in a pseudoterminal and handles I/O.
+ * Based on the PTY patterns from packages/ekkos-cli/src/commands/run.ts
+ */
+interface PTYRunnerConfig {
+    command: string;
+    args: string[];
+    onData: (data: string) => void;
+    onExit: (code: number) => void;
+    cols?: number;
+    rows?: number;
+    verbose?: boolean;
+}
+export declare class PTYRunner {
+    private config;
+    private ptyProcess;
+    private spawnProcess;
+    private usePty;
+    constructor(config: PTYRunnerConfig);
+    /**
+     * Start the PTY process
+     */
+    start(): void;
+    /**
+     * Start using node-pty (preferred)
+     */
+    private startWithPty;
+    /**
+     * Start using spawn (fallback for Windows without PTY)
+     */
+    private startWithSpawn;
+    /**
+     * Write data to PTY stdin
+     */
+    write(data: string): void;
+    /**
+     * Resize PTY
+     */
+    resize(cols: number, rows: number): void;
+    /**
+     * Kill the PTY process
+     */
+    kill(): void;
+    /**
+     * Check if PTY is running
+     */
+    isRunning(): boolean;
+}
+export {};

package/dist/agent/pty-runner.js

@@ -0,0 +1,184 @@
+"use strict";
+/**
+ * PTY Runner for ekkOS Agent
+ *
+ * Spawns `ekkos run -d` in a pseudoterminal and handles I/O.
+ * Based on the PTY patterns from packages/ekkos-cli/src/commands/run.ts
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PTYRunner = void 0;
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+// Try to load node-pty
+let pty = null;
+try {
+    pty = require('node-pty');
+}
+catch {
+    // node-pty not available, will use spawn fallback
+}
+class PTYRunner {
+    constructor(config) {
+        this.ptyProcess = null;
+        this.spawnProcess = null;
+        this.config = config;
+        this.usePty = pty !== null;
+    }
+    /**
+     * Start the PTY process
+     */
+    start() {
+        if (this.usePty && pty) {
+            this.startWithPty();
+        }
+        else {
+            this.startWithSpawn();
+        }
+    }
+    /**
+     * Start using node-pty (preferred)
+     */
+    startWithPty() {
+        if (!pty)
+            return;
+        const shell = os.platform() === 'win32' ? 'cmd.exe' : 'bash';
+        const shellArgs = os.platform() === 'win32'
+            ? ['/c', this.config.command, ...this.config.args]
+            : ['-c', `${this.config.command} ${this.config.args.join(' ')}`];
+        this.ptyProcess = pty.spawn(shell, shellArgs, {
+            name: 'xterm-256color',
+            cols: this.config.cols || 80,
+            rows: this.config.rows || 24,
+            cwd: process.cwd(),
+            env: {
+                ...process.env,
+                TERM: 'xterm-256color',
+                COLORTERM: 'truecolor',
+            },
+        });
+        this.ptyProcess.onData((data) => {
+            this.config.onData(data);
+        });
+        this.ptyProcess.onExit(({ exitCode }) => {
+            this.config.onExit(exitCode);
+        });
+    }
+    /**
+     * Start using spawn (fallback for Windows without PTY)
+     */
+    startWithSpawn() {
+        const isWindows = os.platform() === 'win32';
+        if (isWindows) {
+            // Windows: Use cmd.exe
+            this.spawnProcess = (0, child_process_1.spawn)('cmd.exe', ['/c', this.config.command, ...this.config.args], {
+                stdio: ['pipe', 'pipe', 'pipe'],
+                cwd: process.cwd(),
+                env: process.env,
+            });
+        }
+        else {
+            // Unix: Use script for PTY emulation
+            const scriptArgs = os.platform() === 'darwin'
+                ? ['-q', '/dev/null', this.config.command, ...this.config.args]
+                : ['-q', '-c', `${this.config.command} ${this.config.args.join(' ')}`, '/dev/null'];
+            this.spawnProcess = (0, child_process_1.spawn)('script', scriptArgs, {
+                stdio: ['pipe', 'pipe', 'pipe'],
+                cwd: process.cwd(),
+                env: {
+                    ...process.env,
+                    TERM: 'xterm-256color',
+                },
+            });
+        }
+        if (this.spawnProcess.stdout) {
+            this.spawnProcess.stdout.on('data', (data) => {
+                this.config.onData(data.toString());
+            });
+        }
+        if (this.spawnProcess.stderr) {
+            this.spawnProcess.stderr.on('data', (data) => {
+                this.config.onData(data.toString());
+            });
+        }
+        this.spawnProcess.on('exit', (code) => {
+            this.config.onExit(code || 0);
+        });
+        this.spawnProcess.on('error', (err) => {
+            this.config.onData(`Error: ${err.message}\r\n`);
+            this.config.onExit(1);
+        });
+    }
+    /**
+     * Write data to PTY stdin
+     */
+    write(data) {
+        if (this.ptyProcess) {
+            this.ptyProcess.write(data);
+        }
+        else if (this.spawnProcess && this.spawnProcess.stdin) {
+            this.spawnProcess.stdin.write(data);
+        }
+    }
+    /**
+     * Resize PTY
+     */
+    resize(cols, rows) {
+        if (this.ptyProcess && this.ptyProcess.resize) {
+            this.ptyProcess.resize(cols, rows);
+        }
+        // Spawn fallback doesn't support resize
+    }
+    /**
+     * Kill the PTY process
+     */
+    kill() {
+        if (this.ptyProcess) {
+            this.ptyProcess.kill();
+            this.ptyProcess = null;
+        }
+        if (this.spawnProcess) {
+            this.spawnProcess.kill('SIGTERM');
+            this.spawnProcess = null;
+        }
+    }
+    /**
+     * Check if PTY is running
+     */
+    isRunning() {
+        return this.ptyProcess !== null || this.spawnProcess !== null;
+    }
+}
+exports.PTYRunner = PTYRunner;

package/dist/commands/agent.d.ts

@@ -0,0 +1,44 @@
+/**
+ * ekkos agent - Agent management commands for remote terminal
+ *
+ * Subcommands:
+ * - daemon: Run the agent daemon (used by service)
+ * - start: Start the agent service
+ * - stop: Stop the agent service
+ * - restart: Restart the agent service
+ * - status: Check agent status
+ * - uninstall: Remove agent service
+ */
+export interface AgentOptions {
+    verbose?: boolean;
+}
+/**
+ * Run the agent daemon (foreground)
+ */
+export declare function agentDaemon(options?: AgentOptions): Promise<void>;
+/**
+ * Start the agent service
+ */
+export declare function agentStart(options?: AgentOptions): Promise<void>;
+/**
+ * Stop the agent service
+ */
+export declare function agentStop(options?: AgentOptions): Promise<void>;
+/**
+ * Restart the agent service
+ */
+export declare function agentRestart(options?: AgentOptions): Promise<void>;
+/**
+ * Check agent status
+ */
+export declare function agentStatus(options?: AgentOptions): Promise<void>;
+/**
+ * Uninstall the agent service
+ */
+export declare function agentUninstall(options?: AgentOptions): Promise<void>;
+/**
+ * Show agent logs
+ */
+export declare function agentLogs(options?: {
+    follow?: boolean;
+}): Promise<void>;