@playcraft/cli 0.1.53-beta → 0.1.54

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

@@ -1,53 +0,0 @@
-import { closeSync, constants, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-export class RuntimeProcessLock {
-    filePath;
-    fd = null;
-    constructor(stateDir) {
-        this.filePath = join(stateDir, 'workspace-runtime.lock');
-    }
-    acquire() {
-        mkdirSync(dirname(this.filePath), { recursive: true, mode: 0o700 });
-        try {
-            this.fd = openSync(this.filePath, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, 0o600);
-            writeFileSync(this.fd, String(process.pid));
-            return;
-        }
-        catch (error) {
-            if (error.code !== 'EEXIST')
-                throw error;
-        }
-        const existing = Number.parseInt(readFileSync(this.filePath, 'utf8'), 10);
-        if (Number.isInteger(existing) && processAlive(existing)) {
-            throw Object.assign(new Error(`workspace-runtime already running as pid ${existing}`), {
-                code: 'duplicate_instance',
-            });
-        }
-        unlinkSync(this.filePath);
-        this.acquire();
-    }
-    release() {
-        if (this.fd !== null) {
-            closeSync(this.fd);
-            this.fd = null;
-        }
-        try {
-            if (readFileSync(this.filePath, 'utf8').trim() === String(process.pid)) {
-                unlinkSync(this.filePath);
-            }
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT')
-                throw error;
-        }
-    }
-}
-function processAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}

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

@@ -1,33 +0,0 @@
-import { randomUUID } from 'node:crypto';
-/** One construction point for operation records so HTTP and in-sandbox callers cannot drift. */
-export function buildOperationRecord(state, parsed, payloadHash, leaseFence, executable = true) {
-    const now = new Date().toISOString();
-    const payload = parsed.payload && typeof parsed.payload === 'object' && !Array.isArray(parsed.payload)
-        ? parsed.payload
-        : {};
-    return {
-        operationId: randomUUID(),
-        environment: state.config.environment,
-        userId: state.config.userId,
-        clientRequestId: parsed.clientRequestId,
-        kind: parsed.kind,
-        status: executable ? 'queued' : 'failed',
-        payloadHash,
-        workspaceId: parsed.workspaceId,
-        directoryName: parsed.directoryName,
-        sessionId: parsed.sessionId,
-        expectedRevision: parsed.expectedRevision,
-        generation: state.config.generation,
-        runtimeEpoch: state.runtimeEpoch,
-        leaseFence,
-        terminalId: parsed.kind === 'terminal.create' && typeof payload.terminalId === 'string'
-            ? payload.terminalId.trim()
-            : undefined,
-        cwd: parsed.kind === 'terminal.create' && typeof payload.cwd === 'string'
-            ? payload.cwd
-            : undefined,
-        error: executable ? undefined : 'capability_unavailable',
-        createdAt: now,
-        updatedAt: now,
-    };
-}

package/dist/workspace-runtime/server/rfb-watch-gate.js

@@ -1,168 +0,0 @@
-/**
- * RFB (Remote Framebuffer, 远程帧缓冲) viewing needs a handshake and picture requests.
- * This gate supports the sandbox's version 3.8 / None security negotiation.
- * Input requires a hold for the entire message; unsupported framing closes the stream.
- */
-const INPUT_TYPES = new Set([4, 5, 6, 250, 251, 255]);
-const VERSION = Buffer.from('RFB 003.008\n');
-const MAX_CLIPBOARD_BYTES = 1_000_000;
-export function createRfbWatchGate() {
-    let server = Buffer.alloc(0);
-    let client = Buffer.alloc(0);
-    let phase = 'server-version';
-    let messageInputAllowed = false;
-    const fail = () => {
-        phase = 'failed';
-        server = Buffer.alloc(0);
-        client = Buffer.alloc(0);
-    };
-    const observeServer = (chunk) => {
-        if (phase === 'ready' || phase === 'failed')
-            return;
-        let offset = 0;
-        while (offset < chunk.length) {
-            let size = serverMessageSize(server, phase);
-            if (size === 'invalid') {
-                fail();
-                return;
-            }
-            const count = Math.min(size - server.length, chunk.length - offset);
-            server = Buffer.concat([server, chunk.subarray(offset, offset + count)]);
-            offset += count;
-            size = serverMessageSize(server, phase);
-            if (size === 'invalid') {
-                fail();
-                return;
-            }
-            if (server.length < size)
-                continue;
-            if (phase === 'server-version' && server.equals(VERSION))
-                phase = 'client-version';
-            else if (phase === 'server-types' && server.subarray(1).includes(1))
-                phase = 'client-security';
-            else if (phase === 'server-result' && server.readUInt32BE(0) === 0)
-                phase = 'client-init';
-            else if (phase === 'server-init')
-                phase = 'ready';
-            else {
-                fail();
-                return;
-            }
-            server = Buffer.alloc(0);
-            // The first picture can share the ServerInit chunk; it needs no buffering.
-            if (phase === 'ready')
-                return;
-        }
-    };
-    const clientBytes = (chunk, allowInput) => {
-        if (phase === 'failed')
-            return [];
-        const outgoing = [];
-        let offset = 0;
-        if (client.length > 0)
-            messageInputAllowed &&= allowInput;
-        while (offset < chunk.length) {
-            if (client.length === 0)
-                messageInputAllowed = allowInput;
-            let size = phase === 'client-version' ? 12
-                : phase === 'client-security' || phase === 'client-init' ? 1
-                    : phase === 'server-init' || phase === 'ready' ? clientMessageSize(client)
-                        : 'invalid';
-            if (size === 'invalid') {
-                fail();
-                return [];
-            }
-            const count = Math.min(size - client.length, chunk.length - offset);
-            client = Buffer.concat([client, chunk.subarray(offset, offset + count)]);
-            offset += count;
-            if (phase === 'server-init' || phase === 'ready')
-                size = clientMessageSize(client);
-            if (size === 'invalid') {
-                fail();
-                return [];
-            }
-            if (client.length < size)
-                continue;
-            if (phase === 'client-version' && client.equals(VERSION))
-                phase = 'server-types';
-            else if (phase === 'client-security' && client[0] === 1)
-                phase = 'server-result';
-            else if (phase === 'client-init' && client[0] <= 1)
-                phase = 'server-init';
-            else if (phase !== 'server-init' && phase !== 'ready') {
-                fail();
-                return [];
-            }
-            else if (INPUT_TYPES.has(client[0]) && !messageInputAllowed) {
-                client = Buffer.alloc(0);
-                continue;
-            }
-            outgoing.push(client);
-            client = Buffer.alloc(0);
-        }
-        return outgoing;
-    };
-    return { get failed() { return phase === 'failed'; }, observeServer, clientBytes };
-}
-function serverMessageSize(buffer, phase) {
-    if (phase === 'server-version')
-        return 12;
-    if (phase === 'server-types') {
-        if (buffer.length < 1)
-            return 1;
-        return buffer[0] === 0 ? 'invalid' : 1 + buffer[0];
-    }
-    if (phase === 'server-result')
-        return 4;
-    if (phase === 'server-init') {
-        if (buffer.length < 24)
-            return 24;
-        const length = buffer.readUInt32BE(20);
-        return length > 4096 ? 'invalid' : 24 + length;
-    }
-    return 'invalid';
-}
-function clientMessageSize(buffer) {
-    if (buffer.length === 0)
-        return 1;
-    const type = buffer[0];
-    if (type === 0)
-        return 20;
-    if (type === 3 || type === 150)
-        return 10;
-    if (type === 4)
-        return 8;
-    if (type === 5)
-        return 6;
-    if (type === 250)
-        return 4;
-    if (type === 2) {
-        if (buffer.length < 4)
-            return 4;
-        const count = buffer.readUInt16BE(2);
-        return count > 64 ? 'invalid' : 4 + count * 4;
-    }
-    if (type === 6) {
-        if (buffer.length < 8)
-            return 8;
-        // Extended clipboard messages encode their payload size as a negative length.
-        const length = Math.abs(buffer.readInt32BE(4));
-        return length > MAX_CLIPBOARD_BYTES ? 'invalid' : 8 + length;
-    }
-    if (type === 248) {
-        if (buffer.length < 9)
-            return 9;
-        return buffer[8] > 64 ? 'invalid' : 9 + buffer[8];
-    }
-    if (type === 251) {
-        if (buffer.length < 8)
-            return 8;
-        return buffer[6] > 16 ? 'invalid' : 8 + buffer[6] * 16;
-    }
-    if (type === 255) {
-        if (buffer.length < 2)
-            return 2;
-        return buffer[1] === 0 ? 12 : 'invalid';
-    }
-    return 'invalid';
-}

package/dist/workspace-runtime/server/session-restore.js

@@ -1,84 +0,0 @@
-import { productionSessionAttemptId, } from '@playcraft/common/cloud-workspace/runtime';
-import { NativePreparationError } from '../codex/native-adapter.js';
-import { sessionWorkspaceRoot } from '../workspaces/registry.js';
-export class SessionRestoreError extends Error {
-}
-/** Called under the directory's workspace lock, without replaying old operations or turns. */
-export async function restoreNativeSession(state, scope, input) {
-    // The Codex home contains threads from every workspace owned by this runtime identity.
-    // Serialize their mapping checks across directories, not only within one checkout.
-    return state.journal.exclusive('native-session-bindings', async () => {
-        const checkRuntime = () => {
-            if (state.journal.destroyed())
-                throw new SessionRestoreError('runtime_destroyed');
-            if (input.generation !== state.config.generation)
-                throw new SessionRestoreError('generation_mismatch');
-            if (input.runtimeEpoch !== state.runtimeEpoch)
-                throw new SessionRestoreError('runtime_epoch_mismatch');
-            const group = state.journal.executionGroup();
-            if (group.replaced && !group.stopConfirmed)
-                throw new SessionRestoreError('native_not_recoverable');
-        };
-        checkRuntime();
-        if (productionSessionAttemptId(scope.sessionId))
-            throw new SessionRestoreError('production_session_readonly');
-        const directoryName = scope.directoryName ?? 'basic';
-        const cwd = await sessionWorkspaceRoot(state, scope.workspaceId, directoryName);
-        const binding = state.journal.getSession(scope.sessionId);
-        if (binding && (binding.workspaceId !== scope.workspaceId || (binding.directoryName ?? 'basic') !== directoryName))
-            throw new SessionRestoreError('session_workspace_mismatch');
-        if (binding && binding.threadId !== input.threadId)
-            throw new SessionRestoreError('session_thread_mismatch');
-        if (binding && (binding.turnBlock === 'uncertain' || ['starting', 'running', 'waiting_for_user'].includes(binding.turnStatus ?? '')))
-            throw new SessionRestoreError('turn_already_active');
-        if (state.journal.listSessions().some(session => session.threadId === input.threadId && session.sessionId !== scope.sessionId))
-            throw new SessionRestoreError('thread_already_bound');
-        const adapter = state.native;
-        const resume = adapter?.resumeThread;
-        if (!resume)
-            throw new SessionRestoreError('native_not_recoverable');
-        const modelConfigId = input.modelConfigId ?? binding?.modelConfigId;
-        const reasoningEffort = input.reasoningEffort ?? binding?.reasoningEffort;
-        const permissionMode = input.permissionMode ?? binding?.permissionMode ?? 'auto';
-        let resumed;
-        try {
-            // The adapter accepts only a reply naming this exact thread, and reapplies current settings.
-            resumed = await resume.call(adapter, { sessionId: scope.sessionId, threadId: input.threadId, cwd,
-                modelConfigId, reasoningEffort, permissionMode });
-        }
-        catch (error) {
-            if (error instanceof NativePreparationError)
-                throw new SessionRestoreError(error.message);
-            throw error;
-        }
-        if (!resumed)
-            throw new SessionRestoreError('native_not_recoverable');
-        // A crash or destruction during the native request must not publish a stale binding.
-        checkRuntime();
-        const next = {
-            ...binding,
-            sessionId: scope.sessionId,
-            workspaceId: scope.workspaceId,
-            directoryName,
-            threadId: input.threadId,
-            cwd,
-            recoverability: 'native',
-            modelConfigId: resumed.modelConfigId ?? modelConfigId,
-            reasoningEffort: resumed.reasoningEffort ?? reasoningEffort,
-            permissionMode: resumed.permissionMode ?? permissionMode,
-            turnStatus: undefined,
-            turnBlock: undefined,
-            activeTurnId: undefined,
-            recoveryContextPending: undefined,
-        };
-        await state.journal.putSession(next);
-        try {
-            checkRuntime();
-        }
-        catch (error) {
-            await state.journal.putSession({ ...next, recoverability: 'history_only' });
-            throw error;
-        }
-        return next;
-    });
-}

package/dist/workspace-runtime/server/source-uploader.js

@@ -1,138 +0,0 @@
-import { PLATFORM_ROUTES, platformEndpoint } from '@playcraft/common/cloud-workspace/runtime';
-const uploaders = new WeakMap();
-/** The existing journal and cloud acknowledgement are the outbox and its only delivery cursor. */
-export class SourceEventUploader {
-    state;
-    options;
-    timer;
-    request;
-    requestScope;
-    running = false;
-    closed = false;
-    requested = false;
-    failures = 0;
-    hintedHistoryScope;
-    observedScope;
-    unsubscribe;
-    constructor(state, options = {}) {
-        this.state = state;
-        this.options = options;
-        this.observedScope = this.scope();
-        this.unsubscribe = state.journal.onSourceEvent(() => this.wake());
-        this.wake();
-    }
-    wake() {
-        if (this.closed)
-            return;
-        const scope = this.scope();
-        if (this.observedScope !== scope) {
-            this.observedScope = scope;
-            this.failures = 0;
-            clearTimeout(this.timer);
-            this.timer = undefined;
-            this.request?.abort();
-        }
-        this.requested = true;
-        if (!this.running && !this.timer)
-            this.schedule(0);
-    }
-    close() {
-        this.closed = true;
-        this.unsubscribe();
-        clearTimeout(this.timer);
-        this.timer = undefined;
-        this.request?.abort();
-    }
-    scope() {
-        const { config, runtimeEpoch } = this.state;
-        return JSON.stringify([config.runtimeId, config.generation, runtimeEpoch, config.publicBaseUrl, config.controlToken]);
-    }
-    schedule(delay) {
-        if (this.closed || this.timer)
-            return;
-        this.timer = setTimeout(() => {
-            this.timer = undefined;
-            void this.upload();
-        }, delay);
-        this.timer.unref?.();
-    }
-    async upload() {
-        if (this.closed || this.running)
-            return;
-        this.running = true;
-        this.requested = false;
-        try {
-            while (!this.closed) {
-                const { runtimeId, generation, publicBaseUrl, controlToken } = this.state.config;
-                const runtimeEpoch = this.state.runtimeEpoch;
-                const identity = { runtimeId, generation, runtimeEpoch };
-                const epoch = this.state.journal.epochsSnapshot().find(item => item.runtime_id === runtimeId &&
-                    item.generation === generation && item.runtime_epoch === runtimeEpoch);
-                if (!epoch || epoch.cloud_ack_through >= epoch.local_durable_through) {
-                    const history = this.state.journal.epochsSnapshot().filter(item => item.runtime_id === runtimeId &&
-                        item.generation === generation && item.runtime_epoch < runtimeEpoch && item.cloud_ack_through < item.local_durable_through);
-                    const historyScope = `${this.scope()}:${this.state.journal.executionGroup().stopConfirmed}:${this.state.journal.stoppedRuntimeEpochs().join(',')}`;
-                    if (!history.length || this.hintedHistoryScope === historyScope)
-                        return;
-                    await this.state.journal.allocateSourceEvent({ ...identity, type: 'runtime.source.pending',
-                        payload: { runtimeId, epochs: history.map(item => ({ runtimeEpoch: item.runtime_epoch, highWater: item.local_durable_through })) },
-                        occurredAt: new Date().toISOString() });
-                    this.hintedHistoryScope = historyScope;
-                    continue;
-                }
-                const page = this.state.journal.readSourcePage({ ...identity, after: epoch.cloud_ack_through, limit: 100 });
-                if (!page.ok || page.events.length === 0)
-                    throw new Error('source_gap');
-                this.requestScope = this.scope();
-                this.request = new AbortController();
-                const response = await (this.options.fetchImpl ?? fetch)(platformEndpoint(publicBaseUrl, PLATFORM_ROUTES.events), {
-                    method: 'POST', redirect: 'error',
-                    signal: AbortSignal.any([this.request.signal, AbortSignal.timeout(this.options.requestTimeoutMs ?? 5000)]),
-                    headers: { authorization: `Bearer ${controlToken}`, 'x-playcraft-control-token': controlToken, 'content-type': 'application/json' },
-                    body: JSON.stringify({ ...identity, events: page.events }),
-                });
-                await response.body?.cancel();
-                if (this.closed)
-                    return;
-                if (this.requestScope !== this.scope())
-                    continue;
-                if (!response.ok)
-                    throw new Error(`callback_${response.status}`);
-                const confirmed = this.state.journal.epochsSnapshot().find(item => item.runtime_id === runtimeId &&
-                    item.generation === generation && item.runtime_epoch === runtimeEpoch)?.cloud_ack_through ?? 0;
-                // A successful callback is only a wakeup. Its response never substitutes for the fenced acknowledgement.
-                if (confirmed <= epoch.cloud_ack_through)
-                    throw new Error('awaiting_ack');
-                this.failures = 0;
-            }
-        }
-        catch {
-            if (!this.closed) {
-                const changed = this.requestScope !== undefined && this.requestScope !== this.scope();
-                this.failures = changed ? 0 : this.failures + 1;
-                this.schedule(changed ? 0 : this.options.retryDelayMs?.(this.failures) ?? Math.min(30_000, 1000 * 2 ** Math.min(5, this.failures - 1)));
-            }
-        }
-        finally {
-            this.running = false;
-            this.request = undefined;
-            this.requestScope = undefined;
-            if (this.requested && !this.timer)
-                this.schedule(0);
-        }
-    }
-}
-export function startSourceEventUploader(state, options) {
-    let uploader = uploaders.get(state);
-    if (!uploader) {
-        uploader = new SourceEventUploader(state, options);
-        uploaders.set(state, uploader);
-    }
-    return uploader;
-}
-export function wakeSourceEventUploader(state) {
-    uploaders.get(state)?.wake();
-}
-export function stopSourceEventUploader(state) {
-    uploaders.get(state)?.close();
-}

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

@@ -1,41 +0,0 @@
-import { operationAcceptRequestSchema, } from '@playcraft/common/cloud-workspace/runtime';
-import { batchDirectoryHeld } from '../batch/occupancy.js';
-import { acceptOperationCore } from './accept-operation.js';
-export class SubmitOperationError extends Error {
-    code;
-    constructor(code) {
-        super(code);
-        this.code = code;
-        this.name = 'SubmitOperationError';
-    }
-}
-/**
- * Accepts an operation from a trusted in-sandbox caller (an Agent tool or a future runtime
- * feature) with the same idempotency and lease semantics as the HTTP control plane.
- */
-export async function submitTrustedOperation(state, input) {
-    const directoryName = input.directoryName ?? 'basic';
-    if (directoryName === 'root')
-        throw new SubmitOperationError('invalid_workspace_directory');
-    const parsed = operationAcceptRequestSchema.safeParse({
-        clientRequestId: input.clientRequestId,
-        kind: input.kind,
-        workspaceId: input.workspaceId,
-        directoryName,
-        ...(input.sessionId ? { sessionId: input.sessionId } : {}),
-        ...(input.expectedRevision !== undefined ? { expectedRevision: input.expectedRevision } : {}),
-        payload: input.payload,
-    });
-    if (!parsed.success)
-        throw new SubmitOperationError('invalid_operation');
-    if (await batchDirectoryHeld(state, input.workspaceId, directoryName)) {
-        throw new SubmitOperationError('batch_workspace_readonly');
-    }
-    const result = await acceptOperationCore(state, parsed.data, {
-        leaseFence: state.acceptedLeaseFence,
-        executionPayload: parsed.data.payload,
-    });
-    if (result.rejected)
-        throw new SubmitOperationError(String(result.refusal.body.error ?? 'operation_failed'));
-    return result.reused ? result.operation : result.executed;
-}