@playcraft/cli 0.1.51 → 0.1.53-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/delivery-tools.js

@@ -0,0 +1,144 @@
+import { randomUUID } from 'node:crypto';
+import { DELIVERY_CHANNELS, deliveryFormatSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { rejectTool, toolContent } from './tool-response.js';
+export const WORKSPACE_DELIVERY_TOOLS = [
+    {
+        type: 'function',
+        name: 'playcraft_build_delivery',
+        description: 'Start one formal channel delivery build. Returns build identifiers immediately; poll playcraft_get_delivery for status and validation results. This writes a delivery record under dist/delivery/.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                channels: {
+                    type: 'array',
+                    items: { type: 'string', enum: DELIVERY_CHANNELS },
+                    minItems: 1,
+                    maxItems: 8,
+                    uniqueItems: true,
+                },
+                format: { type: 'string', enum: ['html', 'zip'] },
+            },
+            additionalProperties: false,
+        },
+    },
+    {
+        type: 'function',
+        name: 'playcraft_get_delivery',
+        description: 'Read the latest delivery build, or one build by id, including status, validation summary, error and a truncated build log.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                buildId: { type: 'string' },
+                channel: { type: 'string', enum: DELIVERY_CHANNELS },
+            },
+            additionalProperties: false,
+        },
+    },
+];
+const DELIVERY_TOOL_NAMES = new Set(WORKSPACE_DELIVERY_TOOLS.map(tool => tool.name));
+export function isWorkspaceDeliveryTool(name) {
+    return typeof name === 'string' && DELIVERY_TOOL_NAMES.has(name);
+}
+export class WorkspaceDeliveryTools {
+    handlers;
+    constructor(handlers) {
+        this.handlers = handlers;
+    }
+    async request(requestId, payload, client, context) {
+        const tool = typeof payload.tool === 'string' ? payload.tool : '';
+        const args = payload.arguments;
+        if (!args || typeof args !== 'object' || Array.isArray(args)) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
+        if (!context.sessionId || (!context.cwd && !context.workspaceId)) {
+            await this.reject(client, requestId, 'feature_unavailable');
+            return;
+        }
+        if (context.directoryName === 'root') {
+            await this.reject(client, requestId, 'invalid_workspace_directory');
+            return;
+        }
+        const input = args;
+        if (tool === 'playcraft_build_delivery')
+            return this.build(requestId, payload, input, client, context);
+        if (tool === 'playcraft_get_delivery')
+            return this.get(requestId, input, client, context);
+        await this.reject(client, requestId, 'unknown_delivery_tool');
+    }
+    async build(requestId, payload, input, client, context) {
+        if (context.readOnly) {
+            await this.reject(client, requestId, 'permission_denied');
+            return;
+        }
+        const unknown = Object.keys(input).filter(key => key !== 'channels' && key !== 'format');
+        if (unknown.length) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
+        const channels = input.channels === undefined ? ['playcraft'] : input.channels;
+        if (!Array.isArray(channels) || channels.length < 1 || channels.length > 8
+            || channels.some(channel => !DELIVERY_CHANNELS.includes(channel))
+            || new Set(channels).size !== channels.length) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
+        const format = input.format === undefined ? undefined : deliveryFormatSchema.safeParse(input.format);
+        if (format && !format.success) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
+        try {
+            const result = await this.handlers.build({
+                ...context,
+                clientRequestId: typeof payload.callId === 'string' && payload.callId.length
+                    ? payload.callId
+                    : randomUUID(),
+                channels: channels,
+                ...(format && format.success ? { format: format.data } : {}),
+            });
+            await this.respond(client, requestId, result);
+        }
+        catch (cause) {
+            await this.reject(client, requestId, errorReason(cause));
+        }
+    }
+    async get(requestId, input, client, context) {
+        const unknown = Object.keys(input).filter(key => key !== 'buildId' && key !== 'channel');
+        if (unknown.length) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
+        if (input.buildId !== undefined && (typeof input.buildId !== 'string'
+            || !/^[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/i.test(input.buildId))) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
+        if (input.channel !== undefined && !DELIVERY_CHANNELS.includes(input.channel)) {
+            await this.reject(client, requestId, 'invalid_delivery_tool_arguments');
+            return;
+        }
+        try {
+            const result = await this.handlers.get({
+                ...context,
+                ...(typeof input.buildId === 'string' ? { buildId: input.buildId } : {}),
+                ...(typeof input.channel === 'string' ? { channel: input.channel } : {}),
+            });
+            await this.respond(client, requestId, result);
+        }
+        catch (cause) {
+            await this.reject(client, requestId, errorReason(cause));
+        }
+    }
+    async respond(client, requestId, value) {
+        await client.respond(requestId, { success: true, contentItems: toolContent(value) }).catch(() => undefined);
+    }
+    async reject(client, requestId, reason) {
+        await rejectTool(client, requestId, reason);
+    }
+}
+function errorReason(cause) {
+    if (cause instanceof Error && 'code' in cause && typeof cause.code === 'string')
+        return cause.code;
+    return 'delivery_tool_failed';
+}

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