@ekkos/cli 1.3.1 → 1.3.2

package/dist/synk/session-bridge.js

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

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

package/dist/synk/session-client.js

@@ -0,0 +1,240 @@
+"use strict";
+/**
+ * Real-time session client for ekkOS_synk
+ * Manages Socket.IO connection and message sync with synk-server
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionClient = void 0;
+const node_events_1 = require("node:events");
+const socket_io_client_1 = require("socket.io-client");
+const node_crypto_1 = require("node:crypto");
+const axios_1 = __importDefault(require("axios"));
+const types_1 = require("./types");
+const encryption_1 = require("./encryption");
+const config_1 = require("./config");
+class SessionClient extends node_events_1.EventEmitter {
+    constructor(token, session) {
+        super();
+        this.pendingMessages = [];
+        this.pendingMessageCallback = null;
+        this.lastSeq = 0;
+        this.pendingOutbox = [];
+        this.flushTimer = null;
+        this.token = token;
+        this.sessionId = session.id;
+        this.metadata = session.metadata;
+        this.metadataVersion = session.metadataVersion;
+        this.agentState = session.agentState;
+        this.agentStateVersion = session.agentStateVersion;
+        this.encryptionKey = session.encryptionKey;
+        this.encryptionVariant = session.encryptionVariant;
+        this.socket = (0, socket_io_client_1.io)(config_1.synkConfig.serverUrl, {
+            auth: {
+                token: this.token,
+                clientType: 'session-scoped',
+                sessionId: this.sessionId,
+            },
+            path: '/v1/updates',
+            reconnection: true,
+            reconnectionAttempts: Infinity,
+            reconnectionDelay: 1000,
+            reconnectionDelayMax: 5000,
+            transports: ['websocket'],
+            withCredentials: true,
+            autoConnect: false,
+        });
+        this.socket.on('connect', () => {
+            this.emit('connected');
+            this.fetchMessages().catch(() => { });
+        });
+        this.socket.on('disconnect', (reason) => {
+            this.emit('disconnected', reason);
+        });
+        this.socket.on('connect_error', (error) => {
+            this.emit('error', error);
+        });
+        this.socket.on('update', (data) => {
+            try {
+                if (!data.body)
+                    return;
+                if (data.body.t === 'new-message') {
+                    const messageSeq = data.body.message?.seq;
+                    if (this.lastSeq === 0 || typeof messageSeq !== 'number' || messageSeq !== this.lastSeq + 1 || data.body.message.content.t !== 'encrypted') {
+                        this.fetchMessages().catch(() => { });
+                        return;
+                    }
+                    const body = (0, encryption_1.decrypt)(this.encryptionKey, this.encryptionVariant, (0, encryption_1.decodeBase64)(data.body.message.content.c));
+                    this.routeIncomingMessage(body);
+                    this.lastSeq = messageSeq;
+                }
+                else if (data.body.t === 'update-session') {
+                    if (data.body.metadata && data.body.metadata.version > this.metadataVersion) {
+                        this.metadata = (0, encryption_1.decrypt)(this.encryptionKey, this.encryptionVariant, (0, encryption_1.decodeBase64)(data.body.metadata.value));
+                        this.metadataVersion = data.body.metadata.version;
+                    }
+                    if (data.body.agentState && data.body.agentState.version > this.agentStateVersion) {
+                        this.agentState = data.body.agentState.value
+                            ? (0, encryption_1.decrypt)(this.encryptionKey, this.encryptionVariant, (0, encryption_1.decodeBase64)(data.body.agentState.value))
+                            : null;
+                        this.agentStateVersion = data.body.agentState.version;
+                    }
+                }
+                else {
+                    this.emit('message', data.body);
+                }
+            }
+            catch (error) {
+                this.emit('error', error);
+            }
+        });
+        this.socket.on('rpc-request', async (data, callback) => {
+            this.emit('rpc-request', data, callback);
+        });
+        this.socket.connect();
+    }
+    onUserMessage(callback) {
+        this.pendingMessageCallback = callback;
+        while (this.pendingMessages.length > 0) {
+            callback(this.pendingMessages.shift());
+        }
+    }
+    routeIncomingMessage(message) {
+        const userResult = types_1.UserMessageSchema.safeParse(message);
+        if (userResult.success) {
+            if (this.pendingMessageCallback) {
+                this.pendingMessageCallback(userResult.data);
+            }
+            else {
+                this.pendingMessages.push(userResult.data);
+            }
+            return;
+        }
+        this.emit('message', message);
+    }
+    async fetchMessages() {
+        let afterSeq = this.lastSeq;
+        while (true) {
+            const response = await axios_1.default.get(`${config_1.synkConfig.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/messages`, {
+                params: { after_seq: afterSeq, limit: 100 },
+                headers: { 'Authorization': `Bearer ${this.token}`, 'Content-Type': 'application/json' },
+                timeout: 60000,
+            });
+            const messages = Array.isArray(response.data.messages) ? response.data.messages : [];
+            let maxSeq = afterSeq;
+            for (const message of messages) {
+                if (message.seq > maxSeq)
+                    maxSeq = message.seq;
+                if (message.content?.t !== 'encrypted')
+                    continue;
+                try {
+                    const body = (0, encryption_1.decrypt)(this.encryptionKey, this.encryptionVariant, (0, encryption_1.decodeBase64)(message.content.c));
+                    this.routeIncomingMessage(body);
+                }
+                catch { }
+            }
+            this.lastSeq = Math.max(this.lastSeq, maxSeq);
+            if (!response.data.hasMore || maxSeq === afterSeq)
+                break;
+            afterSeq = maxSeq;
+        }
+    }
+    scheduleFlush() {
+        if (this.flushTimer)
+            return;
+        this.flushTimer = setTimeout(async () => {
+            this.flushTimer = null;
+            await this.flushOutbox().catch(() => { });
+        }, 50);
+    }
+    async flushOutbox() {
+        if (this.pendingOutbox.length === 0)
+            return;
+        const batch = this.pendingOutbox.slice();
+        try {
+            const response = await axios_1.default.post(`${config_1.synkConfig.serverUrl}/v3/sessions/${encodeURIComponent(this.sessionId)}/messages`, { messages: batch }, {
+                headers: { 'Authorization': `Bearer ${this.token}`, 'Content-Type': 'application/json' },
+                timeout: 60000,
+            });
+            this.pendingOutbox.splice(0, batch.length);
+            const messages = Array.isArray(response.data.messages) ? response.data.messages : [];
+            const maxSeq = messages.reduce((acc, m) => (m.seq > acc ? m.seq : acc), this.lastSeq);
+            this.lastSeq = maxSeq;
+        }
+        catch { }
+    }
+    /** Send encrypted message to session */
+    sendMessage(content) {
+        const encrypted = (0, encryption_1.encodeBase64)((0, encryption_1.encrypt)(this.encryptionKey, this.encryptionVariant, content));
+        this.pendingOutbox.push({ content: encrypted, localId: (0, node_crypto_1.randomUUID)() });
+        this.scheduleFlush();
+    }
+    /** Send agent output message */
+    sendAgentMessage(data) {
+        this.sendMessage({
+            role: 'agent',
+            content: { type: 'output', data },
+            meta: { sentFrom: 'cli' },
+        });
+    }
+    /** Send session event */
+    sendSessionEvent(event) {
+        this.sendMessage({
+            role: 'agent',
+            content: { id: (0, node_crypto_1.randomUUID)(), type: 'event', data: event },
+        });
+    }
+    /** Send keepalive ping */
+    keepAlive(thinking, mode) {
+        this.socket.volatile.emit('session-alive', {
+            sid: this.sessionId,
+            time: Date.now(),
+            thinking,
+            mode,
+        });
+    }
+    /** Notify server of session end */
+    sendSessionDeath() {
+        this.socket.emit('session-end', { sid: this.sessionId, time: Date.now() });
+    }
+    /** Update session metadata on server */
+    updateMetadata(handler) {
+        if (!this.metadata)
+            return;
+        const updated = handler(this.metadata);
+        this.socket.emit('update-metadata', {
+            sid: this.sessionId,
+            expectedVersion: this.metadataVersion,
+            metadata: (0, encryption_1.encodeBase64)((0, encryption_1.encrypt)(this.encryptionKey, this.encryptionVariant, updated)),
+        }, (answer) => {
+            if (answer.result === 'success') {
+                this.metadata = (0, encryption_1.decrypt)(this.encryptionKey, this.encryptionVariant, (0, encryption_1.decodeBase64)(answer.metadata));
+                this.metadataVersion = answer.version;
+            }
+            else if (answer.result === 'version-mismatch' && answer.version > this.metadataVersion) {
+                this.metadataVersion = answer.version;
+                this.metadata = (0, encryption_1.decrypt)(this.encryptionKey, this.encryptionVariant, (0, encryption_1.decodeBase64)(answer.metadata));
+            }
+        });
+    }
+    /** Wait for pending messages to flush */
+    async flush() {
+        await this.flushOutbox();
+        if (!this.socket.connected)
+            return;
+        return new Promise((resolve) => {
+            this.socket.emit('ping', () => resolve());
+            setTimeout(() => resolve(), 10000);
+        });
+    }
+    async close() {
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        this.socket.close();
+    }
+}
+exports.SessionClient = SessionClient;