@playcraft/cli 0.1.34 → 0.1.36-beta1

package/dist/workspace-runtime/production/stages.js

@@ -1,205 +0,0 @@
-import { execFile } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import { lstat, mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { promisify } from 'node:util';
-import { batchBaselineSnapshotSchema } from '@playcraft/common/cloud-workspace/runtime';
-import { checkoutBatchCommit, freezeBatchCommit } from '../workspaces/batch-commit.js';
-import { grantWorkspaceTraversal, openDirectoryToDevelopment } from '../workspaces/directory-access.js';
-import { registerWorkspaceDirectory } from '../workspaces/directories.js';
-import { workspaceContainerRoot, workspaceRoot, workspaceSessions } from '../workspaces/registry.js';
-import { excludeFromGit, settleDependencyInstalls } from '../workspaces/dependencies.js';
-import { resolveProductionDependencies, verifyProductionDependencyLocks } from './dependencies.js';
-import { productionLocalCommitCommand } from './save-command.js';
-import { productionOutputStore, verifyProductionLease } from './storage.js';
-import { runProductionCommand } from './processes.js';
-import { runProductionNative } from './native.js';
-import { classifyPreviewOutput, findExternalLocalReferences } from '../previews/single-file.js';
-import { copyProductionSource } from './source-copy.js';
-import { workspaceDirectoryOccupied } from '../workspaces/directory-maintenance.js';
-import { ensureWorkspaceSkills } from '../workspaces/skills.js';
-const execute = promisify(execFile);
-const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
-const hash = (body) => createHash('sha256').update(body).digest('hex');
-const record = (value) => value && typeof value === 'object' ? value : {};
-export async function executeProductionStage(state, input, processRecord, track) {
-    await verifyProductionLease(input);
-    const store = productionOutputStore(input);
-    const stage = input.stage;
-    const workspaceId = input.task.workspaceId;
-    const resultId = String(input.payload.resultVersionId ?? input.task.payload.resultVersionId ?? input.task.attemptId);
-    const sourceDirectoryName = String(input.payload.sourceDirectoryName ?? input.task.payload.sourceDirectoryName ?? 'basic');
-    if (input.task.payload.sourceDirectoryName !== undefined && input.payload.sourceDirectoryName !== undefined
-        && input.task.payload.sourceDirectoryName !== input.payload.sourceDirectoryName)
-        throw new Error('production_source_directory_mismatch');
-    const previous = (name) => input.stages?.find(value => value.stage === name && value.status === 'completed')?.result;
-    const run = async (cwd, command, env, trusted = false) => {
-        const outcome = await runProductionCommand(state, { processId: `production-${input.task.attemptId}-${stage}`, cwd, command, env, trusted,
-            timeoutMs: 10 * 60_000, record: processRecord });
-        if (!outcome.stopped || outcome.code === undefined)
-            throw new Error('production_process_unknown');
-        if (outcome.code !== 0)
-            throw new Error(`production_${stage}_failed`);
-        return outcome.output;
-    };
-    const git = async (root, ...args) => (await execute('git', ['-c', 'core.hooksPath=/dev/null', '-c', 'core.fsmonitor=false', '-C', root, ...args], {
-        timeout: 20_000, maxBuffer: 1024 * 1024, env: { PATH: process.env.PATH, HOME: state.config.stateDir, GIT_CONFIG_GLOBAL: '/dev/null', GIT_CONFIG_NOSYSTEM: '1' },
-    })).stdout.trim();
-    if (stage === 'capture-source') {
-        if (input.directoryName === 'basic' || input.directoryName === sourceDirectoryName)
-            throw new Error('production_source_directory_mismatch');
-        const authority = record(input.payload.workspace);
-        if (authority.directoryName !== input.directoryName || authority.workspaceId !== workspaceId
-            || typeof authority.remixId !== 'string' || typeof authority.branchName !== 'string' || typeof authority.repositoryUrl !== 'string')
-            throw new Error('production_source_directory_mismatch');
-        const { remixId, branchName, repositoryUrl } = authority;
-        await settleDependencyInstalls(state);
-        return state.journal.exclusive(`directory:${workspaceId}:${sourceDirectoryName}`, async () => {
-            if (await workspaceDirectoryOccupied(state, workspaceId, sourceDirectoryName)
-                || workspaceSessions(state, workspaceId, sourceDirectoryName).some(session => session.turnBlock === 'uncertain' || ['starting', 'running', 'waiting_for_user'].includes(session.turnStatus ?? '')))
-                throw new Error('production_source_busy');
-            const source = await workspaceRoot(state, workspaceId, sourceDirectoryName);
-            const container = await workspaceContainerRoot(state, workspaceId);
-            const destination = join(container, input.directoryName);
-            const developmentGroup = (await lstat(state.config.workspaceRoot)).gid;
-            const snapshot = await copyProductionSource({ source, destination, branchName, repositoryUrl });
-            await ensureWorkspaceSkills(destination, join(state.config.stateDir, 'skill-artifacts'));
-            await openDirectoryToDevelopment(destination, developmentGroup);
-            await grantWorkspaceTraversal(container, developmentGroup);
-            await state.journal.exclusive(`workspace:${workspaceId}`, async () => {
-                const binding = state.journal.getWorkspace(workspaceId);
-                await state.journal.putWorkspace({ ...binding, directories: [...(binding.directories ?? []).filter(value => value.directoryName !== input.directoryName),
-                        { workspaceId, directoryName: input.directoryName, remixId, branchName, sourceCommit: snapshot.commitHash, status: 'ready' }] });
-            });
-            return { sourceSnapshot: snapshot, commitHash: snapshot.commitHash };
-        });
-    }
-    if (stage === 'prepare' && input.directoryName !== 'basic' && (input.payload.baseline ?? input.task.payload.baseline)) {
-        const baseline = record(input.payload.baseline ?? input.task.payload.baseline);
-        const authority = record(input.payload.workspace);
-        const sourceCommit = baseline.commitHash;
-        if (typeof sourceCommit !== 'string')
-            throw new Error('production_approved_commit_required');
-        const directory = { workspaceId, directoryName: input.directoryName,
-            remixId: String(authority.remixId), branchName: String(authority.branchName), sourceCommit };
-        await registerWorkspaceDirectory(state, directory, state.acceptedLeaseFence, sourceDirectoryName);
-    }
-    const root = await workspaceRoot(state, workspaceId, input.directoryName);
-    if (stage === 'prepare') {
-        await settleDependencyInstalls(state);
-        if (!(await lstat(join(root, 'package.json')).catch(() => undefined)))
-            return { prepared: true, directoryName: input.directoryName, emptySource: true };
-        const policy = await resolveProductionDependencies(root).catch(error => {
-            if (!(input.payload.baseline ?? input.task.payload.baseline) && error instanceof Error
-                && error.message === 'production_dependency_lock_required')
-                return undefined;
-            throw error;
-        });
-        if (!policy)
-            return { prepared: true, directoryName: input.directoryName, dependencyRepairRequired: true };
-        await run(root, process.env.PLAYCRAFT_PRODUCTION_INSTALL_COMMAND ?? 'pnpm install --frozen-lockfile --store-dir /var/cache/playcraft/pnpm-store --ignore-scripts');
-        await verifyProductionDependencyLocks(root, policy);
-        return { prepared: true, directoryName: input.directoryName };
-    }
-    if (stage === 'generate') {
-        await runProductionNative(state, input, root, processRecord, track);
-        await resolveProductionDependencies(root);
-        return { generated: true };
-    }
-    if (stage === 'save') {
-        const binding = state.journal.getWorkspace(workspaceId);
-        const branch = input.directoryName === 'basic' ? binding.branchName : binding.directories?.find(value => value.directoryName === input.directoryName)?.branchName;
-        if ((input.git && input.git.branchName !== branch) || await git(root, 'symbolic-ref', '--short', 'HEAD') !== branch)
-            throw new Error('production_git_binding_mismatch');
-        await run(root, 'chmod -R u+rwX,g+rwX .').catch(() => undefined);
-        await excludeFromGit(root);
-        await excludeFromGit(root, '/.env*');
-        await excludeFromGit(root, '/.playcraft-temp/');
-        await excludeFromGit(root, '/.playcraft-preview-out/');
-        await git(root, 'config', 'user.name', 'PlayCraft');
-        await git(root, 'config', 'user.email', 'playcraft@localhost');
-        const env = { GIT_TERMINAL_PROMPT: '0', GIT_CONFIG_GLOBAL: '/dev/null', GIT_CONFIG_NOSYSTEM: '1' };
-        await run(root, productionLocalCommitCommand(), env, true);
-        const commitHash = await git(root, 'rev-parse', 'HEAD');
-        const snapshot = await freezeBatchCommit({ source: { workspaceId, root }, commitHash, snapshotId: `${input.task.attemptId}-save` });
-        return { snapshot, saved: { attemptId: input.task.attemptId, resultVersionId: resultId, workspaceId, sourceDigest: snapshot.checksum, commitHash, pushedCommitHash: commitHash } };
-    }
-    if (stage === 'freeze') {
-        const saved = record(previous('save')?.saved);
-        if (typeof saved.commitHash !== 'string')
-            throw new Error('production_saved_commit_required');
-        const snapshot = await freezeBatchCommit({ source: { workspaceId, root }, commitHash: saved.commitHash, snapshotId: `${input.task.attemptId}-freeze` });
-        const baseline = batchBaselineSnapshotSchema.parse({ batchId: input.task.batchId, projectId: String(input.payload.projectId ?? input.task.payload.projectId),
-            snapshotId: snapshot.snapshotId, sourceWorkspaceId: snapshot.sourceWorkspaceId, commitHash: snapshot.commitHash, checksum: snapshot.checksum,
-            sourceVersion: snapshot.sourceVersion, engine: String(input.payload.engine ?? input.task.payload.engine), skillLockDigest: snapshot.skillLockDigest, frozenAt: snapshot.frozenAt });
-        return { snapshot, baseline };
-    }
-    if (stage === 'build') {
-        const saved = record(input.payload.saved ?? previous('save')?.saved);
-        const snapshot = (previous('freeze')?.snapshot ?? previous('save')?.snapshot);
-        if (!snapshot || snapshot.commitHash !== saved.commitHash || snapshot.checksum !== saved.sourceDigest)
-            throw new Error('production_saved_snapshot_mismatch');
-        const destination = join(root, '.playcraft-temp', `production-${input.task.attemptId}`);
-        const removeDestination = async () => {
-            try {
-                await rm(destination, { recursive: true, force: true });
-            }
-            catch {
-                await run(destination, 'chmod -R u+rwX,g+rwX .').catch(() => undefined);
-                await rm(destination, { recursive: true, force: true });
-            }
-        };
-        await excludeFromGit(root, '/.playcraft-temp/');
-        await removeDestination();
-        try {
-            await checkoutBatchCommit({ source: { workspaceId, root }, frozen: snapshot, destination });
-            await openDirectoryToDevelopment(destination, (await lstat(state.config.workspaceRoot)).gid);
-            const policy = await resolveProductionDependencies(destination);
-            await run(destination, process.env.PLAYCRAFT_PRODUCTION_INSTALL_COMMAND ?? 'pnpm install --frozen-lockfile --store-dir /var/cache/playcraft/pnpm-store --ignore-scripts');
-            await verifyProductionDependencyLocks(destination, policy);
-            const output = join(destination, '.production-html');
-            const command = process.env.PLAYCRAFT_PRODUCTION_BUILD_COMMAND ?? 'playcraft build --mode full --platform playcraft --format html';
-            await run(destination, `${command} --output ${quote(output)} .`);
-            await verifyProductionDependencyLocks(destination, policy);
-            const entries = await readdir(output, { withFileTypes: true });
-            const single = classifyPreviewOutput(entries.map(entry => ({ name: entry.name, kind: entry.isFile() ? 'file' : entry.isDirectory() ? 'dir' : 'symlink' })));
-            if (!single.ok)
-                throw new Error('production_preview_not_single_file');
-            const path = join(output, single.entry);
-            if (!(await lstat(path)).isFile())
-                throw new Error('production_preview_invalid');
-            const body = await readFile(path);
-            if (findExternalLocalReferences(body.toString()).length)
-                throw new Error('production_preview_external_reference');
-            const outputDigest = hash(body), outputKey = `workspaces/${workspaceId}/production/${input.task.attemptId}/${outputDigest}.html`;
-            await store.put(outputKey, body);
-            return { outputKey, outputDigest, build: { attemptId: input.task.attemptId, resultVersionId: resultId, workspaceId,
-                    sourceDigest: snapshot.checksum, commitHash: snapshot.commitHash, buildId: `${input.task.attemptId}-build`, succeeded: true } };
-        }
-        finally {
-            await removeDestination();
-        }
-    }
-    if (stage === 'preview') {
-        const built = previous('build');
-        if (typeof built?.outputKey !== 'string' || typeof built.outputDigest !== 'string')
-            throw new Error('production_build_required');
-        const body = await store.get(built.outputKey);
-        if (hash(body) !== built.outputDigest)
-            throw new Error('production_preview_digest_mismatch');
-        const previewPath = join(root, '.playcraft-temp', `${input.task.attemptId}.html`);
-        await mkdir(dirname(previewPath), { recursive: true });
-        await writeFile(previewPath, body);
-        try {
-            const browser = process.env.PLAYCRAFT_PRODUCTION_PREVIEW_COMMAND ?? 'chromium --headless --no-sandbox --disable-gpu --virtual-time-budget=1000 --dump-dom';
-            const opened = await run(root, `${browser} ${quote(`file://${previewPath}`)}`);
-            if (!/<\/?html[\s>]/i.test(opened))
-                throw new Error('production_preview_not_opened');
-            return { opened: true, outputDigest: built.outputDigest };
-        }
-        finally {
-            await rm(previewPath, { force: true });
-        }
-    }
-    throw new Error('invalid_production_stage');
-}

package/dist/workspace-runtime/production/storage.js

@@ -1,60 +0,0 @@
-const taskUrl = (input) => `${input.callbackUrl.replace(/\/+$/, '')}/internal/cloud-production/tasks/${input.task.taskId}`;
-/** Build output travels through the Runtime that leased the task; engineering files travel through Git. */
-export function productionOutputStore(input) {
-    const object = (key) => `${taskUrl(input)}/objects/${encodeURIComponent(key)}`;
-    const headers = { authorization: `Bearer ${input.runnerToken}`, 'x-playcraft-object-client': 'cli' };
-    return {
-        async get(key) {
-            const response = await fetch(object(key), { headers, redirect: 'error', signal: AbortSignal.timeout(60_000) });
-            if (response.status === 404)
-                throw new Error('object_missing');
-            if (!response.ok)
-                throw new Error('object_get_failed');
-            return Buffer.from(await response.arrayBuffer());
-        },
-        async put(key, body) {
-            const response = await fetch(object(key), { method: 'PUT', body: new Uint8Array(body), redirect: 'error', signal: AbortSignal.timeout(60_000),
-                headers: { ...headers, 'content-type': 'application/octet-stream' } });
-            if (!response.ok)
-                throw new Error(response.status === 409 ? 'object_conflict' : 'object_put_failed');
-        },
-    };
-}
-export async function verifyProductionLease(input) {
-    let status;
-    let reason;
-    try {
-        const response = await fetch(`${taskUrl(input)}/runner`, {
-            headers: { authorization: `Bearer ${input.runnerToken}` }, redirect: 'error', signal: AbortSignal.timeout(10_000),
-        });
-        status = response.status;
-        if (!response.ok) {
-            const value = await response.json().catch(() => undefined);
-            const body = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-            reason = [body.reason, body.code, body.message, body.error]
-                .find((value) => typeof value === 'string' && /^[a-z0-9_]{1,128}$/.test(value)
-                && !value.includes(input.runnerToken));
-            throw new Error('production_lease_unavailable');
-        }
-        reason = 'production_lease_invalid_response';
-        const { task } = await response.json();
-        if (!task || task.taskId !== input.task.taskId || task.attemptId !== input.task.attemptId || task.leaseOwner !== input.lease.owner || task.leaseFence !== input.lease.fence || task.status !== 'running' || task.cancelRequested) {
-            reason = 'production_lease_mismatch';
-            throw new Error('production_lease_unavailable');
-        }
-    }
-    catch (error) {
-        const cause = error instanceof Error ? error.cause : undefined;
-        const causeCode = cause && typeof cause === 'object' && 'code' in cause && typeof cause.code === 'string'
-            && /^[A-Za-z0-9_]{1,64}$/.test(cause.code) ? cause.code : undefined;
-        // Callback diagnostics retain machine codes only; responses and credentials stay private.
-        try {
-            console.error(JSON.stringify({ event: 'production.lease_verification_failed', taskId: input.task.taskId,
-                attemptId: input.task.attemptId, workspaceId: input.task.workspaceId, directoryName: input.directoryName,
-                stage: input.stage, leaseFence: input.lease.fence, status, reason,
-                errorType: error instanceof Error && /^[A-Za-z0-9_]{1,64}$/.test(error.name) ? error.name : 'UnknownError', causeCode }));
-        }
-        catch { /* Diagnostics must preserve the original failure. */ }
-        throw error;
-    }
-}

package/dist/workspace-runtime/serve.js

@@ -1,207 +0,0 @@
-import { closeCliCredentials } from './workspaces/cli-credentials.js';
-import { randomUUID } from 'node:crypto';
-import { mkdir } from 'node:fs/promises';
-import { createServer } from 'node:http';
-import { INCOMPATIBLE_EXIT_CODE, negotiateProtocol, } from '@playcraft/common/cloud-workspace/runtime';
-import { RuntimeJournal } from './persistence/journal.js';
-import { createCodexAppServerAdapter } from './codex/app-server.js';
-import { createLoopbackNativeAdapter } from './codex/loopback.js';
-import { attachNativeCollector } from './server/dispatch.js';
-import { handleRuntimeRequest } from './server/http.js';
-import { desktopHost, disposeDesktopHost } from './server/desktop-host.js';
-import { disposeTerminalHost, terminalHost } from './server/terminal-host.js';
-import { handleExecutionGroupCrash } from './server/execution-group.js';
-import { RuntimeProcessLock } from './server/lock.js';
-import { probeGitBinary } from './workspaces/git.js';
-import { WorkspaceGitCredentialBroker } from './workspaces/git-credential-broker.js';
-import { WorkspaceModelBroker } from './codex/model-broker.js';
-import { recoverInterruptedPreviews } from './previews/publish.js';
-import { recoverInterruptedInstalls } from './workspaces/dependencies.js';
-import { loadWorkspaceSkillArtifact } from './workspaces/skill-artifact-loader.js';
-import { workspaceContextFromRoot } from './workspaces/registry.js';
-import { observeWorkspaceArtifacts } from './workspaces/artifact-events.js';
-import { loadWorkspaceMcpConfig } from './codex/mcp-config.js';
-export async function startWorkspaceRuntime(config, options = {}) {
-    process.env.PLAYCRAFT_SKIP_UPDATE_CHECK = '1';
-    const negotiated = negotiateProtocol(config);
-    if (!negotiated.ok) {
-        const error = Object.assign(new Error('protocol_incompatible'), {
-            code: 'protocol_incompatible',
-            exitCode: INCOMPATIBLE_EXIT_CODE,
-        });
-        throw error;
-    }
-    const lock = new RuntimeProcessLock(config.stateDir);
-    lock.acquire();
-    let journal;
-    let gitCredentials;
-    try {
-        journal = new RuntimeJournal(config.stateDir);
-        await journal.load();
-        const previousEpoch = journal.storedRuntimeEpoch();
-        const previousGroup = journal.executionGroup();
-        const previousIdentityMatches = journal.epochsSnapshot().some((epoch) => epoch.runtime_id === config.runtimeId && epoch.generation === config.generation && epoch.runtime_epoch === previousEpoch);
-        await recoverInterruptedInstalls(journal);
-        await recoverInterruptedPreviews(journal);
-        await mkdir(config.workspaceRoot, { recursive: true, mode: 0o700 });
-        const state = {
-            config: { ...config, protocolMinor: negotiated.protocolMinor },
-            configPath: options.configPath,
-            journal,
-            acceptedLeaseFence: journal.acceptedLeaseFence(),
-            gitAvailable: await probeGitBinary(),
-            native: options.nativeAdapter,
-            runtimeEpoch: Math.max(config.runtimeEpoch, journal.storedRuntimeEpoch() ?? 0),
-            executionQueue: Promise.resolve(),
-            instanceToken: randomUUID(),
-        };
-        const native = state.native ??= defaultNativeAdapter(state);
-        await journal.bindRuntime({
-            runtimeId: config.runtimeId,
-            generation: config.generation,
-            runtimeEpoch: state.runtimeEpoch,
-        });
-        if (config.workspaceMode === 'multi') {
-            gitCredentials = state.gitCredentials = new WorkspaceGitCredentialBroker(state);
-            await gitCredentials.start();
-        }
-        const stopArtifactObserver = observeWorkspaceArtifacts(state);
-        attachNativeCollector(state);
-        native?.onUnexpectedExit?.((event) => {
-            void handleExecutionGroupCrash(state, event.pid);
-        });
-        try {
-            await native?.start?.();
-            const group = native?.executionProcess?.();
-            if (group) {
-                let previousStopped = false;
-                if (previousGroup.pid && previousGroup.pid !== group.pid) {
-                    try {
-                        process.kill(previousGroup.pid, 0);
-                    }
-                    catch (error) {
-                        previousStopped = error.code === 'ESRCH';
-                    }
-                }
-                // The supervisor advances the trusted config epoch only after stopping the old
-                // native group. Reconfirm its recorded PID before publishing that replacement.
-                if (previousIdentityMatches && previousEpoch !== undefined && config.runtimeEpoch > previousEpoch && previousStopped) {
-                    await journal.writeExecutionEpoch({
-                        runtimeEpoch: state.runtimeEpoch, ...group, previousPid: previousGroup.pid, stopConfirmed: true,
-                    });
-                    await journal.replaceSessions(journal.listSessions().map((session) => ({ ...session, recoverability: 'history_only' })));
-                }
-                else {
-                    await journal.noteExecutionGroup(group);
-                }
-            }
-        }
-        catch (error) {
-            const code = error instanceof Error ? error.message : '';
-            state.nativeError = code === 'codex_model_catalog_unavailable' ? code : 'codex_start_failed';
-            console.error(`[workspace-runtime] ${state.nativeError}`);
-        }
-        const server = createServer((request, response) => {
-            void handleRuntimeRequest(state, request, response);
-        });
-        server.on('upgrade', (request, socket, head) => {
-            const pathname = new URL(request.url ?? '/', 'http://127.0.0.1').pathname;
-            if (/^\/runtime\/terminals\/[^/]+\/connect$/.test(pathname)) {
-                void terminalHost(state).handleUpgrade(request, socket, head);
-                return;
-            }
-            if (pathname === '/runtime/desktop/connect') {
-                desktopHost(state).handleUpgrade(request, socket, head);
-                return;
-            }
-            socket.destroy();
-        });
-        const port = await listenOn(server, config.listen.host, config.listen.port);
-        return {
-            config: state.config,
-            state,
-            url: `http://${formatHost(config.listen.host)}:${port}`,
-            async close() {
-                const serverClosed = closeServer(server);
-                await closeCliCredentials(state);
-                await gitCredentials?.close();
-                try {
-                    await disposeDesktopHost(state);
-                }
-                finally {
-                    disposeTerminalHost(state);
-                    try {
-                        await native?.close?.();
-                    }
-                    catch {
-                        /* adapter shutdown is best-effort */
-                    }
-                    await serverClosed;
-                    await stopArtifactObserver();
-                    await journal?.close();
-                    lock.release();
-                }
-            },
-        };
-    }
-    catch (error) {
-        await gitCredentials?.close().catch(() => undefined);
-        await journal?.close().catch(() => undefined);
-        lock.release();
-        throw error;
-    }
-}
-function listenOn(server, host, port) {
-    return new Promise((resolve, reject) => {
-        const onError = (error) => reject(error);
-        server.once('error', onError);
-        server.listen(port, host, () => {
-            server.removeListener('error', onError);
-            const address = server.address();
-            if (!address || typeof address === 'string') {
-                reject(new Error('listen_failed'));
-                return;
-            }
-            resolve(address.port);
-        });
-    });
-}
-function closeServer(server) {
-    return new Promise((resolve, reject) => {
-        server.close((error) => {
-            if (error)
-                reject(error);
-            else
-                resolve();
-        });
-    });
-}
-function formatHost(host) {
-    return host.includes(':') ? `[${host}]` : host;
-}
-function defaultNativeAdapter(state) {
-    const config = state.config;
-    if (process.env.PLAYCRAFT_NATIVE_ADAPTER === 'loopback')
-        return createLoopbackNativeAdapter();
-    const hasLauncher = Boolean(process.env.PLAYCRAFT_LAUNCHER_SOCKET);
-    const multi = config.workspaceMode === 'multi';
-    if (process.env.PLAYCRAFT_NATIVE_ADAPTER === 'codex' && !multi && !hasLauncher) {
-        throw new Error('codex_requires_managed_launcher');
-    }
-    if (process.env.PLAYCRAFT_NATIVE_ADAPTER === 'codex' || (multi && hasLauncher)) {
-        return createCodexAppServerAdapter({
-            config,
-            ...(multi ? { modelBroker: new WorkspaceModelBroker(state) } : {}),
-            ...(multi ? { loadMcpConfig: async (cwd) => {
-                    const { workspaceId } = await workspaceContextFromRoot(state, cwd);
-                    return loadWorkspaceMcpConfig(state, workspaceId);
-                } } : {}),
-            loadSkillArtifact: async (cwd, entry) => {
-                const { workspaceId, directoryName } = await workspaceContextFromRoot(state, cwd);
-                return loadWorkspaceSkillArtifact(state, workspaceId, entry, directoryName === 'root' ? 'basic' : directoryName);
-            },
-            onSkillProcessRestart: process => state.journal.noteExecutionGroup(process),
-        });
-    }
-    return undefined;
-}

package/dist/workspace-runtime/server/auth.js

@@ -1,21 +0,0 @@
-import { timingSafeEqual } from 'node:crypto';
-export function extractControlToken(headers) {
-    const authorization = headerValue(headers.authorization);
-    if (authorization?.startsWith('Bearer ')) {
-        return authorization.slice('Bearer '.length).trim() || null;
-    }
-    const dedicated = headerValue(headers['x-playcraft-control-token']);
-    return dedicated?.trim() || null;
-}
-export function controlTokenMatches(expected, actual) {
-    if (!actual)
-        return false;
-    const left = Buffer.from(expected);
-    const right = Buffer.from(actual);
-    if (left.length !== right.length)
-        return false;
-    return timingSafeEqual(left, right);
-}
-function headerValue(value) {
-    return Array.isArray(value) ? value[0] : value;
-}