@playcraft/cli 0.1.50-beta → 0.1.52

package/dist/workspace-runtime/processes/managed-writes.js

@@ -1,69 +0,0 @@
-import { spawn } from 'node:child_process';
-import { setTimeout as delay } from 'node:timers/promises';
-export const MANAGED_WRITE_SOURCES = ['manual', 'agent', 'background'];
-const BACKGROUND_WRITER = `
-const fs = require('node:fs');
-const file = process.argv[1];
-if (!file) process.exit(1);
-fs.appendFileSync(file, 'background\\n');
-const timer = setInterval(() => {
-  try { fs.appendFileSync(file, 'x'); }
-  catch { clearInterval(timer); process.exit(0); }
-}, 200);
-`;
-/** `true` alive, `false` confirmed exited, `undefined` when the probe cannot tell. */
-export function probeProcess(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch (error) {
-        if (error.code === 'ESRCH')
-            return false;
-        return undefined;
-    }
-}
-export function spawnBackgroundWriter(absolutePath) {
-    const child = spawn(process.execPath, ['-e', BACKGROUND_WRITER, absolutePath], {
-        detached: true,
-        stdio: 'ignore',
-    });
-    child.unref();
-    if (!child.pid)
-        throw new Error('background_write_failed');
-    return child.pid;
-}
-export async function stopBackgroundWriter(pid) {
-    signal(pid, 'SIGTERM');
-    if (await waitUntilStopped(pid, 2_000))
-        return true;
-    signal(pid, 'SIGKILL');
-    return waitUntilStopped(pid, 2_000);
-}
-function signal(pid, name) {
-    try {
-        process.kill(-pid, name);
-    }
-    catch (error) {
-        if (error.code !== 'ESRCH')
-            return;
-        try {
-            process.kill(pid, name);
-        }
-        catch {
-            /* already gone */
-        }
-    }
-}
-async function waitUntilStopped(pid, timeoutMs) {
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        const alive = probeProcess(pid);
-        if (alive === false)
-            return true;
-        if (alive === undefined)
-            return false;
-        await delay(50);
-    }
-    return probeProcess(pid) === false;
-}

package/dist/workspace-runtime/serve.js

@@ -1,441 +0,0 @@
-import { closeCliCredentials } from './workspaces/cli-credentials.js';
-import { randomUUID } from 'node:crypto';
-import { mkdir, readdir } from 'node:fs/promises';
-import { createServer } from 'node:http';
-import { createPlatformAdapter } from '@playcraft/build';
-import { INCOMPATIBLE_EXIT_CODE, negotiateProtocol, transitionOperation, directoryMutationReceiptSchema, productionSessionAttemptId, } from '@playcraft/common/cloud-workspace/runtime';
-import { RuntimeJournal } from './persistence/journal.js';
-import { createCodexAppServerAdapter } from './codex/app-server.js';
-import { trustedMemberPolicy } from './batch/policy.js';
-import { batchDirectoryHeld } from './batch/occupancy.js';
-import { createLoopbackNativeAdapter } from './codex/loopback.js';
-import { attachNativeCollector, recoverInterruptedParameterVerifications, stopParameterVerifications } 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 { DeliveryStore, recoverInterruptedDeliveries } from './workspaces/delivery-store.js';
-import { loadWorkspaceSkillArtifact } from './workspaces/skill-artifact-loader.js';
-import { workspaceContextFromRoot, workspaceRoot } from './workspaces/registry.js';
-import { recoverInterruptedLibraryImports } from './workspaces/asset-library-import.js';
-import { recoverAssetTransfers } from './workspaces/asset-transfer-publish.js';
-import { recoverWorkspaceDirectoryMutation } from './workspaces/directory-mutations.js';
-import { observeWorkspaceDirectories } from './workspaces/directory-revisions.js';
-import { observeWorkspaceBinaryFile } from './workspaces/binary-write.js';
-import { revisionScope } from './workspaces/registry.js';
-import { observeWorkspaceArtifacts } from './workspaces/artifact-events.js';
-import { loadWorkspaceMcpConfig } from './codex/mcp-config.js';
-import { startSourceEventUploader, stopSourceEventUploader } from './server/source-uploader.js';
-import { submitTrustedOperation } from './server/submit-operation.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;
-    let runtimeState;
-    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 recoverInterruptedParameterVerifications(journal);
-        await recoverInterruptedDeliveries(config.stateDir);
-        await mkdir(config.workspaceRoot, { recursive: true, mode: 0o700 });
-        const state = runtimeState = {
-            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 recoveredImports = new Map();
-        const recoveredChanges = [];
-        const recoveredWrites = [];
-        const recoverLibraryImports = async (root) => {
-            const result = await recoverInterruptedLibraryImports(root).catch(() => undefined);
-            for (const published of result?.published ?? []) {
-                const previous = recoveredImports.get(published.operationId) ?? { paths: [], assetIds: [] };
-                recoveredImports.set(published.operationId, { paths: [...new Set([...previous.paths, ...published.paths])],
-                    assetIds: [...new Set([...previous.assetIds, published.assetId])] });
-            }
-        };
-        if (config.workspaceMode === 'multi') {
-            for (const entry of await readdir(config.workspaceRoot, { withFileTypes: true })) {
-                if (!entry.isDirectory())
-                    continue;
-                const binding = journal.getWorkspace(entry.name);
-                if (!binding)
-                    continue;
-                for (const directory of new Set(['basic', ...(binding.directories ?? []).map(item => item.directoryName)])) {
-                    const root = await workspaceRoot(state, binding.workspaceId, directory).catch(() => undefined);
-                    if (root)
-                        await recoverLibraryImports(root);
-                }
-            }
-        }
-        else
-            await recoverLibraryImports(config.workspaceRoot);
-        for (const { scopeKey, operation } of journal.listOperations()) {
-            if (operation.kind !== 'asset.library.import' || !['queued', 'dispatched', 'accepted', 'uncertain'].includes(operation.status))
-                continue;
-            const published = recoveredImports.get(operation.operationId);
-            const result = operation.result && 'paths' in operation.result ? { ...operation.result,
-                paths: [...new Set([...operation.result.paths, ...(published?.paths ?? [])])],
-                failures: operation.result.failures.filter(failure => !published?.assetIds.includes(failure.assetId)),
-            } : undefined;
-            const root = await workspaceRoot(state, operation.workspaceId, operation.directoryName).catch(() => undefined);
-            if (root && result)
-                for (const path of result.paths) {
-                    const file = await observeWorkspaceBinaryFile(root, path).catch(() => undefined);
-                    if (!file)
-                        continue;
-                    const scope = revisionScope(state, operation.workspaceId, operation.directoryName);
-                    const previous = journal.fileRevisions(scope)[path];
-                    await journal.putFileRevision(path, { revision: (previous?.revision ?? 0) + 1, contentHash: file.contentHash }, scope);
-                }
-            let next = operation;
-            if (result && !result.failures.length) {
-                if (next.status === 'queued')
-                    next = transitionOperation(next, 'dispatched');
-                if (next.status === 'dispatched')
-                    next = transitionOperation(next, 'accepted');
-                next = transitionOperation(next, 'completed', { result });
-            }
-            else
-                next = transitionOperation(next, 'failed', { error: 'asset_library_import_interrupted', ...(result ? { result } : {}) });
-            await journal.putOperation(scopeKey, next);
-            if (operation.workspaceId && result?.paths.length)
-                recoveredChanges.push({ workspaceId: operation.workspaceId,
-                    directoryName: operation.directoryName ?? 'basic', paths: result.paths });
-        }
-        const recoveredBundles = new Map();
-        const transferScopes = new Set();
-        for (const { operation } of journal.listOperations()) {
-            if (operation.kind !== 'asset.bundle.save')
-                continue;
-            const directoryName = operation.directoryName ?? 'basic';
-            const key = `${operation.workspaceId ?? ''}:${directoryName}`;
-            if (transferScopes.has(key))
-                continue;
-            transferScopes.add(key);
-            const root = await workspaceRoot(state, operation.workspaceId, directoryName).catch(() => undefined);
-            if (!root)
-                continue;
-            const recovered = await recoverAssetTransfers(root, { environment: config.environment, userId: config.userId,
-                workspaceId: operation.workspaceId ?? '', directoryName }).catch(() => []);
-            for (const item of recovered)
-                recoveredBundles.set(item.operationId, item);
-        }
-        for (const { scopeKey, operation } of journal.listOperations()) {
-            if (operation.kind !== 'asset.bundle.save' || !['queued', 'dispatched', 'accepted', 'uncertain'].includes(operation.status))
-                continue;
-            const recovered = recoveredBundles.get(operation.operationId), receipt = recovered?.receipt;
-            let next = operation;
-            if (receipt) {
-                const paths = [...receipt.files.map(file => file.path), ...(receipt.directories ?? [])];
-                const scope = revisionScope(state, operation.workspaceId, operation.directoryName);
-                for (const file of receipt.files) {
-                    const previous = journal.fileRevisions(scope)[file.path];
-                    const revision = previous ? previous.revision + (previous.contentHash === file.contentHash ? 0 : 1) : 1;
-                    await journal.putFileRevision(file.path, { revision,
-                        contentHash: file.contentHash }, scope);
-                    const metadata = recovered?.manifest.files.find(item => item.path === file.path);
-                    recoveredWrites.push({ ...file, revision, writer: 'manual', workspaceId: operation.workspaceId,
-                        directoryName: operation.directoryName ?? 'basic', operationId: operation.operationId, transferId: receipt.transferId,
-                        ...(metadata?.processing ? { processing: metadata.processing } : {}), recovered: true });
-                }
-                if (next.status === 'queued')
-                    next = transitionOperation(next, 'dispatched');
-                if (next.status === 'dispatched')
-                    next = transitionOperation(next, 'accepted');
-                next = transitionOperation(next, 'completed', { result: { paths, skippedPaths: [], failures: [], bundleReceipt: receipt } });
-                if (operation.workspaceId)
-                    recoveredChanges.push({ workspaceId: operation.workspaceId, directoryName: operation.directoryName ?? 'basic', paths, source: 'asset.bundle.save' });
-            }
-            else
-                next = transitionOperation(next, 'failed', { error: 'asset_bundle_save_interrupted' });
-            await journal.putOperation(scopeKey, next);
-        }
-        for (const { scopeKey, operation } of journal.listOperations()) {
-            if (!['directory.rename', 'directory.delete'].includes(operation.kind)
-                || !['queued', 'dispatched', 'accepted', 'uncertain'].includes(operation.status))
-                continue;
-            const kind = operation.kind;
-            let next = operation;
-            try {
-                const root = await workspaceRoot(state, operation.workspaceId, operation.directoryName);
-                const receipt = await recoverWorkspaceDirectoryMutation(root, kind, { operationId: operation.operationId,
-                    operationPayloadHash: operation.payloadHash, scope: scopeKey, assertCurrent: async () => {
-                        if ((operation.leaseFence ?? 0) < state.acceptedLeaseFence || state.journal.destroyed())
-                            throw new Error('stale_lease');
-                        if (operation.sessionId && productionSessionAttemptId(operation.sessionId))
-                            throw new Error('production_session_readonly');
-                        if (await batchDirectoryHeld(state, operation.workspaceId, operation.directoryName))
-                            throw new Error('batch_workspace_readonly');
-                    } });
-                if (!receipt)
-                    throw new Error('directory_mutation_interrupted');
-                await observeWorkspaceDirectories(root, journal, revisionScope(state, operation.workspaceId, operation.directoryName));
-                const paths = [receipt.path, ...(receipt.newPath ? [receipt.newPath] : [])];
-                if (next.status === 'queued')
-                    next = transitionOperation(next, 'dispatched');
-                if (next.status === 'dispatched')
-                    next = transitionOperation(next, 'accepted');
-                next = transitionOperation(next, 'completed', { result: { paths, skippedPaths: [], failures: [], directoryMutation: directoryMutationReceiptSchema.parse(receipt) } });
-                if (operation.workspaceId)
-                    recoveredChanges.push({ workspaceId: operation.workspaceId,
-                        directoryName: operation.directoryName ?? 'basic', paths, source: kind });
-            }
-            catch (error) {
-                const reason = String(error?.code ?? (error instanceof Error ? error.message : ''));
-                const code = ['directory_mutation_interrupted', 'stale_lease', 'production_session_readonly', 'batch_workspace_readonly',
-                    'directory_exists', 'directory_not_found', 'revision_conflict', 'directory_conflict', 'invalid_workspace_path', 'workspace_permission_denied']
-                    .includes(reason) ? reason : 'directory_recovery_required';
-                next = transitionOperation(next, code === 'directory_mutation_interrupted' ? 'failed' : 'uncertain', { error: code });
-            }
-            await journal.putOperation(scopeKey, next);
-        }
-        const native = state.native ??= defaultNativeAdapter(state);
-        await journal.bindRuntime({
-            runtimeId: config.runtimeId,
-            generation: config.generation,
-            runtimeEpoch: state.runtimeEpoch,
-        });
-        for (const payload of recoveredWrites)
-            await journal.allocateSourceEvent({ runtimeId: config.runtimeId,
-                generation: config.generation, runtimeEpoch: state.runtimeEpoch, workspaceId: payload.workspaceId,
-                type: 'file.written', occurredAt: new Date().toISOString(), payload });
-        for (const change of recoveredChanges)
-            await journal.allocateSourceEvent({ runtimeId: config.runtimeId,
-                generation: config.generation, runtimeEpoch: state.runtimeEpoch, workspaceId: change.workspaceId,
-                type: 'files.changed', occurredAt: new Date().toISOString(), payload: { ...change, source: change.source ?? 'asset.library.import', recovered: true },
-            });
-        startSourceEventUploader(state);
-        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, previousRuntimeEpoch: previousEpoch, 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 stopParameterVerifications(state);
-                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();
-                    stopSourceEventUploader(state);
-                    await journal?.close();
-                    lock.release();
-                }
-            },
-        };
-    }
-    catch (error) {
-        if (runtimeState)
-            stopSourceEventUploader(runtimeState);
-        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 deliveryToolHandlers(state) {
-    const contextFor = async (input) => {
-        if (input.workspaceId)
-            return { workspaceId: input.workspaceId, directoryName: input.directoryName ?? 'basic' };
-        if (state.config.workspaceMode !== 'multi' || !input.cwd)
-            throw new Error('feature_unavailable');
-        return workspaceContextFromRoot(state, input.cwd);
-    };
-    return {
-        async build(input) {
-            const { workspaceId, directoryName } = await contextFor(input);
-            if (directoryName === 'root')
-                throw new Error('invalid_workspace_directory');
-            const builds = [];
-            for (const channel of input.channels) {
-                const operation = await submitTrustedOperation(state, {
-                    kind: 'delivery.build',
-                    workspaceId,
-                    directoryName,
-                    ...(input.sessionId ? { sessionId: input.sessionId } : {}),
-                    clientRequestId: `${input.clientRequestId.slice(0, 80)}:${channel}`,
-                    payload: {
-                        channel,
-                        format: input.format ?? createPlatformAdapter({ platform: channel, format: 'html' }).getDefaultFormat(),
-                        actor: 'agent',
-                    },
-                });
-                let record;
-                for (let attempt = 0; attempt < 40 && !record; attempt++) {
-                    record = await new DeliveryStore(state.config.stateDir, workspaceId).read(operation.operationId);
-                    if (!record)
-                        await new Promise(resolve => setTimeout(resolve, 25));
-                }
-                builds.push({
-                    buildId: operation.operationId,
-                    channel,
-                    status: record?.status ?? operation.status,
-                    ...(record?.queuePosition ? { queuePosition: record.queuePosition } : {}),
-                });
-            }
-            return { builds };
-        },
-        async get(input) {
-            const { workspaceId, directoryName } = await contextFor(input);
-            const store = new DeliveryStore(state.config.stateDir, workspaceId);
-            const record = input.buildId
-                ? await store.read(input.buildId)
-                : (await store.list(directoryName, input.channel, 20))[0];
-            if (!record || record.directoryName !== directoryName)
-                throw new Error('delivery_build_not_found');
-            const log = await store.readLog(record.buildId, 0).catch(() => undefined);
-            return { build: record, ...(log ? { logTail: log.text.slice(-4_000) } : {}) };
-        },
-    };
-}
-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,
-            workspaceUi: true,
-            deliveryTools: deliveryToolHandlers(state),
-            ...(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),
-            trustedExecution: sessionId => trustedMemberPolicy(state, sessionId),
-        });
-    }
-    return undefined;
-}

package/dist/workspace-runtime/server/accept-operation.js

@@ -1,61 +0,0 @@
-import { assertLeaseFence, hashOperationPayload, isLostThreadError, operationScopeKey, resolveIdempotentAccept, runtimeError, } from '@playcraft/common/cloud-workspace/runtime';
-import { canExecuteKind, executeOperation } from './dispatch.js';
-import { buildOperationRecord } from './operation-record.js';
-/**
- * Shared operation acceptance: lease fence, idempotency, capability, record creation and
- * execution. HTTP supplies its transport/session checks through `validate`; in-sandbox Agent
- * tools pass none. The callback runs only when a new operation is about to be created.
- */
-export async function acceptOperationCore(state, parsed, options) {
-    const payloadHash = hashOperationPayload(parsed.payload);
-    const scopeKey = operationScopeKey({
-        environment: state.config.environment,
-        userId: state.config.userId,
-        kind: parsed.kind,
-        clientRequestId: parsed.clientRequestId,
-        workspaceId: parsed.workspaceId,
-        directoryName: parsed.directoryName,
-        sessionId: parsed.sessionId,
-    });
-    return state.journal.exclusive(scopeKey, async () => {
-        // Recheck after a concurrent dispatcher may have advanced the fence while this request waited.
-        if (assertLeaseFence(options.leaseFence, state.acceptedLeaseFence) !== 'ok') {
-            return rejected(409, runtimeError('stale_lease', 'leaseFence is behind the accepted dispatcher'));
-        }
-        const existing = state.journal.getOperation(scopeKey);
-        const decision = resolveIdempotentAccept(existing, payloadHash);
-        if (decision.action === 'conflict') {
-            return rejected(409, runtimeError('idempotency_conflict', 'clientRequestId reused with a different payload', {
-                operationId: decision.operation.operationId,
-            }));
-        }
-        const retryWithRecovery = decision.action === 'reuse' && parsed.kind === 'session.turn'
-            && Boolean(parsed.sessionRecovery) && decision.operation.status === 'failed'
-            && isLostThreadError(decision.operation.error);
-        if (decision.action === 'reuse' && !retryWithRecovery) {
-            if (decision.operation.status === 'uncertain') {
-                return rejected(409, runtimeError('uncertain_operation', decision.operation.error ?? 'native_receipt_lost', {
-                    operationId: decision.operation.operationId,
-                }));
-            }
-            return { rejected: false, operation: decision.operation, executed: decision.operation, reused: true };
-        }
-        const validation = await options.validate?.(scopeKey);
-        if (validation)
-            return { rejected: true, refusal: validation };
-        const executable = canExecuteKind(state, parsed.kind);
-        const operation = buildOperationRecord(state, parsed, payloadHash, options.leaseFence, executable);
-        if (!executable) {
-            const saved = await state.journal.putOperation(scopeKey, operation);
-            return rejected(409, runtimeError('capability_unavailable', state.journal.destroyed() ? 'runtime_destroyed' : state.nativeError ?? 'adapter_not_started', { operationId: saved.operationId }));
-        }
-        state.acceptedLeaseFence = Math.max(state.acceptedLeaseFence, options.leaseFence);
-        await state.journal.setAcceptedLeaseFence(state.acceptedLeaseFence);
-        const queued = await state.journal.putOperation(scopeKey, operation);
-        const executed = await executeOperation(state, scopeKey, queued, options.executionPayload, parsed.sessionRecovery);
-        return { rejected: false, operation: queued, executed, reused: false };
-    });
-}
-function rejected(status, body) {
-    return { rejected: true, refusal: { status, body } };
-}

package/dist/workspace-runtime/server/asset-transfers.js

@@ -1,63 +0,0 @@
-import { ASSET_TRANSFER_BODY_MAX_BYTES, ASSET_TRANSFER_CHUNK_BODY_MAX_BYTES } from '@playcraft/common/cloud-workspace/runtime';
-import { batchDirectoryHeld } from '../batch/occupancy.js';
-import { revisionScope, workspaceRoot } from '../workspaces/registry.js';
-import { AssetTransferError, cancelAssetTransfer, createAssetTransfer, getAssetTransfer, putAssetTransferChunk } from '../workspaces/asset-transfer-storage.js';
-export async function handleAssetTransferRequest(state, request, url) {
-    const route = /^\/runtime\/asset-transfers(?:\/([^/]+)(?:\/(chunks))?)?$/.exec(url.pathname);
-    if (!route)
-        return undefined;
-    const workspaceId = url.searchParams.get('workspaceId') ?? '';
-    const directoryName = url.searchParams.get('directoryName') ?? 'basic';
-    try {
-        if (state.journal.destroyed())
-            throw new AssetTransferError('runtime_destroyed');
-        if (!/^(basic|remix-[a-z0-9][a-z0-9-]{3,63})$/.test(directoryName))
-            throw new AssetTransferError('invalid_workspace_directory', 400);
-        const [, id, action] = route;
-        const valid = !id && request.method === 'POST' || id && !action && ['GET', 'DELETE'].includes(request.method ?? '')
-            || id && action === 'chunks' && request.method === 'PUT';
-        if (!valid)
-            return { status: 405, body: { error: 'asset_transfer_method_not_allowed' } };
-        const scope = { workspaceId, directoryName, environment: state.config.environment, userId: state.config.userId };
-        const body = ['POST', 'PUT'].includes(request.method ?? '')
-            ? await readTransferJson(request, action ? ASSET_TRANSFER_CHUNK_BODY_MAX_BYTES : ASSET_TRANSFER_BODY_MAX_BYTES) : undefined;
-        return await state.journal.exclusive(`directory:${workspaceId}:${directoryName}`, async () => state.journal.exclusive(`workspace:${revisionScope(state, workspaceId, directoryName) ?? 'single'}`, async () => {
-            if (state.journal.destroyed())
-                throw new AssetTransferError('runtime_destroyed');
-            if (request.method !== 'GET' && await batchDirectoryHeld(state, workspaceId, directoryName))
-                throw new AssetTransferError('batch_workspace_readonly');
-            const root = await workspaceRoot(state, workspaceId, directoryName);
-            const result = !id ? await createAssetTransfer(root, scope, body)
-                : action ? await putAssetTransferChunk(root, scope, id, body)
-                    : request.method === 'GET' ? await getAssetTransfer(root, scope, id) : await cancelAssetTransfer(root, scope, id);
-            return { status: 200, body: result };
-        }));
-    }
-    catch (error) {
-        if (error instanceof AssetTransferError)
-            return { status: error.status, body: { error: error.code } };
-        if (error.name === 'ZodError')
-            return { status: 400, body: { error: 'invalid_asset_transfer' } };
-        throw error;
-    }
-}
-async function readTransferJson(request, limit) {
-    const length = request.headers['content-length'];
-    if (length && (!/^\d+$/.test(length) || Number(length) > limit))
-        throw new AssetTransferError('asset_transfer_too_large', 413);
-    const parts = [];
-    let size = 0;
-    for await (const data of request) {
-        const bytes = Buffer.isBuffer(data) ? data : Buffer.from(data);
-        size += bytes.length;
-        if (size > limit)
-            throw new AssetTransferError('asset_transfer_too_large', 413);
-        parts.push(bytes);
-    }
-    try {
-        return JSON.parse(Buffer.concat(parts).toString('utf8'));
-    }
-    catch {
-        throw new AssetTransferError('invalid_asset_transfer', 400);
-    }
-}

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