@playcraft/cli 0.0.56 → 0.0.58

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();
+        },
+    };
+}

package/dist/workspace-runtime/codex/loopback.js

@@ -0,0 +1,59 @@
+import { nativeEvent } from './native-adapter.js';
+/** In-process Codex stand-in. Not the App Server; used to prove the operation/event loop. */
+export function createLoopbackNativeAdapter() {
+    const threads = new Map();
+    const approvals = new Set();
+    return {
+        name: 'loopback',
+        ready: () => true,
+        async startThread(input) {
+            const threadId = `thread_${input.sessionId}`;
+            threads.set(threadId, input.sessionId);
+            return { threadId };
+        },
+        async startTurn(input) {
+            if (threads.get(input.threadId) !== input.sessionId) {
+                return {
+                    outcome: 'failed',
+                    events: [nativeEvent('turn.failed', { reason: 'unknown_thread' })],
+                };
+            }
+            if (input.simulateLostReceipt) {
+                return { outcome: 'uncertain', events: [] };
+            }
+            const turnId = `turn_${input.clientRequestId}`;
+            const events = [
+                nativeEvent('item/agentMessage/delta', { text: `loopback:${input.text}` }),
+                nativeEvent('turn.completed', { turnId, threadId: input.threadId }),
+            ];
+            if (input.text.includes('[approval]')) {
+                const approvalId = `approval_${input.clientRequestId}`;
+                approvals.add(JSON.stringify([input.sessionId, approvalId]));
+                events.splice(1, 0, nativeEvent('item/tool/requestUserInput', { approvalId }));
+                return { outcome: 'completed', turnId, approvalId, events };
+            }
+            return { outcome: 'completed', turnId, events };
+        },
+        async interrupt(input) {
+            if (threads.get(input.threadId) !== input.sessionId) {
+                return { outcome: 'uncertain', events: [] };
+            }
+            return {
+                outcome: 'interrupted',
+                events: [nativeEvent('turn.interrupted', { threadId: input.threadId })],
+            };
+        },
+        async respondApproval(input) {
+            if (!approvals.has(JSON.stringify([input.sessionId, input.approvalId]))) {
+                return { outcome: 'failed', events: [nativeEvent('approval.unknown', { approvalId: input.approvalId })] };
+            }
+            approvals.delete(JSON.stringify([input.sessionId, input.approvalId]));
+            const result = {
+                outcome: 'completed',
+                approvalId: input.approvalId,
+                events: [nativeEvent('approval.resolved', { approvalId: input.approvalId, accepted: input.accepted })],
+            };
+            return result;
+        },
+    };
+}

package/dist/workspace-runtime/codex/native-adapter.js

@@ -0,0 +1,3 @@
+export function nativeEvent(type, payload) {
+    return { type, payload, occurredAt: new Date().toISOString() };
+}

package/dist/workspace-runtime/main.js

@@ -0,0 +1,10 @@
+import { runWorkspaceRuntimeServe } from '../commands/workspace-runtime.js';
+const flag = process.argv.indexOf('--config');
+const configPath = flag >= 0 ? process.argv[flag + 1] : undefined;
+if (!configPath) {
+    console.error('workspace-runtime: missing --config');
+    process.exitCode = 2;
+}
+else {
+    await runWorkspaceRuntimeServe(configPath);
+}