@playcraft/cli 0.1.38-beta → 0.1.39-prod

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

@@ -1,46 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,145 +0,0 @@
-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

@@ -1,177 +0,0 @@
-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

@@ -1,146 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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');
-    }
-}