@playcraft/cli 0.1.42 → 0.1.44-beta

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

@@ -0,0 +1,53 @@
+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/rfb-watch-gate.js

@@ -0,0 +1,168 @@
+/**
+ * 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

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,138 @@
+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();
+}