@playcraft/cli 0.1.50-beta → 0.1.52

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/delivery-tools.js

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

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