@ekkos/cli 1.3.2 → 1.3.6

package/dist/synk/persistence.js

@@ -1,211 +0,0 @@
-"use strict";
-/**
- * Persistence for ekkOS_synk — credentials, settings, daemon state
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readCredentials = readCredentials;
-exports.writeCredentialsLegacy = writeCredentialsLegacy;
-exports.writeCredentialsDataKey = writeCredentialsDataKey;
-exports.clearCredentials = clearCredentials;
-exports.readSettings = readSettings;
-exports.writeSettings = writeSettings;
-exports.updateSettings = updateSettings;
-exports.readDaemonState = readDaemonState;
-exports.writeDaemonState = writeDaemonState;
-exports.clearDaemonState = clearDaemonState;
-exports.acquireDaemonLock = acquireDaemonLock;
-exports.releaseDaemonLock = releaseDaemonLock;
-const promises_1 = require("node:fs/promises");
-const node_fs_1 = require("node:fs");
-const node_fs_2 = require("node:fs");
-const zod_1 = require("zod");
-const config_1 = require("./config");
-const encryption_1 = require("./encryption");
-const defaultSettings = {
-    schemaVersion: 1,
-    onboardingCompleted: false,
-};
-// Credentials
-const credentialsSchema = zod_1.z.object({
-    token: zod_1.z.string(),
-    secret: zod_1.z.string().base64().nullish(),
-    encryption: zod_1.z.object({
-        publicKey: zod_1.z.string().base64(),
-        machineKey: zod_1.z.string().base64(),
-    }).nullish(),
-});
-async function readCredentials() {
-    if (!(0, node_fs_1.existsSync)(config_1.synkConfig.credentialsFile))
-        return null;
-    try {
-        const raw = JSON.parse(await (0, promises_1.readFile)(config_1.synkConfig.credentialsFile, 'utf8'));
-        const credentials = credentialsSchema.parse(raw);
-        if (credentials.secret) {
-            return {
-                token: credentials.token,
-                encryption: { type: 'legacy', secret: new Uint8Array(Buffer.from(credentials.secret, 'base64')) },
-            };
-        }
-        else if (credentials.encryption) {
-            return {
-                token: credentials.token,
-                encryption: {
-                    type: 'dataKey',
-                    publicKey: new Uint8Array(Buffer.from(credentials.encryption.publicKey, 'base64')),
-                    machineKey: new Uint8Array(Buffer.from(credentials.encryption.machineKey, 'base64')),
-                },
-            };
-        }
-    }
-    catch {
-        return null;
-    }
-    return null;
-}
-async function writeCredentialsLegacy(credentials) {
-    config_1.synkConfig.ensureDirectories();
-    await (0, promises_1.writeFile)(config_1.synkConfig.credentialsFile, JSON.stringify({
-        secret: (0, encryption_1.encodeBase64)(credentials.secret),
-        token: credentials.token,
-    }, null, 2));
-}
-async function writeCredentialsDataKey(credentials) {
-    config_1.synkConfig.ensureDirectories();
-    await (0, promises_1.writeFile)(config_1.synkConfig.credentialsFile, JSON.stringify({
-        encryption: {
-            publicKey: (0, encryption_1.encodeBase64)(credentials.publicKey),
-            machineKey: (0, encryption_1.encodeBase64)(credentials.machineKey),
-        },
-        token: credentials.token,
-    }, null, 2));
-}
-async function clearCredentials() {
-    if ((0, node_fs_1.existsSync)(config_1.synkConfig.credentialsFile)) {
-        await (0, promises_1.unlink)(config_1.synkConfig.credentialsFile);
-    }
-}
-// Settings
-async function readSettings() {
-    if (!(0, node_fs_1.existsSync)(config_1.synkConfig.settingsFile))
-        return { ...defaultSettings };
-    try {
-        const raw = JSON.parse(await (0, promises_1.readFile)(config_1.synkConfig.settingsFile, 'utf8'));
-        return { ...defaultSettings, ...raw };
-    }
-    catch {
-        return { ...defaultSettings };
-    }
-}
-async function writeSettings(settings) {
-    config_1.synkConfig.ensureDirectories();
-    await (0, promises_1.writeFile)(config_1.synkConfig.settingsFile, JSON.stringify(settings, null, 2));
-}
-async function updateSettings(updater) {
-    const lockFile = config_1.synkConfig.settingsFile + '.lock';
-    const tmpFile = config_1.synkConfig.settingsFile + '.tmp';
-    let fileHandle;
-    let attempts = 0;
-    while (attempts < 50) {
-        try {
-            fileHandle = await (0, promises_1.open)(lockFile, node_fs_2.constants.O_CREAT | node_fs_2.constants.O_EXCL | node_fs_2.constants.O_WRONLY);
-            break;
-        }
-        catch (err) {
-            if (err.code === 'EEXIST') {
-                attempts++;
-                await new Promise(resolve => setTimeout(resolve, 100));
-                try {
-                    const stats = await (0, promises_1.stat)(lockFile);
-                    if (Date.now() - stats.mtimeMs > 10000) {
-                        await (0, promises_1.unlink)(lockFile).catch(() => { });
-                    }
-                }
-                catch { }
-            }
-            else {
-                throw err;
-            }
-        }
-    }
-    if (!fileHandle) {
-        throw new Error('Failed to acquire settings lock after 5 seconds');
-    }
-    try {
-        const current = await readSettings();
-        const updated = await updater(current);
-        config_1.synkConfig.ensureDirectories();
-        await (0, promises_1.writeFile)(tmpFile, JSON.stringify(updated, null, 2));
-        await (0, promises_1.rename)(tmpFile, config_1.synkConfig.settingsFile);
-        return updated;
-    }
-    finally {
-        await fileHandle.close();
-        await (0, promises_1.unlink)(lockFile).catch(() => { });
-    }
-}
-// Daemon state
-async function readDaemonState() {
-    try {
-        if (!(0, node_fs_1.existsSync)(config_1.synkConfig.daemonStateFile))
-            return null;
-        return JSON.parse(await (0, promises_1.readFile)(config_1.synkConfig.daemonStateFile, 'utf-8'));
-    }
-    catch {
-        return null;
-    }
-}
-function writeDaemonState(state) {
-    (0, node_fs_1.writeFileSync)(config_1.synkConfig.daemonStateFile, JSON.stringify(state, null, 2), 'utf-8');
-}
-async function clearDaemonState() {
-    if ((0, node_fs_1.existsSync)(config_1.synkConfig.daemonStateFile)) {
-        await (0, promises_1.unlink)(config_1.synkConfig.daemonStateFile);
-    }
-    if ((0, node_fs_1.existsSync)(config_1.synkConfig.daemonLockFile)) {
-        try {
-            await (0, promises_1.unlink)(config_1.synkConfig.daemonLockFile);
-        }
-        catch { }
-    }
-}
-async function acquireDaemonLock(maxAttempts = 5, delayIncrementMs = 200) {
-    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-        try {
-            const fileHandle = await (0, promises_1.open)(config_1.synkConfig.daemonLockFile, node_fs_2.constants.O_CREAT | node_fs_2.constants.O_EXCL | node_fs_2.constants.O_WRONLY);
-            await fileHandle.writeFile(String(process.pid));
-            return fileHandle;
-        }
-        catch (error) {
-            if (error.code === 'EEXIST') {
-                try {
-                    const lockPid = (0, node_fs_1.readFileSync)(config_1.synkConfig.daemonLockFile, 'utf-8').trim();
-                    if (lockPid && !isNaN(Number(lockPid))) {
-                        try {
-                            process.kill(Number(lockPid), 0);
-                        }
-                        catch {
-                            (0, node_fs_1.unlinkSync)(config_1.synkConfig.daemonLockFile);
-                            continue;
-                        }
-                    }
-                }
-                catch { }
-            }
-            if (attempt === maxAttempts)
-                return null;
-            await new Promise(resolve => setTimeout(resolve, attempt * delayIncrementMs));
-        }
-    }
-    return null;
-}
-async function releaseDaemonLock(lockHandle) {
-    try {
-        await lockHandle.close();
-    }
-    catch { }
-    try {
-        if ((0, node_fs_1.existsSync)(config_1.synkConfig.daemonLockFile))
-            (0, node_fs_1.unlinkSync)(config_1.synkConfig.daemonLockFile);
-    }
-    catch { }
-}

package/dist/synk/qr.d.ts

@@ -1,5 +0,0 @@
-/**
- * QR code display for ekkOS_synk mobile pairing
- */
-/** Display a QR code in the terminal for mobile device pairing */
-export declare function displayQRCode(url: string): void;

package/dist/synk/qr.js

@@ -1,33 +0,0 @@
-"use strict";
-/**
- * QR code display for ekkOS_synk mobile pairing
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.displayQRCode = displayQRCode;
-const chalk_1 = __importDefault(require("chalk"));
-/** Display a QR code in the terminal for mobile device pairing */
-function displayQRCode(url) {
-    let qrcode;
-    try {
-        qrcode = require('qrcode-terminal');
-    }
-    catch {
-        console.log(chalk_1.default.yellow('  qrcode-terminal not installed. Install it for QR code display.'));
-        console.log(chalk_1.default.gray(`  Pairing URL: ${url}`));
-        return;
-    }
-    console.log('');
-    console.log(chalk_1.default.cyan('═'.repeat(60)));
-    console.log(chalk_1.default.cyan.bold('  ekkOS_synk') + chalk_1.default.gray(' — Scan to pair your mobile device'));
-    console.log(chalk_1.default.cyan('═'.repeat(60)));
-    qrcode.generate(url, { small: true }, (qr) => {
-        for (const line of qr.split('\n')) {
-            console.log(' '.repeat(8) + line);
-        }
-    });
-    console.log(chalk_1.default.cyan('═'.repeat(60)));
-    console.log('');
-}

package/dist/synk/session-bridge.d.ts

@@ -1,58 +0,0 @@
-/**
- * SynkSessionBridge — links `ekkos run` to synk real-time sync
- *
- * Lifecycle:
- *   create()              → reads creds, returns null if synk disabled
- *   onSessionEstablished  → creates synk session + WS client
- *   onAgentOutput         → batched forwarding of PTY output
- *   onIdleChange          → keepalive / thinking state
- *   onTurnEnd             → flush output buffer
- *   shutdown              → graceful close
- */
-import { EventEmitter } from 'node:events';
-export interface SynkBridgeOptions {
-    cwd: string;
-    verbose?: boolean;
-}
-export declare class SynkSessionBridge extends EventEmitter {
-    private readonly credential;
-    private readonly apiClient;
-    private readonly cwd;
-    private readonly verbose;
-    private sessionClient;
-    private synkSession;
-    private outputBuffer;
-    private flushTimer;
-    private established;
-    private closed;
-    private constructor();
-    /**
-     * Factory — returns null when synk is not configured (zero-cost path).
-     */
-    static create(opts: SynkBridgeOptions): Promise<SynkSessionBridge | null>;
-    /**
-     * Called once after Claude Code's session name is detected from the status line.
-     * Creates the synk session via REST, then opens a SessionClient WebSocket.
-     */
-    onSessionEstablished(sessionName: string, sessionId: string, extra?: {
-        hostPid?: number;
-    }): Promise<void>;
-    /**
-     * Called on every PTY data chunk. Buffers and flushes every 200ms.
-     */
-    onAgentOutput(data: string): void;
-    /**
-     * Called when Claude transitions between idle <-> active.
-     */
-    onIdleChange(idle: boolean): void;
-    /**
-     * Called at turn boundaries — flush any pending output immediately.
-     */
-    onTurnEnd(): void;
-    /**
-     * Graceful shutdown — send death event, flush, close socket.
-     */
-    shutdown(): Promise<void>;
-    private flushOutputBuffer;
-    private log;
-}

package/dist/synk/session-bridge.js

@@ -1,171 +0,0 @@
-"use strict";
-/**
- * SynkSessionBridge — links `ekkos run` to synk real-time sync
- *
- * Lifecycle:
- *   create()              → reads creds, returns null if synk disabled
- *   onSessionEstablished  → creates synk session + WS client
- *   onAgentOutput         → batched forwarding of PTY output
- *   onIdleChange          → keepalive / thinking state
- *   onTurnEnd             → flush output buffer
- *   shutdown              → graceful close
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SynkSessionBridge = void 0;
-const node_events_1 = require("node:events");
-const node_os_1 = __importDefault(require("node:os"));
-const persistence_1 = require("./persistence");
-const api_1 = require("./api");
-const session_client_1 = require("./session-client");
-const config_1 = require("./config");
-const control_client_1 = require("./daemon/control-client");
-class SynkSessionBridge extends node_events_1.EventEmitter {
-    constructor(credential, apiClient, opts) {
-        super();
-        this.sessionClient = null;
-        this.synkSession = null;
-        this.outputBuffer = '';
-        this.flushTimer = null;
-        this.established = false;
-        this.closed = false;
-        this.credential = credential;
-        this.apiClient = apiClient;
-        this.cwd = opts.cwd;
-        this.verbose = opts.verbose ?? false;
-    }
-    /**
-     * Factory — returns null when synk is not configured (zero-cost path).
-     */
-    static async create(opts) {
-        try {
-            const credential = await (0, persistence_1.readCredentials)();
-            if (!credential)
-                return null;
-            const apiClient = await api_1.ApiClient.create(credential);
-            return new SynkSessionBridge(credential, apiClient, opts);
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * Called once after Claude Code's session name is detected from the status line.
-     * Creates the synk session via REST, then opens a SessionClient WebSocket.
-     */
-    async onSessionEstablished(sessionName, sessionId, extra) {
-        if (this.established || this.closed)
-            return;
-        this.established = true;
-        try {
-            const settings = await (0, persistence_1.readSettings)();
-            const metadata = {
-                path: this.cwd,
-                host: node_os_1.default.hostname(),
-                name: sessionName,
-                os: node_os_1.default.platform(),
-                homeDir: node_os_1.default.homedir(),
-                synkHomeDir: config_1.synkConfig.synkHomeDir,
-                machineId: settings.machineId,
-                claudeSessionId: sessionId,
-                hostPid: extra?.hostPid ?? process.pid,
-                startedBy: 'terminal',
-                lifecycleState: 'running',
-                lifecycleStateSince: Date.now(),
-            };
-            const session = await this.apiClient.getOrCreateSession({
-                tag: sessionId,
-                metadata,
-                state: null,
-            });
-            if (!session) {
-                this.log('synk session creation failed (server unreachable)');
-                return;
-            }
-            this.synkSession = session;
-            this.sessionClient = new session_client_1.SessionClient(this.credential.token, session);
-            // Pipe incoming user messages to run.ts via EventEmitter
-            this.sessionClient.onUserMessage((msg) => {
-                this.emit('remote-message', { text: msg.content.text, meta: msg.meta });
-            });
-            this.sessionClient.on('connected', () => this.log('synk WS connected'));
-            this.sessionClient.on('disconnected', (reason) => this.log(`synk WS disconnected: ${reason}`));
-            this.sessionClient.on('error', (err) => this.log(`synk WS error: ${err.message}`));
-            // Notify daemon (best-effort, fire-and-forget)
-            (0, control_client_1.notifyDaemonSessionStarted)(session.id, metadata).catch(() => { });
-            this.log(`synk session established: ${session.id}`);
-        }
-        catch (err) {
-            this.log(`synk session establish error: ${err instanceof Error ? err.message : err}`);
-        }
-    }
-    /**
-     * Called on every PTY data chunk. Buffers and flushes every 200ms.
-     */
-    onAgentOutput(data) {
-        if (!this.sessionClient || this.closed)
-            return;
-        this.outputBuffer += data;
-        if (!this.flushTimer) {
-            this.flushTimer = setTimeout(() => {
-                this.flushTimer = null;
-                this.flushOutputBuffer();
-            }, 200);
-        }
-    }
-    /**
-     * Called when Claude transitions between idle <-> active.
-     */
-    onIdleChange(idle) {
-        if (!this.sessionClient || this.closed)
-            return;
-        this.sessionClient.keepAlive(!idle, 'local');
-    }
-    /**
-     * Called at turn boundaries — flush any pending output immediately.
-     */
-    onTurnEnd() {
-        this.flushOutputBuffer();
-    }
-    /**
-     * Graceful shutdown — send death event, flush, close socket.
-     */
-    async shutdown() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        if (this.flushTimer) {
-            clearTimeout(this.flushTimer);
-            this.flushTimer = null;
-        }
-        this.flushOutputBuffer();
-        if (this.sessionClient) {
-            try {
-                this.sessionClient.sendSessionDeath();
-                await Promise.race([
-                    this.sessionClient.flush(),
-                    new Promise(resolve => setTimeout(resolve, 3000)),
-                ]);
-            }
-            catch { }
-            await this.sessionClient.close().catch(() => { });
-            this.sessionClient = null;
-        }
-    }
-    // ── internals ──
-    flushOutputBuffer() {
-        if (!this.sessionClient || this.outputBuffer.length === 0)
-            return;
-        const chunk = this.outputBuffer;
-        this.outputBuffer = '';
-        this.sessionClient.sendAgentMessage(chunk);
-    }
-    log(msg) {
-        if (this.verbose) {
-            process.stderr.write(`[synk-bridge] ${msg}\n`);
-        }
-    }
-}
-exports.SynkSessionBridge = SynkSessionBridge;

package/dist/synk/session-client.d.ts

@@ -1,46 +0,0 @@
-/**
- * Real-time session client for ekkOS_synk
- * Manages Socket.IO connection and message sync with synk-server
- */
-import { EventEmitter } from 'node:events';
-import type { Session, Metadata, UserMessage } from './types';
-export declare class SessionClient extends EventEmitter {
-    private readonly token;
-    readonly sessionId: string;
-    private metadata;
-    private metadataVersion;
-    private agentState;
-    private agentStateVersion;
-    private socket;
-    private pendingMessages;
-    private pendingMessageCallback;
-    private encryptionKey;
-    private encryptionVariant;
-    private lastSeq;
-    private pendingOutbox;
-    private flushTimer;
-    constructor(token: string, session: Session);
-    onUserMessage(callback: (data: UserMessage) => void): void;
-    private routeIncomingMessage;
-    private fetchMessages;
-    private scheduleFlush;
-    private flushOutbox;
-    /** Send encrypted message to session */
-    sendMessage(content: unknown): void;
-    /** Send agent output message */
-    sendAgentMessage(data: any): void;
-    /** Send session event */
-    sendSessionEvent(event: {
-        type: string;
-        [key: string]: any;
-    }): void;
-    /** Send keepalive ping */
-    keepAlive(thinking: boolean, mode: 'local' | 'remote'): void;
-    /** Notify server of session end */
-    sendSessionDeath(): void;
-    /** Update session metadata on server */
-    updateMetadata(handler: (metadata: Metadata) => Metadata): void;
-    /** Wait for pending messages to flush */
-    flush(): Promise<void>;
-    close(): Promise<void>;
-}