@ekkos/cli 1.3.2 → 1.3.5

package/dist/synk/daemon/control-client.js

@@ -1,101 +0,0 @@
-"use strict";
-/**
- * HTTP client for communicating with a running synk daemon
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.notifyDaemonSessionStarted = notifyDaemonSessionStarted;
-exports.listDaemonSessions = listDaemonSessions;
-exports.stopDaemonSession = stopDaemonSession;
-exports.spawnDaemonSession = spawnDaemonSession;
-exports.stopDaemonHttp = stopDaemonHttp;
-exports.checkIfDaemonRunning = checkIfDaemonRunning;
-exports.stopDaemon = stopDaemon;
-const persistence_1 = require("../persistence");
-async function daemonPost(path, body) {
-    const state = await (0, persistence_1.readDaemonState)();
-    if (!state?.httpPort) {
-        return { error: 'No daemon running, no state file found' };
-    }
-    try {
-        process.kill(state.pid, 0);
-    }
-    catch {
-        return { error: 'Daemon is not running, state file is stale' };
-    }
-    try {
-        const timeout = process.env.SYNK_DAEMON_HTTP_TIMEOUT
-            ? parseInt(process.env.SYNK_DAEMON_HTTP_TIMEOUT)
-            : 10000;
-        const response = await fetch(`http://127.0.0.1:${state.httpPort}${path}`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify(body || {}),
-            signal: AbortSignal.timeout(timeout),
-        });
-        if (!response.ok) {
-            return { error: `Request failed: ${path}, HTTP ${response.status}` };
-        }
-        return await response.json();
-    }
-    catch (error) {
-        return { error: `Request failed: ${path}, ${error instanceof Error ? error.message : 'Unknown error'}` };
-    }
-}
-async function notifyDaemonSessionStarted(sessionId, metadata) {
-    return await daemonPost('/session-started', { sessionId, metadata });
-}
-async function listDaemonSessions() {
-    const result = await daemonPost('/list');
-    return result.children || [];
-}
-async function stopDaemonSession(sessionId) {
-    const result = await daemonPost('/stop-session', { sessionId });
-    return result.success || false;
-}
-async function spawnDaemonSession(directory, sessionId) {
-    return await daemonPost('/spawn-session', { directory, sessionId });
-}
-async function stopDaemonHttp() {
-    await daemonPost('/stop');
-}
-async function checkIfDaemonRunning() {
-    const state = await (0, persistence_1.readDaemonState)();
-    if (!state)
-        return false;
-    try {
-        process.kill(state.pid, 0);
-        return true;
-    }
-    catch {
-        await (0, persistence_1.clearDaemonState)();
-        return false;
-    }
-}
-async function stopDaemon() {
-    try {
-        const state = await (0, persistence_1.readDaemonState)();
-        if (!state)
-            return;
-        // Try HTTP graceful stop
-        try {
-            await stopDaemonHttp();
-            const start = Date.now();
-            while (Date.now() - start < 2000) {
-                try {
-                    process.kill(state.pid, 0);
-                    await new Promise(resolve => setTimeout(resolve, 100));
-                }
-                catch {
-                    return; // Process is dead
-                }
-            }
-        }
-        catch { }
-        // Force kill
-        try {
-            process.kill(state.pid, 'SIGKILL');
-        }
-        catch { }
-    }
-    catch { }
-}

package/dist/synk/daemon/control-server.d.ts

@@ -1,24 +0,0 @@
-/**
- * Local HTTP control server for synk daemon
- * Listens on 127.0.0.1 only — provides endpoints for session management and shutdown
- */
-import type { Metadata } from '../types';
-export interface TrackedSession {
-    pid: number;
-    startedBy: string;
-    synkSessionId?: string;
-    startedAt: number;
-}
-export declare function startDaemonControlServer(opts: {
-    getChildren: () => TrackedSession[];
-    stopSession: (sessionId: string) => boolean;
-    spawnSession: (options: {
-        directory: string;
-        sessionId?: string;
-    }) => Promise<any>;
-    requestShutdown: () => void;
-    onSessionWebhook: (sessionId: string, metadata: Metadata) => void;
-}): Promise<{
-    port: number;
-    stop: () => Promise<void>;
-}>;

package/dist/synk/daemon/control-server.js

@@ -1,91 +0,0 @@
-"use strict";
-/**
- * Local HTTP control server for synk daemon
- * Listens on 127.0.0.1 only — provides endpoints for session management and shutdown
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startDaemonControlServer = startDaemonControlServer;
-const node_http_1 = __importDefault(require("node:http"));
-function startDaemonControlServer(opts) {
-    return new Promise((resolve, reject) => {
-        const server = node_http_1.default.createServer(async (req, res) => {
-            if (req.method !== 'POST') {
-                res.writeHead(405, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ error: 'Method not allowed' }));
-                return;
-            }
-            let body = '';
-            req.on('data', (chunk) => { body += chunk; });
-            req.on('end', async () => {
-                let parsed = {};
-                try {
-                    parsed = body ? JSON.parse(body) : {};
-                }
-                catch { }
-                try {
-                    switch (req.url) {
-                        case '/session-started': {
-                            const { sessionId, metadata } = parsed;
-                            if (sessionId)
-                                opts.onSessionWebhook(sessionId, metadata);
-                            res.writeHead(200, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ status: 'ok' }));
-                            break;
-                        }
-                        case '/list': {
-                            const children = opts.getChildren()
-                                .filter(c => c.synkSessionId)
-                                .map(c => ({ startedBy: c.startedBy, synkSessionId: c.synkSessionId, pid: c.pid }));
-                            res.writeHead(200, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ children }));
-                            break;
-                        }
-                        case '/stop-session': {
-                            const success = opts.stopSession(parsed.sessionId || '');
-                            res.writeHead(200, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ success }));
-                            break;
-                        }
-                        case '/spawn-session': {
-                            const result = await opts.spawnSession({
-                                directory: parsed.directory || '.',
-                                sessionId: parsed.sessionId,
-                            });
-                            res.writeHead(200, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify(result));
-                            break;
-                        }
-                        case '/stop': {
-                            res.writeHead(200, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ status: 'stopping' }));
-                            setTimeout(() => opts.requestShutdown(), 50);
-                            break;
-                        }
-                        default: {
-                            res.writeHead(404, { 'Content-Type': 'application/json' });
-                            res.end(JSON.stringify({ error: 'Not found' }));
-                        }
-                    }
-                }
-                catch (error) {
-                    if (!res.headersSent) {
-                        res.writeHead(500, { 'Content-Type': 'application/json' });
-                    }
-                    res.end(JSON.stringify({ error: error instanceof Error ? error.message : 'Internal error' }));
-                }
-            });
-        });
-        server.listen(0, '127.0.0.1', () => {
-            const addr = server.address();
-            const port = typeof addr === 'object' && addr ? addr.port : 0;
-            resolve({
-                port,
-                stop: () => new Promise((res) => server.close(() => res())),
-            });
-        });
-        server.on('error', reject);
-    });
-}

package/dist/synk/daemon/run.d.ts

@@ -1,14 +0,0 @@
-/**
- * Synk daemon — background process for session management and remote control
- *
- * Lifecycle:
- * 1. Acquire lock file (prevent multiple daemons)
- * 2. Authenticate with synk-server
- * 3. Start local HTTP control server
- * 4. Register machine via REST API
- * 5. Connect MachineClient WebSocket
- * 6. Heartbeat loop
- * 7. Await shutdown signal
- * 8. Cleanup
- */
-export declare function startDaemon(): Promise<void>;

package/dist/synk/daemon/run.js

@@ -1,338 +0,0 @@
-"use strict";
-/**
- * Synk daemon — background process for session management and remote control
- *
- * Lifecycle:
- * 1. Acquire lock file (prevent multiple daemons)
- * 2. Authenticate with synk-server
- * 3. Start local HTTP control server
- * 4. Register machine via REST API
- * 5. Connect MachineClient WebSocket
- * 6. Heartbeat loop
- * 7. Await shutdown signal
- * 8. Cleanup
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.startDaemon = startDaemon;
-const node_os_1 = require("node:os");
-const node_path_1 = require("node:path");
-const node_fs_1 = require("node:fs");
-const node_child_process_1 = require("node:child_process");
-const node_crypto_1 = require("node:crypto");
-const config_1 = require("../config");
-const persistence_1 = require("../persistence");
-const api_1 = require("../api");
-const machine_client_1 = require("../machine-client");
-const control_server_1 = require("./control-server");
-const control_client_1 = require("./control-client");
-const proxy_url_1 = require("../../utils/proxy-url");
-const state_1 = require("../../utils/state");
-const HEARTBEAT_INTERVAL = parseInt(process.env.SYNK_DAEMON_HEARTBEAT_INTERVAL || '60000');
-let logStream = null;
-function getCliVersion() {
-    try {
-        const pkgPath = (0, node_path_1.resolve)(__dirname, '../../../package.json');
-        const pkg = JSON.parse((0, node_fs_1.readFileSync)(pkgPath, 'utf-8'));
-        return pkg.version || '0.0.0';
-    }
-    catch {
-        return '0.0.0';
-    }
-}
-function daemonLog(message, ...args) {
-    const line = `[${new Date().toISOString()}] ${message} ${args.map(a => typeof a === 'string' ? a : JSON.stringify(a)).join(' ')}`;
-    if (logStream)
-        logStream.write(line + '\n');
-    if (!config_1.synkConfig.isDaemonProcess)
-        console.log(line);
-}
-async function startDaemon() {
-    config_1.synkConfig.ensureDirectories();
-    const cliVersion = getCliVersion();
-    // Setup log file
-    const logPath = (0, node_path_1.join)(config_1.synkConfig.logsDir, `${new Date().toISOString().replace(/[:.]/g, '-')}-daemon.log`);
-    if (!(0, node_fs_1.existsSync)(config_1.synkConfig.logsDir))
-        (0, node_fs_1.mkdirSync)(config_1.synkConfig.logsDir, { recursive: true });
-    logStream = (0, node_fs_1.createWriteStream)(logPath, { flags: 'a' });
-    daemonLog(`Starting synk daemon v${cliVersion}`);
-    // Check if daemon already running
-    const existingState = await (0, persistence_1.readDaemonState)();
-    if (existingState) {
-        try {
-            process.kill(existingState.pid, 0);
-            daemonLog('Daemon already running, stopping old instance');
-            await (0, control_client_1.stopDaemon)();
-        }
-        catch {
-            daemonLog('Stale daemon state, cleaning up');
-            await (0, persistence_1.clearDaemonState)();
-        }
-    }
-    // Acquire lock
-    const lockHandle = await (0, persistence_1.acquireDaemonLock)();
-    if (!lockHandle) {
-        daemonLog('Failed to acquire daemon lock — another daemon may be running');
-        process.exit(1);
-    }
-    // Authenticate
-    const credentials = await (0, persistence_1.readCredentials)();
-    if (!credentials) {
-        daemonLog('No credentials found. Run "ekkos synk auth" first.');
-        await (0, persistence_1.releaseDaemonLock)(lockHandle);
-        process.exit(1);
-    }
-    // Get or create machine ID
-    const settings = await (0, persistence_1.readSettings)();
-    let machineId = settings.machineId;
-    if (!machineId) {
-        machineId = (0, node_crypto_1.randomUUID)();
-        await (0, persistence_1.updateSettings)(s => ({ ...s, machineId }));
-        daemonLog('Generated new machine ID:', machineId);
-    }
-    // Session tracking — keyed by sessionId (not PID) to avoid overwrite bugs
-    const trackedSessions = new Map();
-    let sessionCounter = 0;
-    // Shutdown handling
-    let shutdownRequested = false;
-    let resolveShutdown;
-    const shutdownPromise = new Promise(resolve => { resolveShutdown = resolve; });
-    const requestShutdown = () => {
-        if (shutdownRequested)
-            return;
-        shutdownRequested = true;
-        daemonLog('Shutdown requested');
-        resolveShutdown();
-    };
-    process.on('SIGINT', requestShutdown);
-    process.on('SIGTERM', requestShutdown);
-    process.on('uncaughtException', (error) => {
-        daemonLog('Uncaught exception:', error);
-        requestShutdown();
-    });
-    // --- Spawn session implementation ---
-    const spawnSession = async (options) => {
-        const { directory } = options;
-        daemonLog('Spawning session in:', directory);
-        if (!(0, node_fs_1.existsSync)(directory)) {
-            return { type: 'error', errorMessage: `Directory does not exist: ${directory}` };
-        }
-        // Generate session identity
-        const sessionId = options.sessionId || (0, node_crypto_1.randomUUID)();
-        const sessionName = (0, state_1.uuidToWords)(sessionId);
-        // Build proxy env vars (unless disabled)
-        const proxyEnv = {};
-        if (process.env.SYNK_DISABLE_PROXY !== '1') {
-            const ekkosConfig = (0, state_1.getConfig)();
-            let userId = ekkosConfig?.userId || 'anonymous';
-            if (userId === 'anonymous') {
-                const authToken = (0, state_1.getAuthToken)();
-                if (authToken?.startsWith('ekk_')) {
-                    const parts = authToken.split('_');
-                    if (parts.length >= 2)
-                        userId = parts[1];
-                }
-            }
-            proxyEnv.ANTHROPIC_BASE_URL = (0, proxy_url_1.buildProxyUrl)(userId, sessionName, directory, sessionId);
-            proxyEnv.EKKOS_PROXY_MODE = '1';
-            proxyEnv.EKKOS_ULTRA_MINIMAL = '1';
-        }
-        // Merge env vars: process.env + options.environmentVariables + proxy (highest priority)
-        const childEnv = {
-            ...process.env,
-            ...(options.environmentVariables || {}),
-            ...proxyEnv,
-        };
-        try {
-            // Create log file for spawned session
-            const sessionLogPath = (0, node_path_1.join)(config_1.synkConfig.logsDir, `${new Date().toISOString().replace(/[:.]/g, '-')}-session-${sessionName}.log`);
-            const sessionLogFd = (0, node_fs_1.createWriteStream)(sessionLogPath, { flags: 'a' });
-            const child = (0, node_child_process_1.spawn)('ekkos', ['run', '--started-by', 'daemon'], {
-                cwd: directory,
-                env: childEnv,
-                detached: true,
-                stdio: ['ignore', sessionLogFd, sessionLogFd],
-            });
-            child.unref();
-            const trackKey = `spawn-${++sessionCounter}`;
-            const tracked = {
-                pid: child.pid || 0,
-                startedBy: 'daemon',
-                startedAt: Date.now(),
-            };
-            trackedSessions.set(trackKey, tracked);
-            // Wait for session to report itself via webhook (max 15s)
-            const webhookSessionId = await new Promise((resolve) => {
-                const timeout = setTimeout(() => resolve(null), 15000);
-                const checkInterval = setInterval(() => {
-                    if (tracked.synkSessionId) {
-                        clearInterval(checkInterval);
-                        clearTimeout(timeout);
-                        resolve(tracked.synkSessionId);
-                    }
-                }, 200);
-            });
-            if (webhookSessionId) {
-                // Re-key tracked session by its actual session ID
-                trackedSessions.delete(trackKey);
-                trackedSessions.set(webhookSessionId, tracked);
-                daemonLog('Session spawned and registered:', webhookSessionId);
-                return { type: 'success', sessionId: webhookSessionId };
-            }
-            else {
-                daemonLog('Session spawned but webhook timeout — PID:', child.pid);
-                return { type: 'success', sessionId: `pending-${child.pid}` };
-            }
-        }
-        catch (error) {
-            daemonLog('Failed to spawn session:', error);
-            return { type: 'error', errorMessage: error instanceof Error ? error.message : 'Failed to spawn session' };
-        }
-    };
-    // Start HTTP control server
-    const controlServer = await (0, control_server_1.startDaemonControlServer)({
-        getChildren: () => Array.from(trackedSessions.values()),
-        stopSession: (sessionId) => {
-            for (const [key, session] of trackedSessions) {
-                if (session.synkSessionId === sessionId || key === sessionId) {
-                    try {
-                        process.kill(session.pid, 'SIGTERM');
-                    }
-                    catch { }
-                    return true;
-                }
-            }
-            return false;
-        },
-        spawnSession: async (options) => {
-            const result = await spawnSession(options);
-            if (result.type === 'success')
-                return { success: true, sessionId: result.sessionId };
-            return { success: false, error: result.errorMessage };
-        },
-        requestShutdown,
-        onSessionWebhook: (sessionId, metadata) => {
-            daemonLog('Session webhook:', sessionId);
-            // Find tracked session by PID from metadata
-            const hostPid = metadata?.hostPid;
-            let matched = false;
-            if (hostPid) {
-                for (const [, session] of trackedSessions) {
-                    if (session.pid === hostPid && !session.synkSessionId) {
-                        session.synkSessionId = sessionId;
-                        matched = true;
-                        break;
-                    }
-                }
-            }
-            if (!matched) {
-                // Terminal-spawned session reporting itself
-                trackedSessions.set(sessionId, {
-                    pid: hostPid || process.pid,
-                    startedBy: 'terminal',
-                    synkSessionId: sessionId,
-                    startedAt: Date.now(),
-                });
-            }
-        },
-    });
-    // Write daemon state
-    (0, persistence_1.writeDaemonState)({
-        pid: process.pid,
-        httpPort: controlServer.port,
-        startTime: new Date().toLocaleString(),
-        startedWithCliVersion: cliVersion,
-        daemonLogPath: logPath,
-    });
-    daemonLog(`Control server on port ${controlServer.port}`);
-    // Register machine with synk-server via REST
-    const machineMetadata = {
-        host: (0, node_os_1.hostname)(),
-        platform: (0, node_os_1.platform)(),
-        synkCliVersion: cliVersion,
-        homeDir: (0, node_os_1.homedir)(),
-        synkHomeDir: config_1.synkConfig.synkHomeDir,
-    };
-    const initialDaemonState = {
-        status: 'starting',
-        pid: process.pid,
-        httpPort: controlServer.port,
-        startedAt: Date.now(),
-    };
-    const apiClient = await api_1.ApiClient.create(credentials);
-    const machine = await apiClient.getOrCreateMachine({
-        machineId,
-        metadata: machineMetadata,
-        daemonState: initialDaemonState,
-    });
-    daemonLog('Machine registered:', machine.id);
-    // Connect WebSocket via MachineClient
-    const machineClient = new machine_client_1.MachineClient(credentials.token, machine, daemonLog);
-    machineClient.setRPCHandlers({
-        spawnSession,
-        stopSession: (sessionId) => {
-            for (const [key, session] of trackedSessions) {
-                if (session.synkSessionId === sessionId || key === sessionId) {
-                    try {
-                        process.kill(session.pid, 'SIGTERM');
-                    }
-                    catch { }
-                    return true;
-                }
-            }
-            return false;
-        },
-        requestShutdown,
-    });
-    machineClient.connect();
-    // Heartbeat loop
-    const heartbeatInterval = setInterval(async () => {
-        if (shutdownRequested)
-            return;
-        // Update last heartbeat
-        try {
-            const state = await (0, persistence_1.readDaemonState)();
-            if (state) {
-                (0, persistence_1.writeDaemonState)({ ...state, lastHeartbeat: new Date().toLocaleString() });
-            }
-        }
-        catch { }
-        // Prune dead sessions
-        for (const [key, session] of trackedSessions) {
-            if (session.pid === 0 || session.pid === process.pid)
-                continue;
-            try {
-                process.kill(session.pid, 0);
-            }
-            catch {
-                daemonLog('Pruning dead session:', session.synkSessionId || key);
-                trackedSessions.delete(key);
-            }
-        }
-    }, HEARTBEAT_INTERVAL);
-    daemonLog('Daemon ready. Waiting for shutdown signal...');
-    // Wait for shutdown
-    await shutdownPromise;
-    daemonLog('Shutting down...');
-    // Cleanup
-    clearInterval(heartbeatInterval);
-    // Update daemon state on server via MachineClient
-    try {
-        await machineClient.updateDaemonState(() => ({
-            status: 'shutting-down',
-            shutdownRequestedAt: Date.now(),
-        }));
-    }
-    catch { }
-    // Close WebSocket
-    machineClient.shutdown();
-    // Stop control server
-    await controlServer.stop();
-    // Clear daemon state file
-    await (0, persistence_1.clearDaemonState)();
-    // Release lock
-    await (0, persistence_1.releaseDaemonLock)(lockHandle);
-    if (logStream)
-        logStream.end();
-    daemonLog('Daemon stopped cleanly');
-    process.exit(0);
-}

package/dist/synk/encryption.d.ts

@@ -1,17 +0,0 @@
-export declare function encodeBase64(buffer: Uint8Array, variant?: 'base64' | 'base64url'): string;
-export declare function encodeBase64Url(buffer: Uint8Array): string;
-export declare function decodeBase64(base64: string, variant?: 'base64' | 'base64url'): Uint8Array;
-export declare function getRandomBytes(size: number): Uint8Array;
-export declare function libsodiumPublicKeyFromSecretKey(seed: Uint8Array): Uint8Array;
-export declare function libsodiumEncryptForPublicKey(data: Uint8Array, recipientPublicKey: Uint8Array): Uint8Array;
-export declare function encryptLegacy(data: any, secret: Uint8Array): Uint8Array;
-export declare function decryptLegacy(data: Uint8Array, secret: Uint8Array): any | null;
-export declare function encryptWithDataKey(data: any, dataKey: Uint8Array): Uint8Array;
-export declare function decryptWithDataKey(bundle: Uint8Array, dataKey: Uint8Array): any | null;
-export declare function encrypt(key: Uint8Array, variant: 'legacy' | 'dataKey', data: any): Uint8Array;
-export declare function decrypt(key: Uint8Array, variant: 'legacy' | 'dataKey', data: Uint8Array): any | null;
-export declare function authChallenge(secret: Uint8Array): {
-    challenge: Uint8Array;
-    publicKey: Uint8Array;
-    signature: Uint8Array;
-};