@playcraft/cli 0.0.57 → 0.0.59

package/dist/workspace-runtime/server/execution-group.js

@@ -0,0 +1,88 @@
+function enqueue(state, action) {
+    const run = state.executionQueue.then(action, action);
+    state.executionQueue = run.then(() => undefined, () => undefined);
+    return run;
+}
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function requireRestartable(state) {
+    const native = state.native;
+    if (!native?.executionProcess || !native.replaceProcess) {
+        throw new Error('execution_group_unavailable');
+    }
+    return native;
+}
+async function demoteSessions(state) {
+    await state.journal.replaceSessions(state.journal.listSessions().map((session) => ({ ...session, recoverability: 'history_only' })));
+}
+async function advanceEpoch(state, input) {
+    const runtimeEpoch = state.runtimeEpoch + 1;
+    await state.journal.writeExecutionEpoch({
+        runtimeEpoch,
+        pid: input.pid,
+        startedAt: input.startedAt,
+        previousPid: input.previousPid,
+        stopConfirmed: input.stopConfirmed,
+    });
+    state.runtimeEpoch = runtimeEpoch;
+    await demoteSessions(state);
+}
+export function executionGroupRestarted(state, checkpointEpoch) {
+    return state.runtimeEpoch !== checkpointEpoch;
+}
+export async function replaceExecutionGroup(state, options) {
+    return enqueue(state, async () => {
+        const native = requireRestartable(state);
+        const previous = native.executionProcess();
+        if (!previous)
+            throw new Error('execution_group_missing');
+        const next = await native.replaceProcess();
+        await advanceEpoch(state, {
+            pid: next.pid,
+            startedAt: next.startedAt,
+            previousPid: previous.pid,
+            stopConfirmed: false,
+        });
+        if (options.confirmStop)
+            await confirmStopped(state, previous.pid);
+        return {
+            runtimeEpoch: state.runtimeEpoch,
+            stopConfirmed: state.journal.executionGroup().stopConfirmed,
+            pid: next.pid,
+            previousPid: previous.pid,
+        };
+    });
+}
+export async function confirmExecutionGroupStopped(state, previousPid) {
+    return enqueue(state, () => confirmStopped(state, previousPid));
+}
+async function confirmStopped(state, previousPid) {
+    if (processAlive(previousPid))
+        return false;
+    await state.journal.setExecutionStopConfirmed(true);
+    return true;
+}
+export async function handleExecutionGroupCrash(state, exitedPid) {
+    return enqueue(state, async () => {
+        const group = state.journal.executionGroup();
+        if (group.pid !== exitedPid)
+            return;
+        const native = state.native;
+        if (!native?.replaceProcess)
+            return;
+        const next = await native.replaceProcess();
+        await advanceEpoch(state, {
+            pid: next.pid,
+            startedAt: next.startedAt,
+            previousPid: exitedPid,
+            stopConfirmed: true,
+        });
+    });
+}

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

@@ -0,0 +1,561 @@
+import { readObservedFile, withObservedFile } from '../workspaces/revisions.js';
+import { registerWorkspace, revisionScope, workspaceRoot, WorkspaceContextError } from '../workspaces/registry.js';
+import { randomUUID } from 'node:crypto';
+import { workspaceRegistrationRequestSchema, HTTP_STATUS_BY_ERROR, assertLeaseFence, buildHandshakeDocument, capability, findUntrustedRuntimeFields, hashOperationPayload, instanceRebuildRequestSchema, operationAcceptRequestSchema, operationKindSchema, operationScopeKey, resolveIdempotentAccept, runtimeError, unavailableRuntimeCapabilities, } from '@playcraft/common/cloud-workspace/runtime';
+import { controlTokenMatches, extractControlToken } from './auth.js';
+import { canExecuteKind, executeOperation } from './dispatch.js';
+import { InvalidWorkspacePathError, listWorkspaceFiles, } from '../workspaces/files.js';
+import { materializeRemoteSnapshot } from '../workspaces/file-snapshot.js';
+import { GitWorkspaceError, readWorkspaceGitDiff, readWorkspaceGitGraph, readWorkspaceGitStatus, } from '../workspaces/git.js';
+import { readWorkspaceParameters } from '../workspaces/parameters.js';
+export async function handleRuntimeRequest(state, request, response) {
+    const url = new URL(request.url ?? '/', 'http://127.0.0.1');
+    if (!controlTokenMatches(state.config.controlToken, extractControlToken(request.headers))) {
+        writeError(response, runtimeError('unauthenticated', 'control_token_required'));
+        return;
+    }
+    try {
+        if (request.method === 'GET' && url.pathname === '/runtime/health') {
+            writeJson(response, 200, { status: 'ok', handshake: handshake(state) });
+            return;
+        }
+        if (request.method === 'GET' && url.pathname === '/runtime/identity') {
+            const { runtimeId, userId, environment, generation } = state.config;
+            writeJson(response, 200, {
+                runtimeId,
+                userId,
+                environment,
+                generation,
+                runtimeEpoch: state.runtimeEpoch,
+                instanceToken: state.instanceToken,
+                workspaceMode: state.config.workspaceMode,
+                executionGroup: {
+                    replaced: state.journal.executionGroup().replaced,
+                    stopConfirmed: state.journal.executionGroup().stopConfirmed,
+                },
+            });
+            return;
+        }
+        if (request.method === 'GET' && url.pathname === '/runtime/approvals') {
+            writeJson(response, 200, { approvals: state.journal.listApprovals() });
+            return;
+        }
+        if (request.method === 'POST' && url.pathname === '/runtime/workspaces/register') {
+            if (writeDestroyed(state, response))
+                return;
+            const parsed = workspaceRegistrationRequestSchema.safeParse(await readJson(request));
+            if (!parsed.success || parsed.data.generation !== state.config.generation || parsed.data.runtimeEpoch !== state.runtimeEpoch) {
+                writeJson(response, 409, { error: 'invalid_workspace_registration' });
+                return;
+            }
+            const binding = await registerWorkspace(state, parsed.data.binding, parsed.data.leaseFence, parsed.data.preparation);
+            writeJson(response, 200, { workspaceId: binding.workspaceId, status: 'registered' });
+            return;
+        }
+        if (request.method === 'GET' && url.pathname === '/runtime/handshake') {
+            writeJson(response, 200, handshake(state));
+            return;
+        }
+        if (isUnimplementedWorkbenchPath(url.pathname)) {
+            if (writeDestroyed(state, response))
+                return;
+            writeError(response, runtimeError('capability_unavailable', 'capability_not_implemented'));
+            return;
+        }
+        if (request.method === 'POST' && url.pathname === '/runtime/instance/rebuild') {
+            await rebuildInstanceFiles(state, request, response);
+            return;
+        }
+        if (request.method === 'GET' && url.pathname === '/runtime/checkpoint') {
+            const checkpointId = url.searchParams.get('checkpointId') ?? '';
+            const checkpoint = state.journal.getCheckpoint(checkpointId);
+            if (!checkpoint) {
+                writeJson(response, 404, { error: 'unknown_checkpoint' });
+                return;
+            }
+            writeJson(response, 200, {
+                checkpoint,
+                fileCheckpointId: state.journal.fileCheckpointId() ?? null,
+                consistentCheckpointId: state.journal.consistentCheckpointId() ?? null,
+            });
+            return;
+        }
+        if (request.method === 'GET' && url.pathname === '/runtime/events') {
+            const after = Number(url.searchParams.get('after') ?? '0');
+            writeJson(response, 200, {
+                events: state.journal.listEvents(Number.isInteger(after) ? after : 0),
+            });
+            return;
+        }
+        if (request.method === 'GET' && url.pathname === '/runtime/files') {
+            if (writeDestroyed(state, response))
+                return;
+            writeJson(response, 200, await listWorkspaceFiles(await workspaceRoot(state, url.searchParams.get('workspaceId') ?? undefined), state.journal.fileRevisions(revisionScope(state, url.searchParams.get('workspaceId') ?? undefined))));
+            return;
+        }
+        if (request.method === 'GET' && url.pathname === '/runtime/file') {
+            if (writeDestroyed(state, response))
+                return;
+            const relativePath = url.searchParams.get('path') ?? '';
+            try {
+                writeJson(response, 200, await readObservedFile(state, url.searchParams.get('workspaceId') ?? undefined, relativePath));
+            }
+            catch (error) {
+                if (error instanceof InvalidWorkspacePathError) {
+                    writeJson(response, 400, { error: 'invalid_workspace_path' });
+                    return;
+                }
+                if (error.code === 'ENOENT') {
+                    writeJson(response, 404, { error: 'file_not_found' });
+                    return;
+                }
+                throw error;
+            }
+            return;
+        }
+        if (request.method === 'GET' && url.pathname === '/runtime/git/status') {
+            await writeGitRead(state, response, async () => readWorkspaceGitStatus(await workspaceRoot(state, url.searchParams.get('workspaceId') ?? undefined)));
+            return;
+        }
+        if (request.method === 'GET' && url.pathname === '/runtime/git/diff') {
+            await writeGitRead(state, response, async () => readWorkspaceGitDiff(await workspaceRoot(state, url.searchParams.get('workspaceId') ?? undefined)));
+            return;
+        }
+        if (request.method === 'GET' && url.pathname === '/runtime/git/graph') {
+            await writeGitRead(state, response, async () => readWorkspaceGitGraph(await workspaceRoot(state, url.searchParams.get('workspaceId') ?? undefined)));
+            return;
+        }
+        if (request.method === 'GET' && url.pathname === '/runtime/parameters') {
+            if (writeDestroyed(state, response))
+                return;
+            writeJson(response, 200, await readObservedParameters(state, url.searchParams.get('workspaceId') ?? undefined));
+            return;
+        }
+        if (request.method === 'GET' && url.pathname === '/runtime/terminals') {
+            if (writeDestroyed(state, response))
+                return;
+            writeJson(response, 200, {
+                terminals: state.journal.listTerminals(url.searchParams.get('workspaceId') ?? undefined),
+            });
+            return;
+        }
+        if (url.pathname.startsWith('/runtime/terminals/')) {
+            await handleTerminalIdentity(state, request, response, url.pathname.slice('/runtime/terminals/'.length));
+            return;
+        }
+        if (request.method === 'GET' && url.pathname === '/runtime/operations') {
+            const kind = operationKindSchema.safeParse(url.searchParams.get('kind'));
+            const clientRequestId = url.searchParams.get('clientRequestId');
+            if (!kind.success || !clientRequestId) {
+                writeJson(response, 400, { error: 'invalid_operation_lookup' });
+                return;
+            }
+            const operation = state.journal.getOperation(operationScopeKey({
+                environment: state.config.environment,
+                userId: state.config.userId,
+                kind: kind.data,
+                clientRequestId,
+                workspaceId: url.searchParams.get('workspaceId') ?? undefined,
+                sessionId: url.searchParams.get('sessionId') ?? undefined,
+            }));
+            writeJson(response, operation ? 200 : 404, operation ?? { error: 'operation_not_found' });
+            return;
+        }
+        if (request.method === 'GET' && url.pathname.startsWith('/runtime/operations/')) {
+            const operationId = url.pathname.slice('/runtime/operations/'.length);
+            const operation = state.journal.getOperationById(operationId);
+            if (!operation) {
+                writeJson(response, 404, { error: 'operation_not_found' });
+                return;
+            }
+            writeJson(response, 200, operation);
+            return;
+        }
+        if (request.method === 'POST' && url.pathname === '/runtime/operations') {
+            await acceptOperation(state, request, response);
+            return;
+        }
+        writeJson(response, 404, { error: 'not_found' });
+    }
+    catch (error) {
+        if (error instanceof WorkspaceContextError) {
+            writeJson(response, 409, { error: error.message });
+            return;
+        }
+        writeJson(response, 500, {
+            error: 'internal_error',
+            reason: error instanceof Error ? error.message : 'unknown',
+        });
+    }
+}
+function handshake(state) {
+    const destroyed = state.journal.destroyed();
+    const conversationReady = Boolean(state.native?.ready()) && !destroyed;
+    const filesReady = !destroyed;
+    const gitReady = state.gitAvailable && !destroyed;
+    const capabilities = unavailableRuntimeCapabilities('adapter_not_started').map((item) => {
+        if (item.name === 'conversation') {
+            if (conversationReady)
+                return capability('conversation', true);
+            return destroyed ? capability('conversation', false, 'runtime_destroyed') : item;
+        }
+        if (item.name === 'files') {
+            return filesReady
+                ? capability('files', true)
+                : capability('files', false, 'runtime_destroyed');
+        }
+        if (item.name === 'git') {
+            if (gitReady)
+                return capability('git', true);
+            if (destroyed)
+                return capability('git', false, 'runtime_destroyed');
+            if (!state.gitAvailable)
+                return capability('git', false, 'git_binary_missing');
+            return item;
+        }
+        if (item.name === 'terminal') {
+            return destroyed
+                ? capability('terminal', false, 'runtime_destroyed')
+                : capability('terminal', true);
+        }
+        if (item.name === 'desktop') {
+            return destroyed
+                ? capability('desktop', false, 'runtime_destroyed')
+                : capability('desktop', false, 'display_not_started');
+        }
+        if (item.name === 'parameters') {
+            return destroyed
+                ? capability('parameters', false, 'runtime_destroyed')
+                : capability('parameters', true);
+        }
+        if (item.name === 'artifacts.singleFile') {
+            return destroyed
+                ? capability('artifacts.singleFile', false, 'runtime_destroyed')
+                : capability('artifacts.singleFile', false, 'capability_not_implemented');
+        }
+        return item;
+    });
+    return buildHandshakeDocument({
+        protocolMajor: state.config.protocolMajor,
+        protocolMinor: state.config.protocolMinor,
+        cliVersion: state.config.cliVersion,
+        codexVersion: state.config.codexVersion,
+        imageDigest: state.config.imageDigest,
+        phase: destroyed ? 'unavailable' : conversationReady ? 'ready' : 'awaiting_native',
+        generations: {
+            generation: state.config.generation,
+            runtimeEpoch: state.runtimeEpoch,
+            leaseFence: state.acceptedLeaseFence,
+        },
+        capabilities,
+    });
+}
+async function acceptOperation(state, request, response) {
+    const body = await readJson(request);
+    if (!body || typeof body !== 'object' || Array.isArray(body)) {
+        writeJson(response, 400, { error: 'invalid_operation' });
+        return;
+    }
+    // leaseFence 由 Runtime Server 派发，本控制面单独校验；其余代次/身份/根目录字段仍只来自引导配置。
+    const untrusted = findUntrustedRuntimeFields(body).filter((field) => field !== 'leaseFence');
+    if (untrusted.length > 0) {
+        writeError(response, runtimeError('untrusted_runtime_field', untrusted.join(',')));
+        return;
+    }
+    const incomingFence = Number(body.leaseFence ?? state.acceptedLeaseFence);
+    if (!Number.isInteger(incomingFence) || incomingFence < 0) {
+        writeJson(response, 400, { error: 'invalid_lease_fence' });
+        return;
+    }
+    if (assertLeaseFence(incomingFence, state.acceptedLeaseFence) !== 'ok') {
+        writeError(response, runtimeError('stale_lease', 'leaseFence is behind the accepted dispatcher'));
+        return;
+    }
+    const { leaseFence: _leaseFence, ...requestBody } = body;
+    const parsed = operationAcceptRequestSchema.safeParse(requestBody);
+    if (!parsed.success) {
+        writeJson(response, 400, { error: 'invalid_operation', issues: parsed.error.issues });
+        return;
+    }
+    if (parsed.data.kind.startsWith('session.') && !parsed.data.sessionId) {
+        writeJson(response, 400, { error: 'invalid_operation', reason: 'sessionId_required' });
+        return;
+    }
+    if (state.config.workspaceMode === 'multi')
+        await workspaceRoot(state, parsed.data.workspaceId);
+    const payloadHash = hashOperationPayload(parsed.data.payload);
+    const scopeKey = operationScopeKey({
+        environment: state.config.environment,
+        userId: state.config.userId,
+        kind: parsed.data.kind,
+        clientRequestId: parsed.data.clientRequestId,
+        workspaceId: parsed.data.workspaceId,
+        sessionId: parsed.data.sessionId,
+    });
+    const accept = () => state.journal.exclusive(scopeKey, async () => {
+        // Recheck after a concurrent dispatcher may have advanced the fence while this request waited.
+        if (assertLeaseFence(incomingFence, state.acceptedLeaseFence) !== 'ok') {
+            writeError(response, runtimeError('stale_lease', 'leaseFence is behind the accepted dispatcher'));
+            return;
+        }
+        const existing = state.journal.getOperation(scopeKey);
+        const decision = resolveIdempotentAccept(existing, payloadHash);
+        if (decision.action === 'conflict') {
+            writeError(response, runtimeError('idempotency_conflict', 'clientRequestId reused with a different payload', {
+                operationId: decision.operation.operationId,
+            }));
+            return;
+        }
+        if (decision.action === 'reuse') {
+            if (decision.operation.status === 'uncertain') {
+                writeError(response, runtimeError('uncertain_operation', decision.operation.error ?? 'native_receipt_lost', {
+                    operationId: decision.operation.operationId,
+                }));
+                return;
+            }
+            writeJson(response, 200, decision.operation);
+            return;
+        }
+        if (parsed.data.kind === 'session.create') {
+            const creation = state.journal.findSessionCreation(parsed.data.sessionId);
+            const session = state.journal.getSession(parsed.data.sessionId);
+            if (creation || session) {
+                writeJson(response, 409, { error: 'session_already_bound' });
+                return;
+            }
+        }
+        else if (parsed.data.kind === 'terminal.create') {
+            const payload = asRecord(parsed.data.payload);
+            const terminalId = typeof payload.terminalId === 'string' ? payload.terminalId.trim() : '';
+            if (!terminalId) {
+                writeJson(response, 400, { error: 'invalid_operation', reason: 'terminalId_required' });
+                return;
+            }
+            const creation = state.journal.findTerminalCreation(terminalId);
+            const terminal = state.journal.getTerminal(terminalId);
+            if (creation && operationScopeKey(creation) !== scopeKey) {
+                writeJson(response, 409, { error: 'terminal_already_bound' });
+                return;
+            }
+            if (terminal && !creation) {
+                writeJson(response, 409, { error: 'terminal_already_bound' });
+                return;
+            }
+        }
+        else if (parsed.data.kind.startsWith('session.') && state.config.workspaceMode === 'multi') {
+            const session = state.journal.getSession(parsed.data.sessionId);
+            if (!session || session.workspaceId !== parsed.data.workspaceId) {
+                writeJson(response, 409, { error: 'session_workspace_mismatch' });
+                return;
+            }
+        }
+        const now = new Date().toISOString();
+        const executable = canExecuteKind(state, parsed.data.kind);
+        const payloadRecord = asRecord(parsed.data.payload);
+        const operation = {
+            operationId: randomUUID(),
+            environment: state.config.environment,
+            userId: state.config.userId,
+            clientRequestId: parsed.data.clientRequestId,
+            kind: parsed.data.kind,
+            status: executable ? 'queued' : 'failed',
+            payloadHash,
+            workspaceId: parsed.data.workspaceId,
+            sessionId: parsed.data.sessionId,
+            expectedRevision: parsed.data.expectedRevision,
+            generation: state.config.generation,
+            runtimeEpoch: state.runtimeEpoch,
+            leaseFence: incomingFence,
+            terminalId: parsed.data.kind === 'terminal.create' && typeof payloadRecord.terminalId === 'string'
+                ? payloadRecord.terminalId.trim()
+                : undefined,
+            cwd: parsed.data.kind === 'terminal.create' && typeof payloadRecord.cwd === 'string'
+                ? payloadRecord.cwd
+                : undefined,
+            error: executable ? undefined : 'capability_unavailable',
+            createdAt: now,
+            updatedAt: now,
+        };
+        if (!executable) {
+            const saved = await state.journal.putOperation(scopeKey, operation);
+            writeError(response, runtimeError('capability_unavailable', unavailableReason(state, parsed.data.kind), {
+                operationId: saved.operationId,
+            }));
+            return;
+        }
+        state.acceptedLeaseFence = Math.max(state.acceptedLeaseFence, incomingFence);
+        await state.journal.setAcceptedLeaseFence(state.acceptedLeaseFence);
+        const queued = await state.journal.putOperation(scopeKey, operation);
+        const executed = await executeOperation(state, scopeKey, queued, parsed.data.payload);
+        if (executed.status === 'uncertain') {
+            writeError(response, runtimeError('uncertain_operation', executed.error ?? 'native_receipt_lost', {
+                operationId: executed.operationId,
+            }));
+            return;
+        }
+        writeJson(response, executed.status === 'failed' ? 409 : 202, executed);
+    });
+    if (parsed.data.kind === 'session.create')
+        await state.journal.exclusive(`session:${parsed.data.sessionId}`, accept);
+    else if (parsed.data.kind === 'terminal.create') {
+        const terminalId = typeof asRecord(parsed.data.payload).terminalId === 'string'
+            ? String(asRecord(parsed.data.payload).terminalId).trim()
+            : '';
+        if (terminalId)
+            await state.journal.exclusive(`terminal:${terminalId}`, accept);
+        else
+            await accept();
+    }
+    else
+        await accept();
+}
+async function writeGitRead(state, response, read) {
+    if (writeDestroyed(state, response))
+        return;
+    if (!state.gitAvailable) {
+        writeError(response, runtimeError('capability_unavailable', 'git_binary_missing'));
+        return;
+    }
+    try {
+        writeJson(response, 200, await read());
+    }
+    catch (error) {
+        if (error instanceof GitWorkspaceError && error.code === 'invalid_workspace_path') {
+            writeJson(response, 400, { error: 'invalid_workspace_path' });
+            return;
+        }
+        const reason = error instanceof GitWorkspaceError ? error.code : 'git_command_failed';
+        writeError(response, runtimeError('capability_unavailable', reason));
+    }
+}
+async function rebuildInstanceFiles(state, request, response) {
+    if (writeDestroyed(state, response))
+        return;
+    if (state.journal.fileCheckpointId() || state.journal.listSessions().length > 0) {
+        writeJson(response, 409, { status: 'failed', error: 'instance_still_alive', nativeContinuable: false });
+        return;
+    }
+    const parsed = instanceRebuildRequestSchema.safeParse(await readJson(request));
+    if (!parsed.success) {
+        writeJson(response, 400, { status: 'failed', error: 'snapshot_mismatch', nativeContinuable: false });
+        return;
+    }
+    try {
+        const root = await workspaceRoot(state, parsed.data.workspaceId);
+        const materialized = await materializeRemoteSnapshot(root, parsed.data.entries);
+        state.rebuildGate = {
+            directoryReady: materialized.directoryReady,
+            repositoryReady: materialized.repositoryReady,
+            environmentReady: materialized.environmentReady,
+        };
+        writeJson(response, 200, {
+            status: 'completed',
+            snapshotId: parsed.data.snapshotId,
+            nativeContinuable: false,
+            filesRestored: true,
+            skipped: materialized.skipped,
+            directoryReady: materialized.directoryReady,
+            repositoryReady: materialized.repositoryReady,
+            environmentReady: materialized.environmentReady,
+        });
+    }
+    catch (error) {
+        const reason = error instanceof Error && error.message === 'snapshot_mismatch' ? 'snapshot_mismatch' : 'snapshot_mismatch';
+        writeJson(response, 409, { status: 'failed', error: reason, nativeContinuable: false });
+    }
+}
+async function readJson(request) {
+    const chunks = [];
+    for await (const chunk of request) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    if (chunks.length === 0)
+        return {};
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function writeDestroyed(state, response) {
+    if (!state.journal.destroyed())
+        return false;
+    writeError(response, runtimeError('capability_unavailable', 'runtime_destroyed'));
+    return true;
+}
+async function handleTerminalIdentity(state, request, response, remainder) {
+    if (writeDestroyed(state, response))
+        return;
+    const [terminalId, action] = remainder.split('/');
+    if (!terminalId || action && action !== 'connect') {
+        writeJson(response, 404, { error: 'not_found' });
+        return;
+    }
+    const terminal = state.journal.getTerminal(terminalId);
+    if (!terminal) {
+        writeJson(response, 404, { error: 'terminal_not_found' });
+        return;
+    }
+    if (request.method === 'GET' && action === 'connect') {
+        if (terminal.status === 'destroyed') {
+            writeError(response, runtimeError('capability_unavailable', 'terminal_destroyed'));
+            return;
+        }
+        writeError(response, runtimeError('capability_unavailable', 'pty_not_started'));
+        return;
+    }
+    if (request.method === 'GET' && !action) {
+        writeJson(response, 200, terminal);
+        return;
+    }
+    if (request.method === 'DELETE' && !action) {
+        const destroyed = terminal.status === 'destroyed'
+            ? terminal
+            : await state.journal.putTerminal({
+                ...terminal,
+                status: 'destroyed',
+                destroyedAt: new Date().toISOString(),
+            });
+        writeJson(response, 200, { terminalId: destroyed.terminalId, status: destroyed.status });
+        return;
+    }
+    writeJson(response, 404, { error: 'not_found' });
+}
+function unavailableReason(state, kind) {
+    if (state.journal.destroyed())
+        return 'runtime_destroyed';
+    if (kind === 'preview.publish')
+        return 'capability_not_implemented';
+    return 'adapter_not_started';
+}
+function isUnimplementedWorkbenchPath(pathname) {
+    const parts = pathname.split('/').filter(Boolean);
+    return parts[0] === 'runtime' && (parts.includes('previews') || parts.includes('history'));
+}
+async function readObservedParameters(state, workspaceId) {
+    const root = await workspaceRoot(state, workspaceId);
+    const scope = revisionScope(state, workspaceId);
+    const first = await readWorkspaceParameters(root, state.journal.fileRevisions(scope));
+    for (const path of [first.schemaPath, first.dataPath]) {
+        if (path)
+            await withObservedFile(state, workspaceId, path, async () => undefined);
+    }
+    return readWorkspaceParameters(root, state.journal.fileRevisions(scope));
+}
+function writeError(response, error) {
+    writeJson(response, HTTP_STATUS_BY_ERROR[error.code], error);
+}
+function writeJson(response, status, body) {
+    const payload = JSON.stringify(body);
+    response.writeHead(status, {
+        'content-type': 'application/json; charset=utf-8',
+        'content-length': Buffer.byteLength(payload),
+    });
+    response.end(payload);
+}
+function asRecord(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+}