@playcraft/cli 0.1.23 → 0.1.24

package/dist/workspace-runtime/codex/app-server.js

@@ -1,574 +0,0 @@
-import { spawn } from 'node:child_process';
-import { createHash, randomUUID } from 'node:crypto';
-import { startLauncherProcess } from './launcher-client.js';
-import { chmod, mkdtemp, rm } from 'node:fs/promises';
-import { relative, join } from 'node:path';
-import { tmpdir } from 'node:os';
-import { portableCodexConfig, writePortableCodexCatalog } from './config-toml.js';
-import { createJsonRpcStdioClient } from './jsonrpc-stdio.js';
-import { projectNativeThread } from '@playcraft/common/cloud-workspace/runtime';
-import { collectedEvent, NativePreparationError } from './native-adapter.js';
-import { readProjectSkillsLockFile } from '@playcraft/common/project-skills';
-import { freezeWorkspaceSkills } from '../workspaces/skills.js';
-function asRecord(value) {
-    return value && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : {};
-}
-function waitForChildExit(child) {
-    if (child.exitCode !== null || child.signalCode !== null)
-        return Promise.resolve();
-    return new Promise((resolve) => {
-        const done = () => {
-            clearTimeout(timer);
-            resolve();
-        };
-        const timer = setTimeout(() => {
-            if (child.exitCode === null && child.signalCode === null)
-                child.kill('SIGKILL');
-        }, 3_000);
-        child.once('exit', done);
-        if (child.exitCode !== null || child.signalCode !== null)
-            done();
-    });
-}
-function spawnCommand(bin) {
-    if (bin.endsWith('.mjs') || bin.endsWith('.js') || bin.endsWith('.ts')) {
-        return { command: process.execPath, prefix: [bin] };
-    }
-    return { command: bin, prefix: [] };
-}
-export function createCodexAppServerAdapter(options) {
-    const launcherSocket = options.launcherSocket || process.env.PLAYCRAFT_LAUNCHER_SOCKET;
-    const homeDir = options.homeDir || process.env.PLAYCRAFT_CODEX_HOME ||
-        (launcherSocket ? '/var/lib/playcraft/codex' : join(options.config.stateDir, 'codex-home'));
-    let executionEpoch = options.config.runtimeEpoch;
-    const model = options.model || process.env.PLAYCRAFT_CODEX_MODEL || 'gpt-4o';
-    const turnTimeoutMs = options.turnTimeoutMs ?? Number(process.env.PLAYCRAFT_CODEX_TURN_TIMEOUT_MS || 120_000);
-    const threads = new Map();
-    const approvals = new Map();
-    let child;
-    let rpc;
-    let readyFlag = false;
-    let closed = false;
-    let startPromise;
-    let catalogDirectory;
-    let skillsRestartFailed = false;
-    let preparationQueue = Promise.resolve();
-    let live;
-    const exitListeners = new Set();
-    const collected = new Set();
-    function emitCollected(event) {
-        for (const listener of collected)
-            listener(event);
-    }
-    async function withPreparation(action) {
-        const previous = preparationQueue;
-        let release;
-        preparationQueue = new Promise(resolve => { release = resolve; });
-        await previous;
-        try {
-            return await action();
-        }
-        finally {
-            release();
-        }
-    }
-    async function ensureStarted() {
-        if (closed)
-            throw new Error('codex_not_started');
-        if (skillsRestartFailed)
-            throw new NativePreparationError('workspace_skills_unavailable');
-        if (readyFlag && rpc)
-            return;
-        startPromise ??= start();
-        await startPromise;
-    }
-    async function threadConfig(cwd, modelConfigId, sessionId) {
-        try {
-            return await options.modelBroker?.prepareThreadConfig(cwd, modelConfigId, sessionId)
-                ?? { ...options.fixedThreadConfig, modelConfigId: undefined, activate: () => { } };
-        }
-        catch (error) {
-            const reason = error instanceof Error ? error.message : '';
-            throw new NativePreparationError(['model_config_required',
-                'model_credential_scope_mismatch', 'model_config_denied', 'workspace_not_registered'].includes(reason)
-                ? reason : 'model_credential_unavailable');
-        }
-    }
-    async function lockedThreadConfig(cwd, selectedConfigId, sessionId) {
-        const { modelConfigId, activate, ...modelConfig } = await threadConfig(cwd, selectedConfigId, sessionId);
-        // Single-workspace legacy runners retain their prior behaviour until explicitly adopted.
-        if (await readProjectSkillsLockFile(cwd) === null) {
-            const scope = relative(options.config.workspaceRoot, cwd);
-            const orchestration = /^[0-9a-f-]{36}$/i.test(scope);
-            if (options.config.workspaceMode === 'multi' && !orchestration)
-                throw new NativePreparationError('workspace_skills_unavailable');
-            return { params: modelConfig, modelConfigId, activate, skillsHash: undefined, discoveryHash: undefined };
-        }
-        try {
-            const frozen = await freezeWorkspaceSkills(cwd, join(options.config.stateDir, 'skill-artifacts'), options.loadSkillArtifact ? entry => options.loadSkillArtifact(cwd, entry) : undefined);
-            if (!rpc)
-                throw new Error('codex_not_started');
-            const found = await rpc.request('skills/list', { cwds: [cwd], forceReload: true }, 30_000);
-            const listing = found.data.find(item => item.cwd === cwd);
-            if (!listing || listing.errors.length)
-                throw new Error('workspace_skills_unavailable');
-            // Native scanning is used only to disable paths. Availability comes exclusively from the lock.
-            const config = { ...('config' in modelConfig ? modelConfig.config : {}),
-                'skills.include_instructions': false,
-                'skills.config': listing.skills.map(skill => ({ path: skill.path, enabled: false })) };
-            const developerInstructions = [
-                `Available workspace skills are fixed by lock ${frozen.declarationHash}.`,
-                'Use only the following locked skills. Read its SKILL.md when a skill applies, and resolve supporting files relative to that file. Disabled and unlisted skill directories are not available.',
-                ...frozen.skills.map(skill => JSON.stringify(skill)),
-                ...(frozen.skills.length ? [] : ['(No workspace skills are enabled.)']),
-            ].join('\n');
-            const discoveryHash = createHash('sha256').update(JSON.stringify(listing.skills.map(skill => skill.path).sort())).digest('hex');
-            return { params: { ...modelConfig, config, developerInstructions }, modelConfigId, activate, skillsHash: frozen.lockHash, discoveryHash };
-        }
-        catch {
-            throw new NativePreparationError('workspace_skills_unavailable');
-        }
-    }
-    async function restartForSkills(threadId, selectedConfigId) {
-        if ([...threads.values()].some(thread => thread.turnActive) || approvals.size)
-            throw new NativePreparationError('skills_reload_pending');
-        const previous = live;
-        if (previous)
-            previous.superseded = true;
-        readyFlag = false;
-        await previous?.rpc.close();
-        await previous?.child.stop();
-        if (closed)
-            throw new Error('codex_not_started');
-        rpc = undefined;
-        startPromise = undefined;
-        for (const thread of threads.values()) {
-            thread.loaded = false;
-            thread.needsRecreate = !thread.hasNativeHistory;
-        }
-        // A controlled idle restart retains the runtime epoch and all durable thread identities.
-        try {
-            startPromise = start();
-            await startPromise;
-            if (closed)
-                throw new Error('codex_not_started');
-            if (!live)
-                throw new NativePreparationError('workspace_skills_unavailable');
-            await options.onSkillProcessRestart?.({ pid: live.pid, startedAt: live.startedAt });
-            if (closed)
-                throw new Error('codex_not_started');
-            // Other workspaces resume lazily, so a damaged unrelated lock cannot block this workspace.
-            const thread = threads.get(threadId);
-            if (thread?.hasNativeHistory && thread.cwd)
-                await resumePreparedThread(threadId, thread, await lockedThreadConfig(thread.cwd, selectedConfigId ?? thread.modelConfigId, thread.sessionId));
-        }
-        catch {
-            readyFlag = false;
-            skillsRestartFailed = true;
-            if (live) {
-                live.superseded = true;
-                await live.rpc.close();
-                await live.child.stop();
-            }
-            throw new NativePreparationError('workspace_skills_unavailable');
-        }
-    }
-    async function resumePreparedThread(threadId, thread, prepared) {
-        const resumed = await rpc.request('thread/resume', {
-            threadId, cwd: thread.cwd, ...prepared.params,
-        }, 30_000);
-        if (resumed.thread?.id !== threadId)
-            throw new NativePreparationError('workspace_skills_unavailable');
-        thread.loaded = true;
-        thread.skillsHash = prepared.skillsHash;
-        thread.discoveryHash = prepared.discoveryHash;
-    }
-    async function start() {
-        if (closed)
-            throw new Error('codex_not_started');
-        await options.modelBroker?.start();
-        if (closed)
-            throw new Error('codex_not_started');
-        const bin = options.command || process.env.PLAYCRAFT_CODEX_BIN || (launcherSocket ? '/usr/local/bin/codex' : 'codex');
-        const { command, prefix } = spawnCommand(bin);
-        const launchArgs = [...prefix, ...(options.args ?? ['app-server'])];
-        const catalogArgs = launchArgs.at(-1) === 'app-server' ? launchArgs.slice(0, -1) : launchArgs;
-        let catalogPath;
-        try {
-            // Only public model metadata is shared with the development identity.
-            // A private, control-owned directory keeps it outside writable project files.
-            catalogDirectory ??= await mkdtemp(join(tmpdir(), 'playcraft-codex-catalog-'));
-            await chmod(catalogDirectory, 0o755);
-            catalogPath = await writePortableCodexCatalog({ directory: catalogDirectory, command, args: catalogArgs });
-        }
-        catch {
-            throw new NativePreparationError('codex_model_catalog_unavailable');
-        }
-        if (closed)
-            throw new Error('codex_not_started');
-        const args = [...prefix, ...(options.args ?? ['app-server'])];
-        if (launcherSocket) {
-            // Thread model access comes from the broker. These overrides carry no proxy address or token.
-            for (const [key, value] of Object.entries({
-                model,
-                approval_policy: 'never',
-                sandbox_mode: 'danger-full-access',
-                ...portableCodexConfig(catalogPath),
-            }))
-                args.push('-c', `${key}=${JSON.stringify(value)}`);
-            child = await startLauncherProcess({
-                socketPath: launcherSocket,
-                processId: `codex-${randomUUID()}`,
-                runtimeEpoch: executionEpoch,
-                argv: [command, ...args],
-                // The launcher admits the dev home, not the shared /workspaces root.
-                // Each thread supplies its registered workspace separately.
-                cwd: options.config.workspaceMode === 'multi' ? '/home/playcraft-dev' : options.config.workspaceRoot,
-                env: { CODEX_HOME: homeDir },
-            });
-        }
-        else {
-            if (closed)
-                throw new Error('codex_not_started');
-            const local = spawn(command, args, {
-                cwd: options.config.workspaceRoot,
-                env: { ...process.env, ...options.env, CODEX_HOME: homeDir, PLAYCRAFT_SKIP_UPDATE_CHECK: '1' },
-                stdio: ['pipe', 'pipe', 'pipe'],
-                detached: options.processGroup === true,
-            });
-            await new Promise((resolve, reject) => { local.once('spawn', resolve); local.once('error', reject); });
-            child = {
-                pid: local.pid, stdin: local.stdin, stdout: local.stdout, stderr: local.stderr,
-                onExit(listener) { local.once('exit', listener); },
-                async stop() {
-                    if (local.exitCode === null && local.signalCode === null) {
-                        if (options.processGroup && local.pid) {
-                            try {
-                                process.kill(-local.pid, 'SIGTERM');
-                            }
-                            catch { /* already stopped */ }
-                        }
-                        else
-                            local.kill('SIGTERM');
-                    }
-                    await waitForChildExit(local);
-                },
-            };
-        }
-        if (closed) {
-            await child.stop();
-            throw new Error('codex_not_started');
-        }
-        child.stderr?.on('data', (chunk) => {
-            process.stderr.write(chunk);
-        });
-        rpc = createJsonRpcStdioClient(child);
-        rpc.onNotification((method, params) => {
-            if (method === 'turn/completed') {
-                const record = asRecord(params), turnId = asRecord(record.turn).id;
-                const thread = typeof record.threadId === 'string' ? threads.get(record.threadId)
-                    : [...threads.values()].find(item => item.lastTurnId === turnId);
-                if (thread) {
-                    thread.turnActive = false;
-                    if (typeof turnId === 'string')
-                        thread.lastCompletedTurnId = turnId;
-                }
-            }
-            emitCollected(collectedEvent('notification', method, params));
-        });
-        rpc.onServerRequest((id, method, params) => {
-            const payload = asRecord(params);
-            const approvalId = String(payload.itemId ?? id);
-            const turnId = typeof payload.turnId === 'string' ? payload.turnId : '';
-            approvals.set(JSON.stringify([String(payload.threadId ?? ''), approvalId]), {
-                rpcId: id,
-                threadId: String(payload.threadId ?? ''),
-                turnId: turnId || undefined,
-            });
-            emitCollected(collectedEvent('approval_request', method, { ...payload, itemId: approvalId }));
-        });
-        const pid = child.pid;
-        if (!pid)
-            throw new Error('codex_pid_missing');
-        const current = {
-            child,
-            rpc,
-            pid,
-            startedAt: new Date().toISOString(),
-            superseded: false,
-        };
-        live = current;
-        child.onExit(() => {
-            void current.rpc.close();
-            if (live === current) {
-                readyFlag = false;
-                // Retain the old handle until its entire execution group is confirmed stopped.
-                rpc = undefined;
-                if (!current.superseded)
-                    emitCollected(collectedEvent('process_exit', 'process.exited', { pid: current.pid }));
-            }
-            if (!current.superseded && !closed) {
-                for (const listener of exitListeners)
-                    listener({ pid: current.pid });
-            }
-        });
-        try {
-            await rpc.request('initialize', {
-                clientInfo: {
-                    name: 'playcraft_workspace_runtime',
-                    title: 'PlayCraft Workspace Runtime',
-                    version: options.config.cliVersion,
-                },
-            });
-            if (closed)
-                throw new Error('codex_not_started');
-            rpc.notify('initialized', {});
-            readyFlag = true;
-        }
-        catch (error) {
-            current.superseded = true;
-            await current.rpc.close();
-            await current.child.stop();
-            throw error;
-        }
-    }
-    return {
-        name: 'codex-app-server',
-        ready: () => readyFlag && !closed,
-        executionProcess() {
-            if (!live)
-                return undefined;
-            return { pid: live.pid, startedAt: live.startedAt };
-        },
-        onUnexpectedExit(listener) {
-            exitListeners.add(listener);
-        },
-        onCollected(listener) {
-            collected.add(listener);
-            return () => collected.delete(listener);
-        },
-        turnStartSends() {
-            return rpc?.turnStartSends() ?? 0;
-        },
-        async replaceProcess() {
-            const previous = live;
-            if (previous)
-                previous.superseded = true;
-            readyFlag = false;
-            startPromise = undefined;
-            threads.clear();
-            approvals.clear();
-            await previous?.rpc.close().catch(() => undefined);
-            if (previous)
-                await previous.child.stop();
-            executionEpoch += 1;
-            skillsRestartFailed = false;
-            if (closed)
-                throw new Error('codex_not_started');
-            try {
-                startPromise = start();
-                await startPromise;
-            }
-            catch (error) {
-                startPromise = undefined;
-                throw error;
-            }
-            const next = live;
-            if (!next)
-                throw new Error('codex_not_started');
-            return { pid: next.pid, startedAt: next.startedAt };
-        },
-        async readThread(input) {
-            try {
-                await ensureStarted();
-                if (!rpc)
-                    return undefined;
-                const result = await rpc.request('thread/read', {
-                    threadId: input.threadId,
-                    includeTurns: true,
-                }, 30_000);
-                const projected = projectNativeThread(input.threadId, result.thread ?? result);
-                return projected;
-            }
-            catch {
-                return undefined;
-            }
-        },
-        async start() {
-            await ensureStarted();
-        },
-        async startThread(input) {
-            return withPreparation(async () => {
-                await ensureStarted();
-                if (!rpc)
-                    throw new Error('codex_not_started');
-                const prepared = await lockedThreadConfig(input.cwd, input.modelConfigId, input.sessionId);
-                const result = await rpc.request('thread/start', {
-                    cwd: input.cwd,
-                    model,
-                    ...prepared.params,
-                });
-                const threadId = result.thread?.id;
-                if (!threadId)
-                    throw new Error('native_receipt_lost');
-                prepared.activate();
-                threads.set(threadId, { sessionId: input.sessionId, cwd: input.cwd, skillsHash: prepared.skillsHash,
-                    discoveryHash: prepared.discoveryHash, modelConfigId: prepared.modelConfigId, hasNativeHistory: false, loaded: true });
-                return { threadId, modelConfigId: prepared.modelConfigId };
-            });
-        },
-        async resumeThread(input) {
-            return withPreparation(async () => {
-                await ensureStarted();
-                if (!rpc)
-                    throw new Error('codex_not_started');
-                const prepared = await lockedThreadConfig(input.cwd, input.modelConfigId, input.sessionId);
-                let resumedId;
-                try {
-                    const resumed = await rpc.request('thread/resume', {
-                        threadId: input.threadId, cwd: input.cwd, ...prepared.params,
-                    }, 30_000);
-                    resumedId = resumed.thread?.id;
-                }
-                catch {
-                    return undefined;
-                }
-                if (resumedId !== input.threadId)
-                    return undefined;
-                prepared.activate();
-                threads.set(input.threadId, { sessionId: input.sessionId, cwd: input.cwd, skillsHash: prepared.skillsHash,
-                    discoveryHash: prepared.discoveryHash, modelConfigId: prepared.modelConfigId, hasNativeHistory: true, loaded: true });
-                return { modelConfigId: prepared.modelConfigId };
-            });
-        },
-        async startTurn(input) {
-            return withPreparation(async () => {
-                await ensureStarted();
-                if (!rpc)
-                    throw new Error('codex_not_started');
-                if (threads.get(input.threadId)?.sessionId !== input.sessionId) {
-                    return { outcome: 'failed', error: 'unknown_thread' };
-                }
-                const thread = threads.get(input.threadId);
-                if (thread.turnActive)
-                    return { outcome: 'failed', error: 'turn_already_active' };
-                if (thread.needsRecreate)
-                    return { outcome: 'failed', error: 'workspace_skills_changed' };
-                let selectedModel;
-                let modelConfigId = thread.modelConfigId;
-                let activateModel = () => { };
-                if (thread.cwd) {
-                    try {
-                        const prepared = await lockedThreadConfig(thread.cwd, input.modelConfigId ?? thread.modelConfigId, input.sessionId);
-                        selectedModel = 'model' in prepared.params ? prepared.params.model : undefined;
-                        modelConfigId = prepared.modelConfigId;
-                        activateModel = prepared.activate;
-                        // Codex does not persist an empty thread rollout until its first turn.
-                        if (thread.skillsHash && !thread.hasNativeHistory) {
-                            if (prepared.skillsHash !== thread.skillsHash || prepared.discoveryHash !== thread.discoveryHash)
-                                return { outcome: 'failed', error: 'workspace_skills_changed' };
-                        }
-                        else if (thread.skillsHash && (prepared.skillsHash !== thread.skillsHash || prepared.discoveryHash !== thread.discoveryHash)) {
-                            await restartForSkills(input.threadId, prepared.modelConfigId);
-                        }
-                        if (!thread.loaded)
-                            await resumePreparedThread(input.threadId, thread, prepared);
-                        thread.skillsHash = prepared.skillsHash;
-                        thread.discoveryHash = prepared.discoveryHash;
-                    }
-                    catch (error) {
-                        return { outcome: 'failed', error: error instanceof NativePreparationError ? error.message : 'workspace_skills_unavailable' };
-                    }
-                }
-                const requestId = rpc.reserveRequest();
-                await input.persistReservation({ nativeRequestId: String(requestId), modelConfigId });
-                activateModel();
-                thread.modelConfigId = modelConfigId;
-                if (input.simulateLostReceipt)
-                    return { outcome: 'uncertain', threadId: input.threadId };
-                try {
-                    thread.turnActive = true;
-                    const started = await rpc.sendReserved(requestId, 'turn/start', { threadId: input.threadId, input: [
-                            { type: 'text', text: input.text },
-                            ...(input.images ?? []).map((path) => ({ type: 'localImage', path })),
-                        ], ...(selectedModel ? { model: selectedModel } : {}) }, turnTimeoutMs);
-                    const turnId = started.turn?.id;
-                    if (!turnId)
-                        return { outcome: 'uncertain', threadId: input.threadId };
-                    const acceptedThread = threads.get(input.threadId);
-                    if (acceptedThread) {
-                        acceptedThread.lastTurnId = turnId;
-                        acceptedThread.hasNativeHistory = true;
-                        acceptedThread.modelConfigId = modelConfigId;
-                        acceptedThread.turnActive = acceptedThread.lastCompletedTurnId !== turnId;
-                    }
-                    return { outcome: 'accepted', threadId: input.threadId, turnId, modelConfigId };
-                }
-                catch {
-                    return { outcome: 'uncertain', threadId: input.threadId };
-                }
-            });
-        },
-        async interrupt(input) {
-            await ensureStarted();
-            const thread = threads.get(input.threadId);
-            // Nothing is sent when no turn of this session runs here, so that answer is definite.
-            if (thread?.sessionId !== input.sessionId || !thread.turnActive)
-                return { outcome: 'failed', error: 'turn_not_running' };
-            if (!rpc)
-                return { outcome: 'uncertain' };
-            const turnId = thread.lastTurnId;
-            // A turn that is still starting has no id yet; the last one is already over.
-            if (!turnId || turnId === thread.lastCompletedTurnId)
-                return { outcome: 'uncertain' };
-            try {
-                await rpc.request('turn/interrupt', { threadId: input.threadId, turnId });
-                const cwd = threads.get(input.threadId)?.cwd;
-                if (cwd)
-                    options.modelBroker?.cancelSession(cwd, input.sessionId);
-            }
-            catch {
-                return { outcome: 'uncertain', turnId };
-            }
-            return { outcome: 'accepted', turnId };
-        },
-        async respondApproval(input) {
-            if (!rpc)
-                return { outcome: 'failed', approvalId: input.approvalId };
-            const threadId = [...threads].find(([, thread]) => thread.sessionId === input.sessionId)?.[0];
-            const key = JSON.stringify([threadId, input.approvalId]);
-            const pending = approvals.get(key);
-            if (!pending)
-                return { outcome: 'failed', approvalId: input.approvalId };
-            approvals.delete(key);
-            rpc.respond(pending.rpcId, { decision: input.accepted ? 'accept' : 'decline' });
-            emitCollected(collectedEvent('notification', 'approval.resolved', {
-                approvalId: input.approvalId,
-                accepted: input.accepted,
-                threadId,
-                turnId: pending.turnId,
-            }));
-            return { outcome: 'accepted', approvalId: input.approvalId, turnId: pending.turnId };
-        },
-        async close() {
-            if (closed)
-                return;
-            closed = true;
-            readyFlag = false;
-            if (live)
-                live.superseded = true;
-            const current = child;
-            await rpc?.close().catch(() => undefined);
-            rpc = undefined;
-            if (current)
-                await current.stop();
-            child = undefined;
-            live = undefined;
-            await options.modelBroker?.close();
-            if (catalogDirectory)
-                await rm(catalogDirectory, { recursive: true, force: true });
-        },
-    };
-}

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

@@ -1,108 +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': false,
-        '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,
-            multi_agent_version: null,
-            supports_search_tool: false,
-            experimental_supported_tools: [],
-            default_reasoning_level: null,
-            supported_reasoning_levels: [],
-        };
-    });
-    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;
-}