@playcraft/cli 0.1.35-prod → 0.1.37-beta

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

@@ -0,0 +1,46 @@
+import { NativeRpcResponseError } from './jsonrpc-stdio.js';
+/** The compact receipt is empty. A separately observed turn supplies its durable identity. */
+export async function requestNativeCompaction(input) {
+    let turnId;
+    let rejectStarted = () => { };
+    let unsubscribe = () => { };
+    let timer;
+    const started = new Promise((resolve, reject) => {
+        rejectStarted = reject;
+        timer = setTimeout(() => reject(new Error('compact_start_timeout')), input.timeoutMs);
+        unsubscribe = input.onCollected(event => {
+            if (event.kind === 'process_exit') {
+                reject(new Error('compact_process_exited'));
+                return;
+            }
+            if (event.method !== 'turn/started')
+                return;
+            const params = record(event.params), turn = record(params.turn);
+            if (params.threadId !== input.threadId || typeof turn.id !== 'string' || !turn.id || turn.id === input.previousTurnId)
+                return;
+            turnId = turn.id;
+            resolve(turn.id);
+        });
+    });
+    try {
+        // Subscribe before sending: Codex may emit the new turn before acknowledging this request.
+        await Promise.all([started, input.client.sendReserved(input.requestId, 'thread/compact/start', {
+                threadId: input.threadId,
+            }, input.timeoutMs)]);
+        return { outcome: 'accepted', threadId: input.threadId, turnId: turnId };
+    }
+    catch (error) {
+        if (error instanceof NativeRpcResponseError && !turnId)
+            return { outcome: 'failed', error: 'compact_start_rejected' };
+        return { outcome: 'uncertain', threadId: input.threadId, ...(turnId ? { turnId } : {}) };
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        unsubscribe();
+        rejectStarted(new Error('compact_request_finished'));
+    }
+}
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}

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

@@ -0,0 +1,107 @@
+import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+const exec = promisify(execFile);
+function tomlString(value) {
+    return JSON.stringify(value);
+}
+/** Keep workspace turns portable between native Responses and function-tool conversion. */
+export function portableCodexConfig(catalogPath) {
+    return {
+        web_search: 'disabled',
+        'features.multi_agent': true,
+        'features.goals': false,
+        'features.apps': false,
+        'features.plugins': false,
+        'features.code_mode': false,
+        'features.code_mode_host': false,
+        'features.code_mode_only': false,
+        model_reasoning_summary: 'none',
+        ...(catalogPath ? { model_catalog_json: catalogPath } : {}),
+    };
+}
+/** Retain real model identities and limits while declaring this gateway's portable tools. */
+export function portableCodexCatalog(raw) {
+    if (!raw ||
+        typeof raw !== 'object' ||
+        Array.isArray(raw) ||
+        !Array.isArray(raw.models)) {
+        throw new Error('codex_model_catalog_invalid');
+    }
+    const catalog = raw;
+    const models = catalog.models.map((value) => {
+        if (!value ||
+            typeof value !== 'object' ||
+            Array.isArray(value) ||
+            typeof value.slug !== 'string') {
+            throw new Error('codex_model_catalog_invalid');
+        }
+        return {
+            ...value,
+            tool_mode: null,
+            use_responses_lite: false,
+            apply_patch_tool_type: null,
+            // v1 keeps delegated turns portable through the model proxy's provider conversion.
+            multi_agent_version: 'v1',
+            supports_search_tool: false,
+            experimental_supported_tools: [],
+        };
+    });
+    return { ...catalog, models };
+}
+/** The installed binary supplies its own schema; unsupported binaries fail before inference. */
+export async function writePortableCodexCatalog(input) {
+    const command = input.command || process.env.PLAYCRAFT_CODEX_BIN || 'codex';
+    const prefix = input.args ?? [];
+    let body;
+    let version;
+    try {
+        const bundled = await exec(command, [...prefix, 'debug', 'models', '--bundled'], {
+            encoding: 'utf8',
+            timeout: 10_000,
+            maxBuffer: 16 * 1024 * 1024,
+        });
+        const metadata = await exec(command, [...prefix, '--version'], {
+            encoding: 'utf8',
+            timeout: 10_000,
+            maxBuffer: 64 * 1024,
+        });
+        version = metadata.stdout.trim();
+        body = JSON.stringify(portableCodexCatalog(JSON.parse(bundled.stdout)));
+    }
+    catch {
+        // Continuing with an unverified catalog can silently remove every coding tool.
+        throw new Error('codex_model_catalog_unavailable');
+    }
+    await mkdir(input.directory, { recursive: true });
+    const path = join(input.directory, 'portable-models.json');
+    await writeFile(path, body, { encoding: 'utf8', mode: 0o644 });
+    await writeFile(join(input.directory, 'portable-models.version.json'), JSON.stringify({
+        version,
+        sha256: createHash('sha256').update(body).digest('hex'),
+    }), { encoding: 'utf8', mode: 0o644 });
+    return path;
+}
+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"',
+        ...Object.entries(portableCodexConfig(input.catalogPath)).map(([key, value]) => `${key} = ${JSON.stringify(value)}`),
+        '',
+        '[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,145 @@
+import { EventEmitter } from 'node:events';
+export class NativeRpcResponseError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'NativeRpcResponseError';
+    }
+}
+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 turnStarts = 0;
+    let buffer = '';
+    let closed = false;
+    const onTransportError = () => {
+        for (const [id, waiter] of pending) {
+            clearTimeout(waiter.timer);
+            waiter.reject(new Error('jsonrpc_closed'));
+            pending.delete(id);
+        }
+    };
+    stdin.on('error', onTransportError);
+    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.method && 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 NativeRpcResponseError(message.error.message || 'jsonrpc_error', message.error.code));
+                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 || stdin.destroyed || stdin.writableEnded)
+            throw new Error('jsonrpc_closed');
+        stdin.write(`${JSON.stringify(payload)}\n`);
+    };
+    return {
+        notify(method, params) {
+            send({ method, params: params ?? {} });
+        },
+        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);
+                    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)));
+                }
+            });
+        },
+        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);
+        },
+        onServerRequest(listener) {
+            emitter.on('serverRequest', listener);
+            return () => emitter.off('serverRequest', listener);
+        },
+        respond(id, result) {
+            return new Promise((resolve, reject) => {
+                if (closed || stdin.destroyed || stdin.writableEnded) {
+                    reject(new Error('jsonrpc_closed'));
+                    return;
+                }
+                stdin.write(`${JSON.stringify({ id, result })}\n`, (error) => error ? reject(error) : resolve());
+            });
+        },
+        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/launcher-client.js

@@ -0,0 +1,177 @@
+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 exitCode;
+    let buffer = '';
+    let identity;
+    let stopPromise;
+    let finishTransport;
+    const transportClosed = new Promise(resolve => { finishTransport = resolve; });
+    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', exitCode);
+    }
+    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: input.terminal ? 'start-pty' : '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') {
+                        exitCode = typeof frame.code === 'number' ? frame.code : null;
+                        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();
+            finishTransport();
+        });
+    });
+    return {
+        pid,
+        stdin,
+        stdout,
+        stderr,
+        onExit(listener) {
+            if (exited)
+                queueMicrotask(() => listener(exitCode));
+            else
+                events.once('exit', listener);
+        },
+        resize(cols, rows) {
+            if (!input.terminal || exited)
+                return;
+            socket.write(`${JSON.stringify({ action: 'resize', cols, rows })}\n`);
+        },
+        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) {
+                            let timeout;
+                            try {
+                                await Promise.race([transportClosed, new Promise((_resolve, reject) => {
+                                        timeout = setTimeout(() => {
+                                            socket.destroy();
+                                            reject(new Error('launcher_output_drain_unconfirmed'));
+                                        }, 3000);
+                                    })]);
+                            }
+                            finally {
+                                clearTimeout(timeout);
+                            }
+                            return;
+                        }
+                        await delay(50);
+                    }
+                }
+                throw new Error('codex_group_stop_unconfirmed');
+            })();
+            return stopPromise;
+        },
+    };
+}

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

@@ -0,0 +1,146 @@
+import { projectNativeThread } from '@playcraft/common/cloud-workspace/runtime';
+import { collectedEvent } 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();
+    const collected = new Set();
+    const sent = new Set();
+    let turnStarts = 0;
+    function emit(event) {
+        for (const listener of collected)
+            listener(event);
+    }
+    return {
+        name: 'loopback',
+        ready: () => true,
+        onCollected(listener) {
+            collected.add(listener);
+            return () => collected.delete(listener);
+        },
+        turnStartSends() {
+            return turnStarts;
+        },
+        async startThread(input) {
+            const threadId = `thread_${input.sessionId}`;
+            threads.set(threadId, { sessionId: input.sessionId, items: [] });
+            return { threadId };
+        },
+        async resumeThread(input) {
+            return threads.get(input.threadId)?.sessionId === input.sessionId ? {} : undefined;
+        },
+        async startTurn(input) {
+            const thread = threads.get(input.threadId);
+            if (!thread || thread.sessionId !== input.sessionId)
+                return { outcome: 'failed', error: 'unknown_thread' };
+            const nativeRequestId = `loopback:${input.sessionId}:${input.clientRequestId}`;
+            const sentKey = `${input.sessionId}:${input.clientRequestId}`;
+            await input.persistReservation({ nativeRequestId });
+            if (input.simulateLostReceipt || sent.has(sentKey)) {
+                sent.add(sentKey);
+                return { outcome: 'uncertain', threadId: input.threadId };
+            }
+            sent.add(sentKey);
+            turnStarts += 1;
+            const turnId = `turn_${input.sessionId}_${input.clientRequestId}`;
+            thread.turnId = turnId;
+            thread.items.push({
+                type: 'userMessage',
+                id: `user_${turnId}`,
+                content: [{ type: 'text', text: input.text }],
+            });
+            if (!input.text.includes('[approval]')) {
+                thread.items.push({
+                    type: 'agentMessage',
+                    id: `agent_${turnId}`,
+                    text: `loopback:${input.text}`,
+                });
+            }
+            queueMicrotask(() => {
+                emit(collectedEvent('notification', 'item/agentMessage/delta', {
+                    threadId: input.threadId,
+                    turnId,
+                    text: `loopback:${input.text}`,
+                    delta: `loopback:${input.text}`,
+                }));
+                if (input.text.includes('[approval]')) {
+                    const approvalId = `approval_${input.clientRequestId}`;
+                    approvals.add(JSON.stringify([input.sessionId, approvalId]));
+                    emit(collectedEvent('approval_request', 'item/commandExecution/requestApproval', {
+                        threadId: input.threadId,
+                        turnId,
+                        approvalId,
+                        itemId: approvalId,
+                    }));
+                    return;
+                }
+                emit(collectedEvent('notification', 'turn/completed', {
+                    threadId: input.threadId,
+                    turnId,
+                    turn: { id: turnId, status: 'completed' },
+                }));
+            });
+            return { outcome: 'accepted', threadId: input.threadId, turnId };
+        },
+        async interrupt(input) {
+            const thread = threads.get(input.threadId);
+            if (!thread || thread.sessionId !== input.sessionId)
+                return { outcome: 'uncertain' };
+            const turnId = thread.turnId;
+            queueMicrotask(() => {
+                emit(collectedEvent('notification', 'turn/completed', {
+                    threadId: input.threadId,
+                    turnId,
+                    turn: { id: turnId, status: 'interrupted' },
+                }));
+            });
+            return { outcome: 'accepted', turnId };
+        },
+        async respondApproval(input) {
+            const key = JSON.stringify([input.sessionId, input.approvalId]);
+            const accepted = input.response?.kind === 'decision' ? input.response.accepted : input.response ? undefined : input.accepted;
+            if (typeof accepted !== 'boolean')
+                return { outcome: 'failed', approvalId: input.approvalId };
+            if (!approvals.has(key))
+                return { outcome: 'failed', approvalId: input.approvalId };
+            approvals.delete(key);
+            const thread = [...threads].find(([, value]) => value.sessionId === input.sessionId);
+            queueMicrotask(() => {
+                emit(collectedEvent('notification', 'approval.resolved', {
+                    approvalId: input.approvalId,
+                    accepted,
+                    threadId: thread?.[0],
+                    turnId: thread?.[1].turnId,
+                }));
+                emit(collectedEvent('notification', 'item/agentMessage/delta', {
+                    threadId: thread?.[0],
+                    turnId: thread?.[1].turnId,
+                    delta: 'after-approval',
+                }));
+                emit(collectedEvent('notification', 'turn/completed', {
+                    threadId: thread?.[0],
+                    turnId: thread?.[1].turnId,
+                    turn: { id: thread?.[1].turnId, status: 'completed' },
+                }));
+            });
+            const found = thread?.[1];
+            if (found) {
+                found.items.push({
+                    type: 'agentMessage',
+                    id: `agent_${found.turnId ?? input.approvalId}`,
+                    text: 'after-approval',
+                });
+            }
+            return { outcome: 'accepted', approvalId: input.approvalId, turnId: found?.turnId };
+        },
+        async readThread(input) {
+            const thread = threads.get(input.threadId);
+            if (!thread || thread.sessionId !== input.sessionId)
+                return undefined;
+            return projectNativeThread(input.threadId, {
+                id: input.threadId,
+                turns: [{ items: thread.items }],
+            });
+        },
+    };
+}

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

@@ -0,0 +1,39 @@
+import { createHash } from 'node:crypto';
+import { platformEndpoint, PLATFORM_ROUTES, workspaceMcpConfigSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { NativePreparationError } from './native-adapter.js';
+function canonical(value) {
+    if (Array.isArray(value))
+        return value.map(canonical);
+    if (value && typeof value === 'object')
+        return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right))
+            .map(([key, entry]) => [key, canonical(entry)]));
+    return value;
+}
+/** MCP (Model Context Protocol, 模型上下文协议) settings are scoped to one native thread. */
+export function nativeMcpConfig(value) {
+    const parsed = workspaceMcpConfigSchema.safeParse(value);
+    if (!parsed.success)
+        throw new NativePreparationError('workspace_mcp_unavailable');
+    return {
+        config: { mcp_servers: parsed.data.mcpServers },
+        hash: createHash('sha256').update(JSON.stringify(canonical(parsed.data))).digest('hex'),
+    };
+}
+/** Resolve current owner settings at every turn boundary without writing secrets to a checkout. */
+export async function loadWorkspaceMcpConfig(state, workspaceId) {
+    const config = state.config;
+    const runtimeEpoch = state.runtimeEpoch;
+    try {
+        const response = await fetch(platformEndpoint(config.publicBaseUrl, PLATFORM_ROUTES.workspaceMcp), {
+            method: 'POST', redirect: 'error', signal: AbortSignal.timeout(10_000),
+            headers: { authorization: `Bearer ${config.controlToken}`, 'content-type': 'application/json', 'playcraft-env': config.environment },
+            body: JSON.stringify({ runtimeId: config.runtimeId, generation: config.generation, runtimeEpoch, workspaceId }),
+        });
+        if (!response.ok || state.journal.destroyed() || state.runtimeEpoch !== runtimeEpoch)
+            throw new Error('workspace_mcp_unavailable');
+        return workspaceMcpConfigSchema.parse(await response.json());
+    }
+    catch {
+        throw new NativePreparationError('workspace_mcp_unavailable');
+    }
+}