cvc-tui 0.4.4 → 0.4.7

package/dist/gateway/client.js

@@ -0,0 +1,312 @@
+// Real subprocess GatewayClient.
+//
+// Spawns `python -m cvc.tui_gateway.entry` (or attaches to a configured
+// `cvc-tui-gateway` binary), speaks newline-delimited JSON-RPC 2.0 over
+// stdio, and surfaces:
+//   * request/response RPCs   — `send(method, params)` → Promise<result>
+//   * server-push events      — `on('event', ev => …)`  (e.g. chat.delta,
+//                                                       chat.done, chat.start)
+//   * stderr lines            — `on('stderr', line => …)`
+//   * lifecycle               — `on('exit', code => …)`,
+//                               `on('connected', info => …)`
+//
+// The protocol contract matches the Python gateway in cvc/tui_gateway/:
+//   request : {jsonrpc:'2.0', id, method, params}
+//   response: {jsonrpc:'2.0', id, result|error}
+//   event   : {jsonrpc:'2.0', method, params}     (no id)
+//
+// During `connect()` we issue a `session.info` handshake; the resolved
+// session payload (version, model, provider, session_id, cwd) is emitted
+// as `connected` and also returned from connect().
+//
+// Tests inject a fake transport via the `transport` constructor option.
+// In production the transport is a child_process spawned with
+// `stdio: ['pipe','pipe','pipe']`.
+import { spawn } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import { existsSync } from 'node:fs';
+import { delimiter, resolve } from 'node:path';
+import { createInterface } from 'node:readline';
+const DEFAULT_TIMEOUT_MS = Math.max(10000, parseInt(process.env.CVC_TUI_RPC_TIMEOUT_MS ?? '120000', 10) || 120000);
+const STARTUP_TIMEOUT_MS = Math.max(3000, parseInt(process.env.CVC_TUI_STARTUP_TIMEOUT_MS ?? '15000', 10) || 15000);
+const resolvePython = (root) => {
+    const configured = process.env.CVC_PYTHON?.trim() || process.env.PYTHON?.trim();
+    if (configured)
+        return configured;
+    const venv = process.env.VIRTUAL_ENV?.trim();
+    const candidates = [
+        venv && resolve(venv, 'bin/python'),
+        venv && resolve(venv, 'bin/python3'),
+        venv && resolve(venv, 'Scripts/python.exe'),
+        resolve(root, '.venv/bin/python'),
+        resolve(root, '.venv/bin/python3'),
+        resolve(root, 'venv/bin/python'),
+        resolve(root, 'venv/bin/python3'),
+    ];
+    for (const c of candidates) {
+        if (c && existsSync(c))
+            return c;
+    }
+    return process.platform === 'win32' ? 'python' : 'python3';
+};
+const findCvcRoot = () => {
+    // entry.tsx is typically at <root>/cvc-tui/src/entry.tsx
+    // dist/entry.js at <root>/cvc-tui/dist/entry.js
+    // Walk up looking for a "cvc/tui_gateway" sibling.
+    if (process.env.CVC_PYTHON_SRC_ROOT)
+        return process.env.CVC_PYTHON_SRC_ROOT;
+    let dir = process.cwd();
+    for (let i = 0; i < 6; i++) {
+        if (existsSync(resolve(dir, 'cvc', 'tui_gateway', 'entry.py')))
+            return dir;
+        const parent = resolve(dir, '..');
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return process.cwd();
+};
+export class GatewayClient extends EventEmitter {
+    opts;
+    proc = null;
+    transport = null;
+    stdoutRl = null;
+    stderrRl = null;
+    pending = new Map();
+    reqId = 0;
+    session = null;
+    connected = false;
+    exited = false;
+    constructor(opts = {}) {
+        super();
+        this.setMaxListeners(0);
+        this.opts = opts;
+    }
+    /** Spawn (or attach) the gateway and run the session.info handshake. */
+    async connect() {
+        if (this.connected) {
+            return this.session;
+        }
+        if (this.opts.transport) {
+            this.transport = this.opts.transport;
+            this.wireTransport();
+        }
+        else {
+            this.spawnGateway();
+        }
+        // Handshake — single session.info round-trip with bounded timeout.
+        const info = (await this.send('session.info', {}, { timeoutMs: STARTUP_TIMEOUT_MS }));
+        this.session = info;
+        this.connected = true;
+        this.emit('connected', info);
+        return info;
+    }
+    spawnGateway() {
+        const root = this.opts.cwd ?? findCvcRoot();
+        const python = this.opts.python ?? resolvePython(root);
+        const env = { ...process.env };
+        const pyPath = env.PYTHONPATH?.trim();
+        env.PYTHONPATH = pyPath ? `${root}${delimiter}${pyPath}` : root;
+        const proc = spawn(python, ['-m', 'cvc.tui_gateway.entry'], {
+            cwd: root,
+            env,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.proc = proc;
+        this.transport = {
+            stdin: proc.stdin,
+            stdout: proc.stdout,
+            stderr: proc.stderr,
+            kill: () => proc.kill(),
+            on: (event, cb) => {
+                proc.on(event, cb);
+            },
+        };
+        proc.on('error', (err) => {
+            this.emit('stderr', `[spawn] ${err.message}`);
+            this.handleExit(1);
+        });
+        proc.on('exit', (code) => this.handleExit(code));
+        this.wireTransport();
+    }
+    wireTransport() {
+        const t = this.transport;
+        this.stdoutRl = createInterface({ input: t.stdout });
+        this.stdoutRl.on('line', (line) => this.handleLine(line));
+        if (t.stderr) {
+            this.stderrRl = createInterface({ input: t.stderr });
+            this.stderrRl.on('line', (line) => {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    return;
+                this.emit('stderr', trimmed);
+                if (this.opts.forwardStderr) {
+                    process.stderr.write(`[cvc-gateway] ${trimmed}\n`);
+                }
+            });
+        }
+        // Lifecycle: injected transports surface exit through their own `on()`.
+        // The real subprocess path also calls handleExit via proc.on('exit')
+        // registered in spawnGateway, so guard with `exited` to dedupe.
+        t.on?.('exit', (code) => this.handleExit(code));
+    }
+    handleLine(raw) {
+        const line = raw.trim();
+        if (!line)
+            return;
+        let frame;
+        try {
+            frame = JSON.parse(line);
+        }
+        catch {
+            this.emit('stderr', `[protocol] malformed stdout: ${line.slice(0, 200)}`);
+            return;
+        }
+        this.dispatch(frame);
+    }
+    dispatch(frame) {
+        // Response — has `id` and (`result` xor `error`).
+        if ('id' in frame && (('result' in frame) || ('error' in frame))) {
+            const id = String(frame.id);
+            const p = this.pending.get(id);
+            if (!p)
+                return;
+            this.pending.delete(id);
+            clearTimeout(p.timer);
+            if ('error' in frame && frame.error) {
+                const err = frame.error;
+                p.reject(new Error(`${p.method}: ${err.message ?? 'rpc error'} (code=${err.code ?? '?'})`));
+            }
+            else {
+                p.resolve(frame.result);
+            }
+            return;
+        }
+        // Event — has `method` but no `id`.
+        if (typeof frame.method === 'string' && !('id' in frame)) {
+            const ev = {
+                method: frame.method,
+                params: frame.params ?? {},
+            };
+            this.emit('event', ev);
+            this.emit(`event:${ev.method}`, ev.params);
+            return;
+        }
+        // Anything else is malformed — log but don't crash.
+        this.emit('stderr', `[protocol] unexpected frame: ${JSON.stringify(frame).slice(0, 200)}`);
+    }
+    handleExit(code) {
+        if (this.exited)
+            return;
+        this.exited = true;
+        for (const p of Array.from(this.pending.values())) {
+            clearTimeout(p.timer);
+            p.reject(new Error(`gateway exited (code=${code ?? 'null'})`));
+        }
+        this.pending.clear();
+        this.stdoutRl?.close();
+        this.stderrRl?.close();
+        this.connected = false;
+        this.emit('exit', code);
+    }
+    /** Issue a JSON-RPC request and await its response. */
+    send(method, params = {}, opts = {}) {
+        if (!this.transport) {
+            return Promise.reject(new Error('GatewayClient: not connected'));
+        }
+        if (this.exited) {
+            return Promise.reject(new Error('GatewayClient: gateway has exited'));
+        }
+        const id = String(++this.reqId);
+        const frame = JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n';
+        const timeoutMs = opts.timeoutMs ?? this.opts.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`${method}: timeout after ${timeoutMs}ms`));
+            }, timeoutMs);
+            this.pending.set(id, { id, method, resolve, reject, timer });
+            try {
+                this.transport.stdin.write(frame);
+            }
+            catch (err) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(err);
+            }
+        });
+    }
+    /**
+     * Streaming chat helper. Wires `chat.start` / `chat.delta` / `chat.done`
+     * to the supplied handlers, then issues `chat.send`. Resolves with the
+     * `chat.done` summary; rejects on RPC error.
+     */
+    async sendChat(params, handlers = {}) {
+        const onStart = (p) => {
+            handlers.onStart?.({ provider: String(p.provider ?? ''), model: String(p.model ?? '') });
+        };
+        const onDelta = (p) => {
+            const t = typeof p.text === 'string' ? p.text : '';
+            if (t)
+                handlers.onDelta?.(t);
+        };
+        const onDone = (p) => {
+            handlers.onDone?.(p);
+        };
+        this.on('event:chat.start', onStart);
+        this.on('event:chat.delta', onDelta);
+        this.on('event:chat.done', onDone);
+        try {
+            const summary = (await this.send('chat.send', params));
+            return summary;
+        }
+        catch (err) {
+            handlers.onError?.(err);
+            throw err;
+        }
+        finally {
+            this.off('event:chat.start', onStart);
+            this.off('event:chat.delta', onDelta);
+            this.off('event:chat.done', onDone);
+        }
+    }
+    /** Resolved session info from the handshake. */
+    getSession() {
+        return this.session;
+    }
+    isConnected() {
+        return this.connected && !this.exited;
+    }
+    /** Best-effort orderly shutdown — issues system.shutdown and kills proc. */
+    async close() {
+        if (!this.transport || this.exited)
+            return;
+        try {
+            await this.send('system.shutdown', {}, { timeoutMs: 1000 });
+        }
+        catch {
+            // ignore — the gateway may already be tearing down.
+        }
+        try {
+            this.transport.kill?.();
+        }
+        catch {
+            // ignore
+        }
+        if (this.proc && !this.proc.killed) {
+            try {
+                this.proc.kill();
+            }
+            catch {
+                // ignore
+            }
+        }
+        this.handleExit(0);
+    }
+}
+/**
+ * Render an OSC 8 hyperlink escape sequence: `\x1b]8;;URL\x1b\\TEXT\x1b]8;;\x1b\\`.
+ * Re-exported here for tests + downstream consumers that don't want a hard
+ * dependency on the markdown component.
+ */
+export const osc8Link = (url, label) => `\x1b]8;;${url}\x1b\\${label}\x1b]8;;\x1b\\`;