@ekkos/cli 1.3.1 → 1.3.2

package/dist/synk/api.js

@@ -0,0 +1,133 @@
+"use strict";
+/**
+ * API client for ekkOS_synk server
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const encryption_1 = require("./encryption");
+const config_1 = require("./config");
+class ApiClient {
+    static async create(credential) {
+        return new ApiClient(credential);
+    }
+    constructor(credential) {
+        this.credential = credential;
+    }
+    /** Create a new session or load existing one with the given tag */
+    async getOrCreateSession(opts) {
+        let dataEncryptionKey = null;
+        let encryptionKey;
+        let encryptionVariant;
+        if (this.credential.encryption.type === 'dataKey') {
+            encryptionKey = (0, encryption_1.getRandomBytes)(32);
+            encryptionVariant = 'dataKey';
+            const encryptedDataKey = (0, encryption_1.libsodiumEncryptForPublicKey)(encryptionKey, this.credential.encryption.publicKey);
+            dataEncryptionKey = new Uint8Array(encryptedDataKey.length + 1);
+            dataEncryptionKey.set([0], 0);
+            dataEncryptionKey.set(encryptedDataKey, 1);
+        }
+        else {
+            encryptionKey = this.credential.encryption.secret;
+            encryptionVariant = 'legacy';
+        }
+        try {
+            const response = await axios_1.default.post(`${config_1.synkConfig.serverUrl}/v1/sessions`, {
+                tag: opts.tag,
+                metadata: (0, encryption_1.encodeBase64)((0, encryption_1.encrypt)(encryptionKey, encryptionVariant, opts.metadata)),
+                agentState: opts.state ? (0, encryption_1.encodeBase64)((0, encryption_1.encrypt)(encryptionKey, encryptionVariant, opts.state)) : null,
+                dataEncryptionKey: dataEncryptionKey ? (0, encryption_1.encodeBase64)(dataEncryptionKey) : null,
+            }, {
+                headers: {
+                    'Authorization': `Bearer ${this.credential.token}`,
+                    'Content-Type': 'application/json',
+                },
+                timeout: 60000,
+            });
+            const raw = response.data.session;
+            return {
+                id: raw.id,
+                seq: raw.seq,
+                metadata: (0, encryption_1.decrypt)(encryptionKey, encryptionVariant, (0, encryption_1.decodeBase64)(raw.metadata)),
+                metadataVersion: raw.metadataVersion,
+                agentState: raw.agentState ? (0, encryption_1.decrypt)(encryptionKey, encryptionVariant, (0, encryption_1.decodeBase64)(raw.agentState)) : null,
+                agentStateVersion: raw.agentStateVersion,
+                encryptionKey,
+                encryptionVariant,
+            };
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error)) {
+                const status = error.response?.status;
+                if (status === 404 || (status && status >= 500) || error.code === 'ECONNREFUSED' || error.code === 'ENOTFOUND') {
+                    return null;
+                }
+            }
+            throw new Error(`Failed to create session: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    /** Register or update machine with the server */
+    async getOrCreateMachine(opts) {
+        let dataEncryptionKey = null;
+        let encryptionKey;
+        let encryptionVariant;
+        if (this.credential.encryption.type === 'dataKey') {
+            encryptionVariant = 'dataKey';
+            encryptionKey = this.credential.encryption.machineKey;
+            const encryptedDataKey = (0, encryption_1.libsodiumEncryptForPublicKey)(this.credential.encryption.machineKey, this.credential.encryption.publicKey);
+            dataEncryptionKey = new Uint8Array(encryptedDataKey.length + 1);
+            dataEncryptionKey.set([0], 0);
+            dataEncryptionKey.set(encryptedDataKey, 1);
+        }
+        else {
+            encryptionKey = this.credential.encryption.secret;
+            encryptionVariant = 'legacy';
+        }
+        const createMinimalMachine = () => ({
+            id: opts.machineId,
+            encryptionKey,
+            encryptionVariant,
+            metadata: opts.metadata,
+            metadataVersion: 0,
+            daemonState: opts.daemonState || null,
+            daemonStateVersion: 0,
+        });
+        try {
+            const response = await axios_1.default.post(`${config_1.synkConfig.serverUrl}/v1/machines`, {
+                id: opts.machineId,
+                metadata: (0, encryption_1.encodeBase64)((0, encryption_1.encrypt)(encryptionKey, encryptionVariant, opts.metadata)),
+                daemonState: opts.daemonState ? (0, encryption_1.encodeBase64)((0, encryption_1.encrypt)(encryptionKey, encryptionVariant, opts.daemonState)) : undefined,
+                dataEncryptionKey: dataEncryptionKey ? (0, encryption_1.encodeBase64)(dataEncryptionKey) : undefined,
+            }, {
+                headers: {
+                    'Authorization': `Bearer ${this.credential.token}`,
+                    'Content-Type': 'application/json',
+                },
+                timeout: 60000,
+            });
+            const raw = response.data.machine;
+            return {
+                id: raw.id,
+                encryptionKey,
+                encryptionVariant,
+                metadata: raw.metadata ? (0, encryption_1.decrypt)(encryptionKey, encryptionVariant, (0, encryption_1.decodeBase64)(raw.metadata)) : opts.metadata,
+                metadataVersion: raw.metadataVersion || 0,
+                daemonState: raw.daemonState ? (0, encryption_1.decrypt)(encryptionKey, encryptionVariant, (0, encryption_1.decodeBase64)(raw.daemonState)) : null,
+                daemonStateVersion: raw.daemonStateVersion || 0,
+            };
+        }
+        catch (error) {
+            if (axios_1.default.isAxiosError(error)) {
+                const status = error.response?.status;
+                if (error.code === 'ECONNREFUSED' || error.code === 'ENOTFOUND' || status === 404 || (status && status >= 500)) {
+                    return createMinimalMachine();
+                }
+            }
+            return createMinimalMachine();
+        }
+    }
+}
+exports.ApiClient = ApiClient;

package/dist/synk/auth.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Authentication for ekkOS_synk server
+ */
+/** Authenticate with synk-server and obtain a bearer token */
+export declare function authGetToken(secret: Uint8Array): Promise<string>;
+/** Generate a deep link URL for mobile app pairing */
+export declare function generateAppUrl(secret: Uint8Array): string;

package/dist/synk/auth.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * Authentication for ekkOS_synk server
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authGetToken = authGetToken;
+exports.generateAppUrl = generateAppUrl;
+const axios_1 = __importDefault(require("axios"));
+const encryption_1 = require("./encryption");
+const config_1 = require("./config");
+/** Authenticate with synk-server and obtain a bearer token */
+async function authGetToken(secret) {
+    const { challenge, publicKey, signature } = (0, encryption_1.authChallenge)(secret);
+    const response = await axios_1.default.post(`${config_1.synkConfig.serverUrl}/v1/auth`, {
+        challenge: (0, encryption_1.encodeBase64)(challenge),
+        publicKey: (0, encryption_1.encodeBase64)(publicKey),
+        signature: (0, encryption_1.encodeBase64)(signature),
+    });
+    if (!response.data.success || !response.data.token) {
+        throw new Error('Authentication failed');
+    }
+    return response.data.token;
+}
+/** Generate a deep link URL for mobile app pairing */
+function generateAppUrl(secret) {
+    return `ekkos-synk://${(0, encryption_1.encodeBase64Url)(secret)}`;
+}

package/dist/synk/config.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Configuration for ekkOS_synk — remote session sync
+ */
+declare class SynkConfig {
+    readonly serverUrl: string;
+    readonly synkHomeDir: string;
+    readonly logsDir: string;
+    readonly settingsFile: string;
+    readonly credentialsFile: string;
+    readonly daemonStateFile: string;
+    readonly daemonLockFile: string;
+    readonly isDaemonProcess: boolean;
+    readonly disableCaffeinate: boolean;
+    constructor();
+    ensureDirectories(): void;
+}
+export declare const synkConfig: SynkConfig;
+export {};

package/dist/synk/config.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Configuration for ekkOS_synk — remote session sync
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.synkConfig = void 0;
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+class SynkConfig {
+    constructor() {
+        this.serverUrl = process.env.SYNK_SERVER_URL || 'https://synk.ekkos.dev';
+        const args = process.argv.slice(2);
+        this.isDaemonProcess = args.length >= 3 && args[0] === 'synk' && args[1] === 'daemon' && args[2] === 'start-sync';
+        if (process.env.SYNK_HOME_DIR) {
+            this.synkHomeDir = process.env.SYNK_HOME_DIR.replace(/^~/, (0, node_os_1.homedir)());
+        }
+        else {
+            this.synkHomeDir = (0, node_path_1.join)((0, node_os_1.homedir)(), '.ekkos', 'synk');
+        }
+        this.logsDir = (0, node_path_1.join)(this.synkHomeDir, 'logs');
+        this.settingsFile = (0, node_path_1.join)(this.synkHomeDir, 'settings.json');
+        this.credentialsFile = (0, node_path_1.join)(this.synkHomeDir, 'credentials.json');
+        this.daemonStateFile = (0, node_path_1.join)(this.synkHomeDir, 'daemon.state.json');
+        this.daemonLockFile = (0, node_path_1.join)(this.synkHomeDir, 'daemon.state.json.lock');
+        this.disableCaffeinate = ['true', '1', 'yes'].includes(process.env.SYNK_DISABLE_CAFFEINATE?.toLowerCase() || '');
+    }
+    ensureDirectories() {
+        if (!(0, node_fs_1.existsSync)(this.synkHomeDir)) {
+            (0, node_fs_1.mkdirSync)(this.synkHomeDir, { recursive: true });
+        }
+        if (!(0, node_fs_1.existsSync)(this.logsDir)) {
+            (0, node_fs_1.mkdirSync)(this.logsDir, { recursive: true });
+        }
+    }
+}
+exports.synkConfig = new SynkConfig();

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

@@ -0,0 +1,11 @@
+/**
+ * HTTP client for communicating with a running synk daemon
+ */
+import type { Metadata } from '../types';
+export declare function notifyDaemonSessionStarted(sessionId: string, metadata: Metadata): Promise<any>;
+export declare function listDaemonSessions(): Promise<any[]>;
+export declare function stopDaemonSession(sessionId: string): Promise<boolean>;
+export declare function spawnDaemonSession(directory: string, sessionId?: string): Promise<any>;
+export declare function stopDaemonHttp(): Promise<void>;
+export declare function checkIfDaemonRunning(): Promise<boolean>;
+export declare function stopDaemon(): Promise<void>;

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

@@ -0,0 +1,101 @@
+"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

@@ -0,0 +1,24 @@
+/**
+ * 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

@@ -0,0 +1,91 @@
+"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

@@ -0,0 +1,14 @@
+/**
+ * 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>;