@playcraft/cli 0.1.57-beta → 0.1.58-beta

package/dist/workspace-runtime/previews/publish.js

@@ -17,6 +17,7 @@ import { openScratchToDevelopment } from '../workspaces/directory-access.js';
 import { injectPreviewDiagnostics } from './diagnostics.js';
 import { OperationLogStore } from '../workspaces/operation-log.js';
 import { prepareRuntimePreview, RuntimePreviewBuildError } from './runtime-preview.js';
+import { driftScope, permissionDriftFromOutput, repairWorkspaceShares, } from '../workspaces/workspace-shares.js';
 const BUILD_TIMEOUT_MS = 10 * 60_000;
 /** Build output and the builder's own scratch folder live in the checkout, hidden from Git. */
 const OUTPUT_FOLDER = '.playcraft-preview-out';
@@ -60,12 +61,12 @@ export function trackPreviewPublish(state, task) {
 export async function settlePreviewPublishes(state) {
     await Promise.all([...(running.get(state) ?? [])]);
 }
-/** A publish cut off by a restart has no build left running; it is closed rather than left accepted. */
+/** Restart alone does not prove the old builder stopped; retain its exclusive directory claim. */
 export async function recoverInterruptedPreviews(journal) {
     for (const { scopeKey, operation } of journal.listOperations()) {
         if (operation.kind !== 'preview.publish' || operation.status !== 'accepted')
             continue;
-        await journal.putOperation(scopeKey, transitionOperation(operation, 'interrupted', { error: 'preview_interrupted' }));
+        await journal.putOperation(scopeKey, transitionOperation(operation, 'uncertain', { error: 'preview_interrupted' }));
     }
 }
 export async function runPreviewPublish(state, operation, root) {
@@ -215,7 +216,7 @@ async function ensureDependencies(state, workspaceId, root, output) {
 async function buildPreview(state, root, outputDir, operationId, output, onLog, runtimeCommand) {
     // Tests replace the build; the real one needs a project and the published CLI.
     const planned = process.env.PLAYCRAFT_PREVIEW_BUILD_COMMAND || BUILD_COMMAND;
-    const outcome = await runDeveloperCommand(state, {
+    const run = () => runDeveloperCommand(state, {
         processId: `preview-${operationId}`,
         cwd: root,
         command: runtimeCommand ?? `${planned} --output ${shellQuote(outputDir)} .`,
@@ -226,8 +227,22 @@ async function buildPreview(state, root, outputDir, operationId, output, onLog,
             onLog?.(text);
         },
     });
-    if (outcome.code !== 0)
-        throw new PreviewFailure('preview_build_failed');
+    let outcome = await run();
+    if (outcome.code === undefined)
+        throw new PreviewFailure('preview_process_unknown');
+    if (outcome.code !== 0) {
+        // The build runs as the development identity; a directory only that identity can repair makes
+        // it fail on its own cwd. Repair the shared subtree as its owner and retry exactly once.
+        const drift = permissionDriftFromOutput(output.log);
+        if (drift) {
+            await repairWorkspaceShares(state, root, await driftScope(root, drift.path)).catch(() => undefined);
+            outcome = await run();
+            if (outcome.code === undefined)
+                throw new PreviewFailure('preview_process_unknown');
+        }
+        if (outcome.code !== 0)
+            throw new PreviewFailure(drift ? 'workspace_permission_drift' : 'preview_build_failed');
+    }
 }
 /** Reads the one HTML file without following links, so the uploaded bytes are what was checked. */
 async function readSingleHtml(outputDir) {

package/dist/workspace-runtime/previews/runtime-preview.js

@@ -166,6 +166,8 @@ export async function prepareRuntimePreview(state, operation, root) {
             dataRevision: before.dataRevision ?? 0,
             schemaRevision: before.schemaRevision ?? 0,
             dataHash: before.dataHash,
+            ...(before.runtimeI18n ? { runtimeI18nRevision: before.runtimeI18n.themeRevision,
+                ...(before.runtimeI18n.themeHash ? { runtimeI18nHash: before.runtimeI18n.themeHash } : {}) } : {}),
         },
     };
     const context = { buildId, ...profileBase };
@@ -187,6 +189,8 @@ export async function prepareRuntimePreview(state, operation, root) {
                 after.schemaHash !== before.schemaHash ||
                 after.dataRevision !== before.dataRevision ||
                 after.schemaRevision !== before.schemaRevision ||
+                after.runtimeI18n?.themeHash !== before.runtimeI18n?.themeHash ||
+                after.runtimeI18n?.themeRevision !== before.runtimeI18n?.themeRevision ||
                 digest(await insideFile(root, manifestPath)) !== digest(manifest))
                 throw new RuntimePreviewBuildError('runtime_preview_source_changed');
             for (const [path, hash] of gameHashes) {

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

@@ -1,5 +1,6 @@
 import { spawn } from 'node:child_process';
 import { setTimeout as delay } from 'node:timers/promises';
+import { holdDirectoryAccess, managedDirectoryScope } from '../server/directory-access.js';
 export const MANAGED_WRITE_SOURCES = ['manual', 'agent', 'background'];
 const BACKGROUND_WRITER = `
 const fs = require('node:fs');
@@ -23,16 +24,48 @@ export function probeProcess(pid) {
         return undefined;
     }
 }
-export function spawnBackgroundWriter(absolutePath) {
+export function spawnBackgroundWriter(absolutePath, stopped) {
     const child = spawn(process.execPath, ['-e', BACKGROUND_WRITER, absolutePath], {
         detached: true,
         stdio: 'ignore',
     });
     child.unref();
+    child.once('error', () => undefined);
+    child.once('exit', () => stopped?.());
     if (!child.pid)
         throw new Error('background_write_failed');
     return child.pid;
 }
+/** A writer keeps its directory claim after the request that created it has finished. */
+export async function startManagedBackgroundWriter(state, record, absolutePath) {
+    if (state.journal.listManagedWrites().some(item => item.writeId === record.writeId && !item.stoppedAt))
+        throw new Error('write_already_active');
+    const release = await holdDirectoryAccess(state, managedDirectoryScope(state, record.workspaceId), `managed:${record.writeId}`, 'shared');
+    let pid;
+    let persisted = Promise.resolve();
+    const finish = async () => {
+        await persisted;
+        const current = state.journal.listManagedWrites().find(item => item.writeId === record.writeId);
+        if (current && current.startedAt === record.startedAt && !current.stoppedAt) {
+            await state.journal.putManagedWrite({ ...current, stoppedAt: new Date().toISOString() });
+        }
+        release();
+    };
+    try {
+        await state.journal.putManagedWrite(record);
+        pid = spawnBackgroundWriter(absolutePath, () => { void finish().catch(() => undefined); });
+        persisted = state.journal.putManagedWrite({ ...record, pid });
+        await persisted;
+        return pid;
+    }
+    catch (error) {
+        if (pid === undefined || await stopBackgroundWriter(pid)) {
+            persisted = Promise.resolve();
+            await finish();
+        }
+        throw error;
+    }
+}
 export async function stopBackgroundWriter(pid) {
     signal(pid, 'SIGTERM');
     if (await waitUntilStopped(pid, 2_000))
@@ -58,12 +91,21 @@ function signal(pid, name) {
 async function waitUntilStopped(pid, timeoutMs) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
-        const alive = probeProcess(pid);
+        const alive = probeProcessGroup(pid);
         if (alive === false)
             return true;
-        if (alive === undefined)
-            return false;
         await delay(50);
     }
-    return probeProcess(pid) === false;
+    return probeProcessGroup(pid) === false;
+}
+function probeProcessGroup(pid) {
+    try {
+        process.kill(-pid, 0);
+        return true;
+    }
+    catch (error) {
+        if (error.code !== 'ESRCH')
+            return undefined;
+        return probeProcess(pid);
+    }
 }

package/dist/workspace-runtime/serve.js

@@ -8,7 +8,8 @@ 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 { attachNativeCollector, executeOperation, recoverInterruptedParameterVerifications, stopParameterVerifications } from './server/dispatch.js';
+import { restoreDeferredDirectoryOperations } from './server/directory-access.js';
 import { handleRuntimeRequest } from './server/http.js';
 import { desktopHost, disposeDesktopHost } from './server/desktop-host.js';
 import { disposeTerminalHost, terminalHost } from './server/terminal-host.js';
@@ -57,7 +58,8 @@ export async function startWorkspaceRuntime(config, options = {}) {
         await recoverInterruptedPreviews(journal);
         await recoverInterruptedParameterVerifications(journal);
         await recoverInterruptedDeliveries(config.stateDir);
-        await mkdir(config.workspaceRoot, { recursive: true, mode: 0o700 });
+        // shared: in multi-workspace mode this is /workspaces, the container both identities traverse.
+        await mkdir(config.workspaceRoot, { recursive: true, mode: 0o2770 });
         const state = runtimeState = {
             config: { ...config, protocolMinor: negotiated.protocolMinor },
             configPath: options.configPath,
@@ -99,6 +101,8 @@ export async function startWorkspaceRuntime(config, options = {}) {
         for (const { scopeKey, operation } of journal.listOperations()) {
             if (operation.kind !== 'asset.library.import' || !['queued', 'dispatched', 'accepted', 'uncertain'].includes(operation.status))
                 continue;
+            if (operation.status === 'queued' && journal.deferredDirectoryOperations().some(item => item.operationId === operation.operationId))
+                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 ?? [])])],
@@ -150,6 +154,8 @@ export async function startWorkspaceRuntime(config, options = {}) {
         for (const { scopeKey, operation } of journal.listOperations()) {
             if (operation.kind !== 'asset.bundle.save' || !['queued', 'dispatched', 'accepted', 'uncertain'].includes(operation.status))
                 continue;
+            if (operation.status === 'queued' && journal.deferredDirectoryOperations().some(item => item.operationId === operation.operationId))
+                continue;
             const recovered = recoveredBundles.get(operation.operationId), receipt = recovered?.receipt;
             let next = operation;
             if (receipt) {
@@ -181,6 +187,8 @@ export async function startWorkspaceRuntime(config, options = {}) {
             if (!['directory.rename', 'directory.delete'].includes(operation.kind)
                 || !['queued', 'dispatched', 'accepted', 'uncertain'].includes(operation.status))
                 continue;
+            if (operation.status === 'queued' && journal.deferredDirectoryOperations().some(item => item.operationId === operation.operationId))
+                continue;
             const kind = operation.kind;
             let next = operation;
             try {
@@ -272,6 +280,7 @@ export async function startWorkspaceRuntime(config, options = {}) {
             state.nativeError = code === 'codex_model_catalog_unavailable' ? code : 'codex_start_failed';
             console.error(`[workspace-runtime] ${state.nativeError}`);
         }
+        await restoreDeferredDirectoryOperations(state, (scopeKey, operation, payload, recovery) => executeOperation(state, scopeKey, operation, payload, recovery));
         const server = createServer((request, response) => {
             void handleRuntimeRequest(state, request, response);
         });

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

@@ -1,4 +1,4 @@
-import { assertLeaseFence, hashOperationPayload, isLostThreadError, operationScopeKey, resolveIdempotentAccept, runtimeError, } from '@playcraft/common/cloud-workspace/runtime';
+import { assertLeaseFence, hashOperationPayload, isLostThreadError, operationScopeKey, resolveIdempotentAccept, runtimeError, takesWorkspaceDirectory, isTurnControl, } from '@playcraft/common/cloud-workspace/runtime';
 import { canExecuteKind, executeOperation } from './dispatch.js';
 import { buildOperationRecord } from './operation-record.js';
 /**
@@ -29,6 +29,18 @@ export async function acceptOperationCore(state, parsed, options) {
                 operationId: decision.operation.operationId,
             }));
         }
+        if (decision.action === 'reuse' && parsed.gatewayOperationId) {
+            if (decision.operation.gatewayOperationId && decision.operation.gatewayOperationId !== parsed.gatewayOperationId) {
+                return rejected(409, runtimeError('idempotency_conflict', 'gateway_operation_mismatch', {
+                    operationId: decision.operation.operationId,
+                }));
+            }
+            if (!decision.operation.gatewayOperationId) {
+                decision.operation = await state.journal.putOperation(scopeKey, {
+                    ...decision.operation, gatewayOperationId: parsed.gatewayOperationId,
+                });
+            }
+        }
         const retryWithRecovery = decision.action === 'reuse' && parsed.kind === 'session.turn'
             && Boolean(parsed.sessionRecovery) && decision.operation.status === 'failed'
             && isLostThreadError(decision.operation.error);
@@ -38,6 +50,12 @@ export async function acceptOperationCore(state, parsed, options) {
                     operationId: decision.operation.operationId,
                 }));
             }
+            if (decision.operation.status === 'queued' && takesWorkspaceDirectory(decision.operation.kind) &&
+                !isTurnControl(decision.operation.kind) && !state.journal.deferredDirectoryOperations().some(item => item.operationId === decision.operation.operationId)) {
+                const queued = await state.journal.putPendingOperation(scopeKey, decision.operation, options.executionPayload, parsed.sessionRecovery);
+                const executed = await executeOperation(state, scopeKey, queued, options.executionPayload, parsed.sessionRecovery);
+                return { rejected: false, operation: executed, executed, reused: true };
+            }
             return { rejected: false, operation: decision.operation, executed: decision.operation, reused: true };
         }
         const validation = await options.validate?.(scopeKey);
@@ -51,7 +69,9 @@ export async function acceptOperationCore(state, parsed, options) {
         }
         state.acceptedLeaseFence = Math.max(state.acceptedLeaseFence, options.leaseFence);
         await state.journal.setAcceptedLeaseFence(state.acceptedLeaseFence);
-        const queued = await state.journal.putOperation(scopeKey, operation);
+        const queued = takesWorkspaceDirectory(operation.kind) && !isTurnControl(operation.kind) && operation.kind !== 'runtime.destroy'
+            ? await state.journal.putPendingOperation(scopeKey, operation, options.executionPayload, parsed.sessionRecovery)
+            : 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 };
     });