cvc-tui 0.4.0 → 0.4.2

package/dist/gateway/client.js

@@ -1,312 +0,0 @@
-// 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\\`;