@playcraft/cli 0.0.57 → 0.0.58

package/dist/utils/agent-api-client.js

@@ -3,6 +3,8 @@ import { join } from 'path';
 import { homedir } from 'os';
 import { loadGlobalConfig } from '../config.js';
 import { DEFAULT_PLAYCRAFT_CLOUD_BASE } from '../commands/login.js';
+import { AGENT_TOOL_OPERATION_PROTOCOL, AGENT_TOOL_OPERATION_HEADERS, AGENT_TOOL_OPERATION_CAPABILITIES_PATH, } from '@playcraft/common/agent-tools';
+import { beginToolOperation } from './tool-operation-journal.js';
 /**
  * 判断 token 是否为用户 PAT（Personal Access Token）。
  * PAT 以 "playcraft_pat_" 开头；沙箱 JWT 为三段式 base64。
@@ -48,9 +50,7 @@ export class AgentApiClient {
         this.apiUrl = apiUrl;
         this.token = token;
         this.isPat = isPatToken(token);
-        this.playcraftEnv = (process.env.PLAYCRAFT_ENV ||
-            localConfig.env ||
-            '').trim();
+        this.playcraftEnv = (process.env.PLAYCRAFT_ENV || localConfig.env || '').trim();
     }
     /** 根据 token 类型构造鉴权 headers */
     authHeaders() {
@@ -67,21 +67,58 @@ export class AgentApiClient {
         const p = path.startsWith('/') ? path : `/${path}`;
         return new URL(`/api/agent/tools${p}`, this.apiUrl);
     }
-    async post(path, body) {
-        const url = this.toolsRequestUrl(path).href;
-        const res = await fetch(url, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                ...this.authHeaders(),
-            },
-            body: JSON.stringify(body),
-        });
-        if (!res.ok) {
-            const text = await res.text().catch(() => res.statusText);
-            throw new Error(`API ${res.status}: ${text}`);
+    async post(path, body, options) {
+        const url = this.toolsRequestUrl(path);
+        const serializedBody = JSON.stringify(body);
+        if (serializedBody === undefined)
+            throw new Error('Tool request body is required');
+        const operation = beginToolOperation(url.pathname, serializedBody, options?.requestId ?? process.env.PLAYCRAFT_TOOL_REQUEST_ID);
+        try {
+            const capabilityResponse = await fetch(this.toolsRequestUrl(AGENT_TOOL_OPERATION_CAPABILITIES_PATH), {
+                headers: this.authHeaders(),
+                redirect: 'error',
+                signal: AbortSignal.timeout(30_000),
+            });
+            if (!capabilityResponse.ok) {
+                await capabilityResponse.body?.cancel();
+                throw new Error(`Business tool protocol unavailable (${capabilityResponse.status}); no operation was sent`);
+            }
+            const capabilities = (await capabilityResponse.json());
+            if (capabilities.protocol !== AGENT_TOOL_OPERATION_PROTOCOL ||
+                capabilities.settledOnly !== true)
+                throw new Error('Business tool protocol is incompatible; no operation was sent');
+            const res = await fetch(url, {
+                method: 'POST',
+                redirect: 'error',
+                signal: AbortSignal.timeout(30 * 60_000),
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...this.authHeaders(),
+                    [AGENT_TOOL_OPERATION_HEADERS.protocol]: AGENT_TOOL_OPERATION_PROTOCOL,
+                    [AGENT_TOOL_OPERATION_HEADERS.requestId]: operation.requestId,
+                    ...(operation.settledOnly ? { [AGENT_TOOL_OPERATION_HEADERS.settledOnly]: 'true' } : {}),
+                },
+                body: serializedBody,
+            });
+            if (res.headers.get(AGENT_TOOL_OPERATION_HEADERS.protocol) !== AGENT_TOOL_OPERATION_PROTOCOL ||
+                res.headers.get(AGENT_TOOL_OPERATION_HEADERS.requestId) !== operation.requestId) {
+                await res.body?.cancel();
+                throw new Error('Business did not acknowledge a durable receipt; outcome remains unconfirmed');
+            }
+            if (!res.ok) {
+                const text = await res.text().catch(() => res.statusText);
+                throw new Error(`API ${res.status}: ${text}`);
+            }
+            const result = (await res.json());
+            operation.complete();
+            return result;
+        }
+        catch (error) {
+            throw new Error(`${error instanceof Error ? error.message : String(error)}\n` +
+                `Tool request ${operation.requestId}; record: ${operation.file}. ` +
+                `To query its settled result, rerun the same command with PLAYCRAFT_TOOL_REQUEST_ID=${operation.requestId}. ` +
+                'This recovery does not start another operation.');
         }
-        return res.json();
     }
     async get(path, params) {
         const url = this.toolsRequestUrl(path);

package/dist/utils/tool-operation-journal.js

@@ -0,0 +1,54 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { isAbsolute, join } from 'node:path';
+import { isAgentToolRequestId } from '@playcraft/common/agent-tools';
+/** Persist an identity before sending. Store neither credentials nor request/response bodies. */
+export function beginToolOperation(path, serializedBody, recoverId) {
+    const identifier = recoverId ?? randomUUID();
+    if (!isAgentToolRequestId(identifier))
+        throw new Error('Invalid PLAYCRAFT_TOOL_REQUEST_ID');
+    const requestId = identifier.toLowerCase();
+    const directory = process.env.PLAYCRAFT_TOOL_REQUEST_DIR ?? join(homedir(), '.playcraft', 'tool-requests');
+    if (!isAbsolute(directory))
+        throw new Error('PLAYCRAFT_TOOL_REQUEST_DIR must be an absolute path');
+    mkdirSync(directory, { recursive: true, mode: 0o700 });
+    const file = join(directory, `${requestId}.json`);
+    const inputHash = createHash('sha256').update(serializedBody).digest('hex');
+    const now = new Date().toISOString();
+    const entry = {
+        version: 1,
+        requestId,
+        path,
+        inputHash,
+        state: 'unconfirmed',
+        createdAt: now,
+        updatedAt: now,
+    };
+    let settledOnly = recoverId !== undefined;
+    try {
+        writeFileSync(file, JSON.stringify(entry), { flag: 'wx', mode: 0o600 });
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST')
+            throw error;
+        const previous = JSON.parse(readFileSync(file, 'utf8'));
+        if (previous.version !== 1 ||
+            previous.requestId !== requestId ||
+            previous.path !== path ||
+            previous.inputHash !== inputHash)
+            throw new Error(`Tool request ${requestId} conflicts with its durable local record`);
+        settledOnly = true;
+    }
+    return {
+        requestId,
+        settledOnly,
+        file,
+        complete() {
+            const current = JSON.parse(readFileSync(file, 'utf8'));
+            const temporary = `${file}.${randomUUID()}.tmp`;
+            writeFileSync(temporary, JSON.stringify({ ...current, state: 'completed', updatedAt: new Date().toISOString() }), { flag: 'wx', mode: 0o600 });
+            renameSync(temporary, file);
+        },
+    };
+}

package/dist/workspace-runtime/codex/app-server.js

@@ -0,0 +1,395 @@
+import { spawn } from 'node:child_process';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { writePlaycraftCodexConfig } from './config-toml.js';
+import { createJsonRpcStdioClient } from './jsonrpc-stdio.js';
+import { nativeEvent } from './native-adapter.js';
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}
+function nestedId(value, key) {
+    const record = asRecord(value);
+    const nested = asRecord(record[key]);
+    return typeof nested.id === 'string' ? nested.id : undefined;
+}
+function waitForChildExit(child) {
+    if (child.exitCode !== null || child.signalCode !== null)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        const done = () => {
+            clearTimeout(timer);
+            resolve();
+        };
+        const timer = setTimeout(() => {
+            if (child.exitCode === null && child.signalCode === null)
+                child.kill('SIGKILL');
+        }, 3_000);
+        child.once('exit', done);
+        if (child.exitCode !== null || child.signalCode !== null)
+            done();
+    });
+}
+function spawnCommand(bin) {
+    if (bin.endsWith('.mjs') || bin.endsWith('.js') || bin.endsWith('.ts')) {
+        return { command: process.execPath, prefix: [bin] };
+    }
+    return { command: bin, prefix: [] };
+}
+async function readToken(options) {
+    if (options.token?.trim())
+        return options.token.trim();
+    const fromEnv = process.env.PLAYCRAFT_MODEL_PROXY_TOKEN?.trim() || process.env.OPENAI_API_KEY?.trim() || '';
+    if (fromEnv)
+        return fromEnv;
+    const tokenFile = options.tokenFile || process.env.PLAYCRAFT_MODEL_PROXY_TOKEN_FILE;
+    if (tokenFile) {
+        return (await readFile(tokenFile, 'utf8')).trim();
+    }
+    throw new Error('model_proxy_token_missing');
+}
+export function createCodexAppServerAdapter(options) {
+    const homeDir = options.homeDir || process.env.PLAYCRAFT_CODEX_HOME || join(options.config.stateDir, 'codex-home');
+    const model = options.model || process.env.PLAYCRAFT_CODEX_MODEL || 'gpt-4o';
+    const turnTimeoutMs = options.turnTimeoutMs ?? Number(process.env.PLAYCRAFT_CODEX_TURN_TIMEOUT_MS || 120_000);
+    const threads = new Map();
+    const approvals = new Map();
+    let child;
+    let rpc;
+    let readyFlag = false;
+    let closed = false;
+    let startPromise;
+    let live;
+    const exitListeners = new Set();
+    const unmatchedTurns = new Map();
+    const turnWaiters = new Map();
+    function finishTurn(turnId, params, waiter) {
+        turnWaiters.delete(turnId);
+        unmatchedTurns.delete(turnId);
+        const status = String(asRecord(asRecord(params).turn).status ?? 'completed');
+        const outcome = status === 'interrupted' ? 'interrupted' : status === 'failed' ? 'failed' : 'completed';
+        waiter.resolve({ outcome, turnId, events: waiter.events });
+    }
+    async function ensureStarted() {
+        if (readyFlag && rpc)
+            return;
+        startPromise ??= start();
+        await startPromise;
+    }
+    async function start() {
+        const token = await readToken(options);
+        await writePlaycraftCodexConfig({
+            homeDir,
+            modelProxyUrl: options.config.modelProxyUrl,
+            model,
+        });
+        const bin = options.command || process.env.PLAYCRAFT_CODEX_BIN || 'codex';
+        const { command, prefix } = spawnCommand(bin);
+        const args = [...prefix, ...(options.args ?? ['app-server'])];
+        child = spawn(command, args, {
+            cwd: options.config.workspaceRoot,
+            env: {
+                ...process.env,
+                ...options.env,
+                CODEX_HOME: homeDir,
+                OPENAI_API_KEY: token,
+                PLAYCRAFT_SKIP_UPDATE_CHECK: '1',
+            },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        child.stderr?.on('data', (chunk) => {
+            process.stderr.write(chunk);
+        });
+        rpc = createJsonRpcStdioClient(child);
+        rpc.onNotification((method, params) => {
+            const turnId = nestedId(params, 'turn') ?? String(asRecord(params).turnId ?? '');
+            const event = nativeEvent(method, params);
+            if (!turnId)
+                return;
+            const waiter = turnWaiters.get(turnId);
+            if (waiter) {
+                waiter.events.push(event);
+                if (method === 'turn/completed')
+                    finishTurn(turnId, params, waiter);
+                return;
+            }
+            const queued = unmatchedTurns.get(turnId) ?? [];
+            queued.push(event);
+            unmatchedTurns.set(turnId, queued);
+        });
+        rpc.onServerRequest((id, method, params) => {
+            const payload = asRecord(params);
+            const approvalId = String(payload.itemId ?? id);
+            const turnId = typeof payload.turnId === 'string' ? payload.turnId : '';
+            approvals.set(JSON.stringify([String(payload.threadId ?? ''), approvalId]), {
+                rpcId: id,
+                threadId: String(payload.threadId ?? ''),
+                turnId: turnId || undefined,
+            });
+            const event = nativeEvent(method, params);
+            const waiter = turnId ? turnWaiters.get(turnId) : undefined;
+            if (waiter) {
+                waiter.events.push(event);
+                turnWaiters.delete(turnId);
+                waiter.resolve({ outcome: 'completed', turnId, approvalId, events: waiter.events });
+                return;
+            }
+            if (turnId) {
+                const queued = unmatchedTurns.get(turnId) ?? [];
+                queued.push(event);
+                unmatchedTurns.set(turnId, queued);
+            }
+        });
+        const pid = child.pid;
+        if (!pid)
+            throw new Error('codex_pid_missing');
+        const current = {
+            child,
+            rpc,
+            pid,
+            startedAt: new Date().toISOString(),
+            superseded: false,
+        };
+        live = current;
+        child.once('exit', () => {
+            if (live === current) {
+                readyFlag = false;
+                live = undefined;
+                rpc = undefined;
+                child = undefined;
+                for (const [turnId, waiter] of turnWaiters) {
+                    turnWaiters.delete(turnId);
+                    waiter.resolve({ outcome: 'uncertain', turnId, events: waiter.events });
+                }
+            }
+            if (!current.superseded && !closed) {
+                for (const listener of exitListeners)
+                    listener({ pid: current.pid });
+            }
+        });
+        await rpc.request('initialize', {
+            clientInfo: {
+                name: 'playcraft_workspace_runtime',
+                title: 'PlayCraft Workspace Runtime',
+                version: options.config.cliVersion,
+            },
+        });
+        rpc.notify('initialized', {});
+        readyFlag = true;
+    }
+    return {
+        name: 'codex-app-server',
+        ready: () => readyFlag && !closed,
+        executionProcess() {
+            if (!live)
+                return undefined;
+            return { pid: live.pid, startedAt: live.startedAt };
+        },
+        onUnexpectedExit(listener) {
+            exitListeners.add(listener);
+        },
+        async replaceProcess() {
+            const previous = live;
+            if (previous)
+                previous.superseded = true;
+            readyFlag = false;
+            startPromise = undefined;
+            threads.clear();
+            approvals.clear();
+            turnWaiters.clear();
+            unmatchedTurns.clear();
+            if (previous && previous.child.exitCode === null && previous.child.signalCode === null) {
+                previous.child.kill('SIGTERM');
+            }
+            await previous?.rpc.close().catch(() => undefined);
+            if (previous)
+                await waitForChildExit(previous.child);
+            if (closed)
+                throw new Error('codex_not_started');
+            try {
+                startPromise = start();
+                await startPromise;
+            }
+            catch (error) {
+                startPromise = undefined;
+                throw error;
+            }
+            const next = live;
+            if (!next)
+                throw new Error('codex_not_started');
+            return { pid: next.pid, startedAt: next.startedAt };
+        },
+        async canContinueThread(input) {
+            await ensureStarted();
+            if (!rpc)
+                return false;
+            try {
+                const result = await rpc.request('thread/resume', { threadId: input.threadId, cwd: input.cwd }, 30_000);
+                const resumedId = result.thread?.id ?? result.threadId;
+                if (resumedId !== input.threadId)
+                    return false;
+                threads.set(input.threadId, { sessionId: input.sessionId });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        async captureNativeCheckpoint(input) {
+            const thread = threads.get(input.threadId);
+            if (!thread || thread.sessionId !== input.sessionId)
+                return undefined;
+            if (!thread.lastTurnId)
+                return { threadId: input.threadId };
+            return { threadId: input.threadId, nativeDurableTurnId: thread.lastTurnId };
+        },
+        async start() {
+            await ensureStarted();
+        },
+        async startThread(input) {
+            await ensureStarted();
+            if (!rpc)
+                throw new Error('codex_not_started');
+            const result = await rpc.request('thread/start', {
+                cwd: input.cwd,
+                model,
+            });
+            const threadId = result.thread?.id;
+            if (!threadId)
+                throw new Error('native_receipt_lost');
+            threads.set(threadId, { sessionId: input.sessionId });
+            return { threadId };
+        },
+        async startTurn(input) {
+            await ensureStarted();
+            if (!rpc)
+                throw new Error('codex_not_started');
+            if (input.simulateLostReceipt) {
+                return { outcome: 'uncertain', events: [] };
+            }
+            if (threads.get(input.threadId)?.sessionId !== input.sessionId) {
+                return {
+                    outcome: 'failed',
+                    events: [nativeEvent('turn.failed', { reason: 'unknown_thread' })],
+                };
+            }
+            const started = await rpc.request('turn/start', {
+                threadId: input.threadId,
+                input: [{ type: 'text', text: input.text }],
+            });
+            const turnId = started.turn?.id;
+            if (!turnId)
+                return { outcome: 'uncertain', events: [] };
+            const thread = threads.get(input.threadId);
+            if (thread)
+                thread.lastTurnId = turnId;
+            const queued = unmatchedTurns.get(turnId) ?? [];
+            unmatchedTurns.delete(turnId);
+            const events = [nativeEvent('turn/started', started), ...queued];
+            const alreadyDone = queued.find((event) => event.type === 'turn/completed');
+            if (alreadyDone) {
+                const status = String(asRecord(asRecord(alreadyDone.payload).turn).status ?? 'completed');
+                const outcome = status === 'interrupted' ? 'interrupted' : status === 'failed' ? 'failed' : 'completed';
+                return { outcome, turnId, events };
+            }
+            const approvalEvent = queued.find((event) => event.type.includes('requestApproval') || event.type.includes('requestUserInput'));
+            if (approvalEvent) {
+                const approvalId = String(asRecord(approvalEvent.payload).itemId ?? '');
+                return { outcome: 'completed', turnId, approvalId, events };
+            }
+            return await new Promise((resolve) => {
+                let timer;
+                const waiter = {
+                    events,
+                    resolve: (result) => {
+                        clearTimeout(timer);
+                        resolve(result);
+                    },
+                };
+                timer = setTimeout(() => {
+                    turnWaiters.delete(turnId);
+                    resolve({ outcome: 'uncertain', turnId, events: waiter.events });
+                }, turnTimeoutMs);
+                turnWaiters.set(turnId, waiter);
+            });
+        },
+        async interrupt(input) {
+            await ensureStarted();
+            if (!rpc)
+                return { outcome: 'uncertain', events: [] };
+            if (threads.get(input.threadId)?.sessionId !== input.sessionId)
+                return { outcome: 'uncertain', events: [] };
+            const turnId = threads.get(input.threadId)?.lastTurnId;
+            if (!turnId)
+                return { outcome: 'uncertain', events: [] };
+            try {
+                await rpc.request('turn/interrupt', { threadId: input.threadId, turnId });
+            }
+            catch {
+                return { outcome: 'uncertain', events: [nativeEvent('turn.interrupted', { threadId: input.threadId })] };
+            }
+            return {
+                outcome: 'interrupted',
+                turnId,
+                events: [nativeEvent('turn.interrupted', { threadId: input.threadId, turnId })],
+            };
+        },
+        async respondApproval(input) {
+            if (!rpc) {
+                return {
+                    outcome: 'failed',
+                    events: [nativeEvent('approval.unknown', { approvalId: input.approvalId })],
+                };
+            }
+            const threadId = [...threads].find(([, thread]) => thread.sessionId === input.sessionId)?.[0];
+            const key = JSON.stringify([threadId, input.approvalId]);
+            const pending = approvals.get(key);
+            if (!pending) {
+                return {
+                    outcome: 'failed',
+                    events: [nativeEvent('approval.unknown', { approvalId: input.approvalId })],
+                };
+            }
+            approvals.delete(key);
+            rpc.respond(pending.rpcId, { decision: input.accepted ? 'accept' : 'decline' });
+            return {
+                outcome: 'completed',
+                approvalId: input.approvalId,
+                events: [
+                    nativeEvent('approval.resolved', {
+                        approvalId: input.approvalId,
+                        accepted: input.accepted,
+                    }),
+                ],
+            };
+        },
+        async close() {
+            if (closed)
+                return;
+            closed = true;
+            readyFlag = false;
+            if (live)
+                live.superseded = true;
+            const current = child;
+            await rpc?.close().catch(() => undefined);
+            rpc = undefined;
+            if (current && current.exitCode === null && !current.killed) {
+                current.kill('SIGTERM');
+                await new Promise((resolve) => {
+                    const timer = setTimeout(() => {
+                        if (current.exitCode === null)
+                            current.kill('SIGKILL');
+                        resolve();
+                    }, 3000);
+                    current.once('exit', () => {
+                        clearTimeout(timer);
+                        resolve();
+                    });
+                });
+            }
+            child = undefined;
+            live = undefined;
+        },
+    };
+}

package/dist/workspace-runtime/codex/config-toml.js

@@ -0,0 +1,25 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+function tomlString(value) {
+    return JSON.stringify(value);
+}
+export async function writePlaycraftCodexConfig(input) {
+    await mkdir(input.homeDir, { recursive: true, mode: 0o700 });
+    const path = join(input.homeDir, 'config.toml');
+    const body = [
+        `model = ${tomlString(input.model)}`,
+        'model_provider = "playcraft"',
+        'approval_policy = "never"',
+        'sandbox_mode = "danger-full-access"',
+        '',
+        '[model_providers.playcraft]',
+        'name = "PlayCraft Model Proxy"',
+        `base_url = ${tomlString(input.modelProxyUrl.replace(/\/+$/, ''))}`,
+        'env_key = "OPENAI_API_KEY"',
+        'wire_api = "responses"',
+        'requires_openai_auth = false',
+        '',
+    ].join('\n');
+    await writeFile(path, body, { encoding: 'utf8', mode: 0o600 });
+    return path;
+}

package/dist/workspace-runtime/codex/jsonrpc-stdio.js

@@ -0,0 +1,106 @@
+import { EventEmitter } from 'node:events';
+export function createJsonRpcStdioClient(child) {
+    const stdin = child.stdin;
+    const stdout = child.stdout;
+    if (!stdin || !stdout)
+        throw new Error('codex_stdio_missing');
+    const emitter = new EventEmitter();
+    const pending = new Map();
+    let nextId = 1;
+    let buffer = '';
+    let closed = false;
+    const onData = (chunk) => {
+        buffer += typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+        let newline = buffer.indexOf('\n');
+        while (newline >= 0) {
+            const line = buffer.slice(0, newline).trim();
+            buffer = buffer.slice(newline + 1);
+            if (line)
+                handleLine(line);
+            newline = buffer.indexOf('\n');
+        }
+    };
+    stdout.setEncoding('utf8');
+    stdout.on('data', onData);
+    function handleLine(line) {
+        let message;
+        try {
+            message = JSON.parse(line);
+        }
+        catch {
+            return;
+        }
+        if (message.id !== undefined && pending.has(Number(message.id))) {
+            const waiter = pending.get(Number(message.id));
+            if (!waiter)
+                return;
+            pending.delete(Number(message.id));
+            clearTimeout(waiter.timer);
+            if (message.error) {
+                waiter.reject(new Error(message.error.message || 'jsonrpc_error'));
+                return;
+            }
+            waiter.resolve(message.result);
+            return;
+        }
+        if (message.method && message.id !== undefined) {
+            emitter.emit('serverRequest', message.id, message.method, message.params ?? {});
+            return;
+        }
+        if (message.method) {
+            emitter.emit('notification', message.method, message.params ?? {});
+        }
+    }
+    const send = (payload) => {
+        if (closed)
+            throw new Error('jsonrpc_closed');
+        stdin.write(`${JSON.stringify(payload)}\n`);
+    };
+    return {
+        notify(method, params) {
+            send({ method, params: params ?? {} });
+        },
+        request(method, params, timeoutMs = 20_000) {
+            const id = nextId++;
+            return new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    pending.delete(id);
+                    reject(new Error(`jsonrpc_timeout:${method}`));
+                }, timeoutMs);
+                pending.set(id, { resolve: (value) => resolve(value), reject, timer });
+                try {
+                    send({ method, id, params: params ?? {} });
+                }
+                catch (error) {
+                    pending.delete(id);
+                    clearTimeout(timer);
+                    reject(error instanceof Error ? error : new Error(String(error)));
+                }
+            });
+        },
+        onNotification(listener) {
+            emitter.on('notification', listener);
+            return () => emitter.off('notification', listener);
+        },
+        onServerRequest(listener) {
+            emitter.on('serverRequest', listener);
+            return () => emitter.off('serverRequest', listener);
+        },
+        respond(id, result) {
+            send({ id, result });
+        },
+        async close() {
+            if (closed)
+                return;
+            closed = true;
+            stdout.off('data', onData);
+            for (const [id, waiter] of pending) {
+                clearTimeout(waiter.timer);
+                waiter.reject(new Error('jsonrpc_closed'));
+                pending.delete(id);
+            }
+            if (!stdin.destroyed)
+                stdin.end();
+        },
+    };
+}