@playcraft/cli 0.0.59 → 0.1.1

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

@@ -1,19 +1,17 @@
 import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { startLauncherProcess } from './launcher-client.js';
 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';
+import { projectNativeThread } from '@playcraft/common/cloud-workspace/runtime';
+import { collectedEvent } 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();
@@ -50,7 +48,10 @@ async function readToken(options) {
     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 launcherSocket = options.launcherSocket || process.env.PLAYCRAFT_LAUNCHER_SOCKET;
+    const homeDir = options.homeDir || process.env.PLAYCRAFT_CODEX_HOME ||
+        (launcherSocket ? '/var/lib/playcraft/codex' : join(options.config.stateDir, 'codex-home'));
+    let executionEpoch = options.config.runtimeEpoch;
     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();
@@ -62,14 +63,10 @@ export function createCodexAppServerAdapter(options) {
     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 });
+    const collected = new Set();
+    function emitCollected(event) {
+        for (const listener of collected)
+            listener(event);
     }
     async function ensureStarted() {
         if (readyFlag && rpc)
@@ -79,44 +76,56 @@ export function createCodexAppServerAdapter(options) {
     }
     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 bin = options.command || process.env.PLAYCRAFT_CODEX_BIN || (launcherSocket ? '/usr/local/bin/codex' : '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'],
-        });
+        if (launcherSocket) {
+            // Configuration travels as non-secret overrides: control cannot write dev's home.
+            for (const [key, value] of Object.entries({
+                model,
+                model_provider: 'playcraft',
+                approval_policy: 'never',
+                sandbox_mode: 'danger-full-access',
+                'model_providers.playcraft.name': 'PlayCraft Model Proxy',
+                'model_providers.playcraft.base_url': options.config.modelProxyUrl.replace(/\/+$/, ''),
+                'model_providers.playcraft.env_key': 'OPENAI_API_KEY',
+                'model_providers.playcraft.wire_api': 'responses',
+                'model_providers.playcraft.requires_openai_auth': false,
+            }))
+                args.push('-c', `${key}=${JSON.stringify(value)}`);
+            child = await startLauncherProcess({
+                socketPath: launcherSocket,
+                processId: `codex-${randomUUID()}`,
+                runtimeEpoch: executionEpoch,
+                argv: [command, ...args],
+                cwd: options.config.workspaceRoot,
+                env: { CODEX_HOME: homeDir, OPENAI_API_KEY: token },
+            });
+        }
+        else {
+            await writePlaycraftCodexConfig({ homeDir, modelProxyUrl: options.config.modelProxyUrl, model });
+            const local = 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'],
+            });
+            await new Promise((resolve, reject) => { local.once('spawn', resolve); local.once('error', reject); });
+            child = {
+                pid: local.pid, stdin: local.stdin, stdout: local.stdout, stderr: local.stderr,
+                onExit(listener) { local.once('exit', listener); },
+                async stop() {
+                    if (local.exitCode === null && local.signalCode === null)
+                        local.kill('SIGTERM');
+                    await waitForChildExit(local);
+                },
+            };
+        }
         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);
+            emitCollected(collectedEvent('notification', method, params));
         });
         rpc.onServerRequest((id, method, params) => {
             const payload = asRecord(params);
@@ -127,19 +136,7 @@ export function createCodexAppServerAdapter(options) {
                 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);
-            }
+            emitCollected(collectedEvent('approval_request', method, { ...payload, itemId: approvalId }));
         });
         const pid = child.pid;
         if (!pid)
@@ -152,31 +149,36 @@ export function createCodexAppServerAdapter(options) {
             superseded: false,
         };
         live = current;
-        child.once('exit', () => {
+        child.onExit(() => {
+            void current.rpc.close();
             if (live === current) {
                 readyFlag = false;
-                live = undefined;
+                // Retain the old handle until its entire execution group is confirmed stopped.
                 rpc = undefined;
-                child = undefined;
-                for (const [turnId, waiter] of turnWaiters) {
-                    turnWaiters.delete(turnId);
-                    waiter.resolve({ outcome: 'uncertain', turnId, events: waiter.events });
-                }
+                emitCollected(collectedEvent('process_exit', 'process.exited', { pid: current.pid }));
             }
             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;
+        try {
+            await rpc.request('initialize', {
+                clientInfo: {
+                    name: 'playcraft_workspace_runtime',
+                    title: 'PlayCraft Workspace Runtime',
+                    version: options.config.cliVersion,
+                },
+            });
+            rpc.notify('initialized', {});
+            readyFlag = true;
+        }
+        catch (error) {
+            current.superseded = true;
+            await current.rpc.close();
+            await current.child.stop();
+            throw error;
+        }
     }
     return {
         name: 'codex-app-server',
@@ -189,6 +191,13 @@ export function createCodexAppServerAdapter(options) {
         onUnexpectedExit(listener) {
             exitListeners.add(listener);
         },
+        onCollected(listener) {
+            collected.add(listener);
+            return () => collected.delete(listener);
+        },
+        turnStartSends() {
+            return rpc?.turnStartSends() ?? 0;
+        },
         async replaceProcess() {
             const previous = live;
             if (previous)
@@ -197,14 +206,10 @@ export function createCodexAppServerAdapter(options) {
             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);
+                await previous.child.stop();
+            executionEpoch += 1;
             if (closed)
                 throw new Error('codex_not_started');
             try {
@@ -236,6 +241,22 @@ export function createCodexAppServerAdapter(options) {
                 return false;
             }
         },
+        async readThread(input) {
+            try {
+                await ensureStarted();
+                if (!rpc)
+                    return undefined;
+                const result = await rpc.request('thread/read', {
+                    threadId: input.threadId,
+                    includeTurns: true,
+                }, 30_000);
+                const projected = projectNativeThread(input.threadId, result.thread ?? result);
+                return projected;
+            }
+            catch {
+                return undefined;
+            }
+        },
         async captureNativeCheckpoint(input) {
             const thread = threads.get(input.threadId);
             if (!thread || thread.sessionId !== input.sessionId)
@@ -265,104 +286,61 @@ export function createCodexAppServerAdapter(options) {
             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' })],
-                };
+                return { outcome: 'failed', error: '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 requestId = rpc.reserveRequest();
+            await input.persistReservation({ nativeRequestId: String(requestId) });
+            if (input.simulateLostReceipt)
+                return { outcome: 'uncertain', threadId: input.threadId };
+            try {
+                const started = await rpc.sendReserved(requestId, 'turn/start', { threadId: input.threadId, input: [{ type: 'text', text: input.text }] }, turnTimeoutMs);
+                const turnId = started.turn?.id;
+                if (!turnId)
+                    return { outcome: 'uncertain', threadId: input.threadId };
+                const thread = threads.get(input.threadId);
+                if (thread)
+                    thread.lastTurnId = turnId;
+                return { outcome: 'accepted', threadId: input.threadId, turnId };
             }
-            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 };
+            catch {
+                return { outcome: 'uncertain', threadId: input.threadId };
             }
-            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: [] };
+                return { outcome: 'uncertain' };
             if (threads.get(input.threadId)?.sessionId !== input.sessionId)
-                return { outcome: 'uncertain', events: [] };
+                return { outcome: 'uncertain' };
             const turnId = threads.get(input.threadId)?.lastTurnId;
             if (!turnId)
-                return { outcome: 'uncertain', events: [] };
+                return { outcome: 'uncertain' };
             try {
                 await rpc.request('turn/interrupt', { threadId: input.threadId, turnId });
             }
             catch {
-                return { outcome: 'uncertain', events: [nativeEvent('turn.interrupted', { threadId: input.threadId })] };
+                return { outcome: 'uncertain', turnId };
             }
-            return {
-                outcome: 'interrupted',
-                turnId,
-                events: [nativeEvent('turn.interrupted', { threadId: input.threadId, turnId })],
-            };
+            return { outcome: 'accepted', turnId };
         },
         async respondApproval(input) {
-            if (!rpc) {
-                return {
-                    outcome: 'failed',
-                    events: [nativeEvent('approval.unknown', { approvalId: input.approvalId })],
-                };
-            }
+            if (!rpc)
+                return { outcome: 'failed', 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 })],
-                };
-            }
+            if (!pending)
+                return { outcome: 'failed', approvalId: input.approvalId };
             approvals.delete(key);
             rpc.respond(pending.rpcId, { decision: input.accepted ? 'accept' : 'decline' });
-            return {
-                outcome: 'completed',
+            emitCollected(collectedEvent('notification', 'approval.resolved', {
                 approvalId: input.approvalId,
-                events: [
-                    nativeEvent('approval.resolved', {
-                        approvalId: input.approvalId,
-                        accepted: input.accepted,
-                    }),
-                ],
-            };
+                accepted: input.accepted,
+                threadId,
+                turnId: pending.turnId,
+            }));
+            return { outcome: 'accepted', approvalId: input.approvalId, turnId: pending.turnId };
         },
         async close() {
             if (closed)
@@ -374,20 +352,8 @@ export function createCodexAppServerAdapter(options) {
             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();
-                    });
-                });
-            }
+            if (current)
+                await current.stop();
             child = undefined;
             live = undefined;
         },

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

@@ -7,6 +7,7 @@ export function createJsonRpcStdioClient(child) {
     const emitter = new EventEmitter();
     const pending = new Map();
     let nextId = 1;
+    let turnStarts = 0;
     let buffer = '';
     let closed = false;
     const onData = (chunk) => {
@@ -60,8 +61,16 @@ export function createJsonRpcStdioClient(child) {
         notify(method, params) {
             send({ method, params: params ?? {} });
         },
-        request(method, params, timeoutMs = 20_000) {
-            const id = nextId++;
+        reserveRequest() {
+            const id = nextId;
+            nextId += 1;
+            return id;
+        },
+        sendReserved(id, method, params, timeoutMs = 20_000) {
+            if (pending.has(id))
+                throw new Error('jsonrpc_request_in_use');
+            if (method === 'turn/start')
+                turnStarts += 1;
             return new Promise((resolve, reject) => {
                 const timer = setTimeout(() => {
                     pending.delete(id);
@@ -78,6 +87,14 @@ export function createJsonRpcStdioClient(child) {
                 }
             });
         },
+        request(method, params, timeoutMs = 20_000) {
+            const id = nextId;
+            nextId += 1;
+            return this.sendReserved(id, method, params, timeoutMs);
+        },
+        turnStartSends() {
+            return turnStarts;
+        },
         onNotification(listener) {
             emitter.on('notification', listener);
             return () => emitter.off('notification', listener);

package/dist/workspace-runtime/codex/launcher-client.js

@@ -0,0 +1,155 @@
+import { EventEmitter } from 'node:events';
+import { createConnection } from 'node:net';
+import { PassThrough, Writable } from 'node:stream';
+import { setTimeout as delay } from 'node:timers/promises';
+function request(socketPath, message) {
+    return new Promise((resolve, reject) => {
+        const socket = createConnection(socketPath);
+        let buffer = '';
+        socket.setEncoding('utf8');
+        const timer = setTimeout(() => socket.destroy(new Error('launcher_request_timeout')), 5000);
+        socket.on('connect', () => socket.write(`${JSON.stringify(message)}\n`));
+        socket.on('data', (chunk) => {
+            buffer += chunk;
+            if (buffer.length > 64 * 1024)
+                return socket.destroy(new Error('launcher_reply_too_large'));
+            if (!buffer.includes('\n'))
+                return;
+            try {
+                const reply = JSON.parse(buffer.split('\n')[0]);
+                if (!reply.ok)
+                    throw new Error(reply.error || 'launcher_request_failed');
+                resolve(reply);
+            }
+            catch (error) {
+                reject(error);
+            }
+            socket.destroy();
+        });
+        socket.on('error', reject);
+        socket.on('close', () => {
+            clearTimeout(timer);
+            reject(new Error('launcher_connection_closed'));
+        });
+    });
+}
+export async function startLauncherProcess(input) {
+    const socket = createConnection(input.socketPath);
+    const stdout = new PassThrough();
+    const stderr = new PassThrough();
+    const events = new EventEmitter();
+    let exited = false;
+    let buffer = '';
+    let identity;
+    let stopPromise;
+    const stdin = new Writable({
+        write(chunk, _encoding, callback) {
+            socket.write(`${JSON.stringify({ action: 'stdin', data: chunk.toString('base64') })}\n`, callback);
+        },
+        final(callback) {
+            socket.write(`${JSON.stringify({ action: 'stdin-end' })}\n`, callback);
+        },
+    });
+    // Transport loss is reported through onExit, never an unhandled stream error.
+    stdin.on('error', () => socket.destroy());
+    function exit() {
+        if (exited)
+            return;
+        exited = true;
+        events.emit('exit');
+    }
+    socket.setEncoding('utf8');
+    const pid = await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => socket.destroy(new Error('launcher_start_timeout')), 5000);
+        let started = false;
+        socket.on('connect', () => {
+            const { socketPath: _socketPath, ...payload } = input;
+            socket.write(`${JSON.stringify({ ...payload, action: 'start-stdio' })}\n`);
+        });
+        socket.on('data', (chunk) => {
+            buffer += chunk;
+            if (buffer.length > 8 * 1024 * 1024)
+                return socket.destroy(new Error('launcher_reply_too_large'));
+            let newline;
+            while ((newline = buffer.indexOf('\n')) >= 0) {
+                const line = buffer.slice(0, newline);
+                buffer = buffer.slice(newline + 1);
+                try {
+                    const frame = JSON.parse(line);
+                    if (!started) {
+                        if (!frame.ok || !frame.pid || !frame.instanceId)
+                            throw new Error(frame.error || 'launcher_start_failed');
+                        identity = {
+                            processId: input.processId,
+                            runtimeEpoch: input.runtimeEpoch,
+                            instanceId: frame.instanceId,
+                        };
+                        started = true;
+                        clearTimeout(timer);
+                        resolve(frame.pid);
+                    }
+                    else if (frame.channel === 'stdout' || frame.channel === 'stderr') {
+                        if (typeof frame.data !== 'string')
+                            throw new Error('launcher_invalid_frame');
+                        const stream = frame.channel === 'stdout' ? stdout : stderr;
+                        if (!stream.write(Buffer.from(frame.data, 'base64'))) {
+                            socket.pause();
+                            stream.once('drain', () => socket.resume());
+                        }
+                    }
+                    else if (frame.event === 'exit')
+                        exit();
+                    else
+                        throw new Error('launcher_invalid_frame');
+                }
+                catch (error) {
+                    socket.destroy(error instanceof Error ? error : new Error('launcher_invalid_frame'));
+                    return;
+                }
+            }
+        });
+        socket.on('error', (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        socket.on('close', () => {
+            clearTimeout(timer);
+            reject(new Error('launcher_connection_closed'));
+            stdout.end();
+            stderr.end();
+            stdin.destroy();
+            exit();
+        });
+    });
+    return {
+        pid,
+        stdin,
+        stdout,
+        stderr,
+        onExit(listener) {
+            if (exited)
+                queueMicrotask(listener);
+            else
+                events.once('exit', listener);
+        },
+        stop() {
+            stopPromise ??= (async () => {
+                // A new launcher's empty registry cannot confirm an old group's exit.
+                for (const signal of ['SIGTERM', 'SIGKILL']) {
+                    await request(input.socketPath, { ...identity, action: 'stop', signal });
+                    const deadline = Date.now() + 3000;
+                    while (Date.now() < deadline) {
+                        const status = await request(input.socketPath, { ...identity, action: 'status' });
+                        if (status.running === false) {
+                            socket.destroy();
+                            return;
+                        }
+                        await delay(50);
+                    }
+                }
+                throw new Error('codex_group_stop_unconfirmed');
+            })();
+            return stopPromise;
+        },
+    };
+}