@playcraft/cli 0.1.63 → 0.1.65

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

@@ -6,7 +6,7 @@ import { shareWorkspaceGit } from '../workspaces/shared-git.js';
 import { cancelPendingDirectoryAccess, holdDirectoryAccess, withOperationDirectoryAccess } from './directory-access.js';
 import { join } from 'node:path';
 import { z } from 'zod';
-import { fileWritePayloadSchema, fileBinaryWritePayloadSchema, directoryCreatePayloadSchema, directoryRenamePayloadSchema, directoryDeletePayloadSchema, directoryMutationReceiptSchema, gitCommitPayloadSchema, gitPathsPayloadSchema, gitPushPayloadSchema, gitPullPayloadSchema, gitMergeAbortPayloadSchema, parameterPatchPayloadSchema, parameterAgentTaskRequestSchema, parameterAgentVerifyPayloadSchema, productionSessionAttemptId, reasoningEffortSchema, workspacePermissionModeSchema, workspaceComposerSelectionSchema, workspaceReviewPayloadSchema, workspaceCompactPayloadSchema, workspaceSteerPayloadSchema, workspaceApprovalResponseSchema, terminalCreatePayloadSchema, terminalProcessIdentity, transitionOperation, recoverUncertainOperation, workspaceSavePayloadSchema, workspaceSkillsUpdatePayloadSchema, workspaceRemixReferenceImportPayloadSchema, deliveryBuildPayloadSchema, deliveryCancelPayloadSchema, workspaceModelPreviewBuildSchema, workspaceModelPreviewCancelSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { fileWritePayloadSchema, fileBinaryWritePayloadSchema, directoryCreatePayloadSchema, directoryRenamePayloadSchema, directoryDeletePayloadSchema, directoryMutationReceiptSchema, gitCommitPayloadSchema, gitPathsPayloadSchema, gitPushPayloadSchema, gitPullPayloadSchema, gitMergeAbortPayloadSchema, parameterPatchPayloadSchema, parameterAgentTaskRequestSchema, parameterAgentVerifyPayloadSchema, productionSessionAttemptId, reasoningEffortSchema, workspacePermissionModeSchema, workspaceComposerSelectionSchema, workspaceReviewPayloadSchema, workspaceCompactPayloadSchema, workspaceSteerPayloadSchema, workspaceApprovalResponseSchema, terminalCreatePayloadSchema, terminalProcessIdentity, transitionOperation, recoverUncertainOperation, workspaceSavePayloadSchema, workspaceSkillsUpdatePayloadSchema, workspaceRemixReferenceImportPayloadSchema, workspaceModelPreviewBuildSchema, workspaceModelPreviewCancelSchema, } from '@playcraft/common/cloud-workspace/runtime';
 import { closeCliCredentials, ensureCliCredentials } from '../workspaces/cli-credentials.js';
 import { artifactFormat } from '../workspaces/artifact-files.js';
 import { refreshWorkspaceArtifacts } from '../workspaces/artifact-events.js';
@@ -42,8 +42,8 @@ import { DirectoryMutationError, mutateWorkspaceDirectory } from '../workspaces/
 import { observeWorkspaceDirectories } from '../workspaces/directory-revisions.js';
 import { publishAssetTransfer } from '../workspaces/asset-transfer-publish.js';
 import { AssetTransferError } from '../workspaces/asset-transfer-storage.js';
-import { runDeliveryBuild, cancelDeliveryBuild, trackDeliveryBuild, DeliveryBuildError } from '../workspaces/delivery-build.js';
 import { runModelPreviewBuild, cancelModelPreview, modelPreviewError } from '../workspaces/procedural-3d/model-preview-build.js';
+import { runModelPreparation, trackModelPreparation } from '../workspaces/model-preparation.js';
 const CONVERSATION_KINDS = new Set([
     'session.create',
     'session.turn',
@@ -76,10 +76,9 @@ const LOCAL_KINDS = new Set([
     'parameter.patch',
     'parameter.verify',
     'preview.publish',
-    'delivery.build',
-    'delivery.cancel',
     'model.preview',
     'model.preview.cancel',
+    'model.prepare',
     'skills.update',
 ]);
 const parameterVerifications = new WeakMap();
@@ -123,7 +122,7 @@ export async function executeOperation(state, scopeKey, operation, payload, reco
             return executeScopedOperation(state, scopeKey, operation, payload, recovery);
         }, { operationId: operation.operationId, scopeKey, payload, ...(recovery ? { recovery } : {}) });
     };
-    if (['runtime.destroy', 'session.interrupt', 'session.approval.respond', 'session.steer', 'preview.publish', 'delivery.build', 'delivery.cancel', 'model.preview', 'model.preview.cancel'].includes(operation.kind)) {
+    if (['runtime.destroy', 'session.interrupt', 'session.approval.respond', 'session.steer', 'preview.publish', 'model.preview', 'model.preview.cancel', 'model.prepare'].includes(operation.kind)) {
         return run();
     }
     return state.journal.exclusive(operation.kind.startsWith('session.') && operation.sessionId
@@ -199,15 +198,32 @@ async function executeScopedOperation(state, scopeKey, operation, payload, recov
     if (operation.kind === 'preview.publish') {
         return executePreviewPublish(state, scopeKey, current);
     }
-    if (operation.kind === 'delivery.build') {
-        return executeDeliveryBuild(state, scopeKey, current, payload);
-    }
-    if (operation.kind === 'delivery.cancel') {
-        return executeDeliveryCancel(state, scopeKey, current, payload);
-    }
     if (operation.kind === 'model.preview' || operation.kind === 'model.preview.cancel') {
         return executeModelPreview(state, scopeKey, current, payload);
     }
+    if (operation.kind === 'model.prepare') {
+        const accepted = await persist(state, scopeKey, transitionOperation(current, 'accepted'));
+        const task = runModelPreparation(state, accepted, payload, { onFile: async (file) => {
+                const scope = revisionScope(state, accepted.workspaceId, accepted.directoryName);
+                const existing = state.journal.listEvents().some(event => {
+                    const payload = asRecord(event.payload);
+                    return event.type === 'file.written' &&
+                        payload.operationId === accepted.operationId && payload.path === file.path && payload.contentHash === file.contentHash;
+                });
+                if (existing)
+                    return;
+                const previous = state.journal.fileRevisions(scope)[file.path];
+                const revision = previous ? previous.revision + (previous.contentHash === file.contentHash ? 0 : 1) : 1;
+                await state.journal.putFileRevision(file.path, { contentHash: file.contentHash, revision }, scope);
+                await recordNativeEvents(state, accepted, [{ type: 'file.written', payload: { ...file, revision, writer: 'manual',
+                            operationId: accepted.operationId, source: 'model.prepare' }, occurredAt: new Date().toISOString() }]);
+            } }).then(async (result) => { await persist(state, scopeKey, transitionOperation(accepted, 'completed', { result })); }, async (error) => {
+            const message = error instanceof Error ? error.message : '', code = /^model_prepare_[a-z_]+$/.test(message) ? message : 'model_prepare_failed';
+            await persist(state, scopeKey, transitionOperation(accepted, code === 'model_prepare_process_unknown' ? 'uncertain' : ['model_prepare_cancelled', 'model_prepare_timeout'].includes(code) ? 'interrupted' : 'failed', { error: code }));
+        });
+        trackModelPreparation(state, task);
+        return accepted;
+    }
     if (!state.native?.ready()) {
         return persist(state, scopeKey, transitionOperation(current, 'failed', { error: 'capability_unavailable' }));
     }
@@ -1533,42 +1549,6 @@ async function executeModelPreview(state, scopeKey, operation, payload) {
     }).catch(() => undefined));
     return accepted;
 }
-async function executeDeliveryBuild(state, scopeKey, operation, payload) {
-    const parsed = deliveryBuildPayloadSchema.safeParse(payload);
-    if (!parsed.success) {
-        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_delivery_build' }));
-    }
-    if (!operation.workspaceId) {
-        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_workspace' }));
-    }
-    const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
-    const task = runDeliveryBuild(state, {
-        buildId: operation.operationId,
-        workspaceId: operation.workspaceId,
-        directoryName: operation.directoryName ?? 'basic',
-        payload: parsed.data,
-        actor: parsed.data.actor ?? 'user',
-    }).then(async (result) => {
-        const error = result.record.error
-            ?? (result.record.status === 'succeeded' ? undefined : 'delivery_build_failed');
-        await persist(state, scopeKey, transitionOperation(accepted, result.record.status === 'succeeded' ? 'completed' : error === 'delivery_process_unknown' ? 'uncertain' : 'failed', error ? { error } : {}));
-    }, async (error) => {
-        await persist(state, scopeKey, transitionOperation(accepted, 'failed', {
-            error: error instanceof DeliveryBuildError ? error.code : 'delivery_build_failed',
-        }));
-    }).catch(() => undefined);
-    trackDeliveryBuild(state, task);
-    return accepted;
-}
-async function executeDeliveryCancel(state, scopeKey, operation, payload) {
-    const parsed = deliveryCancelPayloadSchema.safeParse(payload);
-    if (!parsed.success || !operation.workspaceId) {
-        return persist(state, scopeKey, transitionOperation(operation, 'failed', { error: 'invalid_delivery_cancel' }));
-    }
-    const accepted = await persist(state, scopeKey, transitionOperation(operation, 'accepted'));
-    const canceled = await cancelDeliveryBuild(state, operation.workspaceId, operation.directoryName ?? 'basic', parsed.data.buildId);
-    return persist(state, scopeKey, transitionOperation(accepted, canceled ? 'completed' : 'failed', canceled ? {} : { error: 'delivery_build_not_found' }));
-}
 async function executeTerminalCreate(state, scopeKey, operation, payload) {
     const parsed = terminalCreatePayloadSchema.safeParse(payload ?? {});
     if (!parsed.success) {

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

@@ -49,6 +49,7 @@ import { readWorktreeSource, registerChatWorktree } from '../workspaces/worktree
 import { withDirectoryWrite } from './directory-access.js';
 import { readProceduralModelCandidates } from '../workspaces/procedural-3d/read-candidates.js';
 import { ModelPreviewStore } from '../workspaces/procedural-3d/model-preview-store.js';
+import { readModelPreparation } from '../workspaces/model-preparation.js';
 export async function handleRuntimeRequest(state, request, response) {
     const url = new URL(request.url ?? '/', 'http://127.0.0.1');
     const workspaceId = url.searchParams.get('workspaceId');
@@ -567,6 +568,17 @@ async function dispatchRuntimeRequest(state, request, response) {
             writeJson(response, 200, await readProceduralModelCandidates(root, state.config.stateDir));
             return;
         }
+        if (request.method === 'GET' && url.pathname === '/runtime/model-preparations') {
+            if (writeDestroyed(state, response))
+                return;
+            const workspaceId = url.searchParams.get('workspaceId'), pipelineId = url.searchParams.get('pipelineId'), stepId = url.searchParams.get('stepId');
+            if (!workspaceId || !pipelineId || !stepId || directoryName === 'root') {
+                writeJson(response, 400, { error: 'model_prepare_scope_invalid' });
+                return;
+            }
+            writeJson(response, 200, await readModelPreparation(state, workspaceId, directoryName, pipelineId, stepId));
+            return;
+        }
         if (request.method === 'GET' && url.pathname === '/runtime/artifacts') {
             if (writeDestroyed(state, response))
                 return;

package/dist/workspace-runtime/workspaces/build-isolation.js

@@ -0,0 +1,75 @@
+import { constants } from 'node:fs';
+import { copyFile, cp, lstat, mkdir, readdir, readlink, symlink } from 'node:fs/promises';
+import { dirname, join, relative, sep } from 'node:path';
+import { listWorkspaceBuildInputs } from './git.js';
+import { ensureSharedDirectory } from './shared-write.js';
+/** Staging under the workspace from earlier runtimes' sandbox delivery builds; never a build input. */
+const STAGING_DIRECTORY = '.playcraft-delivery';
+/** Never copied into the build copy: history, outputs and caches that the build neither reads nor owns. */
+const ISOLATE_SKIP = new Set(['.git', 'dist', '.turbo', STAGING_DIRECTORY]);
+/** Copy-on-write clone where the filesystem supports it (APFS, btrfs, XFS); a plain copy elsewhere. */
+const CLONE = constants.COPYFILE_FICLONE;
+const COPY_CONCURRENCY = 16;
+function skipped(path) {
+    const parts = path.split(/[\\/]/);
+    return ISOLATE_SKIP.has(parts[0]) || parts.includes('node_modules');
+}
+async function copyInput(root, destination, path) {
+    const source = join(root, path);
+    const target = join(destination, path);
+    let entry;
+    try {
+        entry = await lstat(source);
+    }
+    catch (error) {
+        // A tracked file deleted in the work tree is not a build input.
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+    await mkdir(dirname(target), { recursive: true });
+    if (entry.isSymbolicLink())
+        await symlink(await readlink(source), target);
+    else if (entry.isDirectory())
+        await cp(source, target, { recursive: true, verbatimSymlinks: true, mode: CLONE });
+    else
+        await copyFile(source, target, CLONE);
+}
+/**
+ * Copies the workspace into `destination` for one build, like the platform export runner, with the
+ * top-level `node_modules` linked (the build only reads it). Builders rewrite project files in place
+ * (`builds.config.js` and its `.bak`, `package.json` scripts, migrated imports), so the build must
+ * never run in the workspace itself, where autosave would commit those rewrites.
+ *
+ * Only the files Git would carry are copied: tracked ones and untracked ones `.gitignore` keeps, so
+ * caches, logs and local outputs stay behind. Without a repository the whole tree is copied.
+ */
+export async function isolateWorkspaceForBuild(root, destination) {
+    // The build runs as the development identity and writes its scratch folder inside this copy.
+    await ensureSharedDirectory(root, destination);
+    const modules = join(root, 'node_modules');
+    const modulesEntry = await lstat(modules).catch(() => undefined);
+    if (modulesEntry?.isDirectory() || modulesEntry?.isSymbolicLink()) {
+        await symlink(modulesEntry.isSymbolicLink() ? await readlink(modules) : modules, join(destination, 'node_modules'), 'dir');
+    }
+    const inputs = await listWorkspaceBuildInputs(root).catch(() => undefined);
+    const paths = inputs
+        ?? (await readdir(root)).filter((name) => name !== 'node_modules');
+    const queue = paths.filter((path) => !skipped(path));
+    const workers = Array.from({ length: Math.min(COPY_CONCURRENCY, queue.length) }, async () => {
+        for (let path = queue.shift(); path !== undefined; path = queue.shift()) {
+            if (inputs)
+                await copyInput(root, destination, path);
+            else {
+                await cp(join(root, path), join(destination, path), {
+                    recursive: true,
+                    verbatimSymlinks: true,
+                    mode: CLONE,
+                    // Nested dependency folders stay out as well; the build resolves through the linked root.
+                    filter: (source) => !relative(join(root, path), source).split(sep).includes('node_modules'),
+                });
+            }
+        }
+    });
+    await Promise.all(workers);
+}

package/dist/workspace-runtime/workspaces/model-build-inputs.js

@@ -118,6 +118,16 @@ export async function readWorkspaceModelBuildInputs(root, stateDir) {
                 throw new Error('model_build_resource_manifest_mismatch');
             for (const file of source.files)
                 inputs.push((await read(file.path, file.contentHash)).file);
+            // Resolve the actual installed dependency inputs even when a generated declaration predates installation.
+            for (const path of ['package.json', 'pnpm-lock.yaml', 'package-lock.json', 'yarn.lock']) {
+                try {
+                    inputs.push((await read(path)).file);
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        throw error;
+                }
+            }
         }
         else {
             const candidate = candidates?.candidates.find(item => item.runId === source.runId && item.candidateId === source.candidateId);
@@ -174,6 +184,23 @@ export async function verifyWorkspaceModelBuildInputs(root, snapshot) {
         if (model.source.kind === 'procedural' &&
             await dependencyHash(root) !== model.source.dependencyHash)
             throw new Error('model_build_input_changed');
+    for (const model of snapshot.models)
+        if (model.source.kind === 'resource') {
+            for (const path of ['package.json', 'pnpm-lock.yaml', 'package-lock.json', 'yarn.lock']) {
+                const frozen = model.inputs.find(file => file.path === path);
+                try {
+                    const bytes = await checkedFile(root, path, 64 * 1024 * 1024);
+                    if (!frozen || digest(bytes) !== frozen.contentHash)
+                        throw new Error('model_build_input_changed');
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        throw error;
+                    if (frozen)
+                        throw new Error('model_build_input_changed');
+                }
+            }
+        }
 }
 /** The marker makes otherwise identical HTML from different input declarations distinct artifacts. */
 export function markWorkspaceModelBuild(bytes, snapshot) {

package/dist/workspace-runtime/workspaces/model-preparation-store.js

@@ -0,0 +1,134 @@
+import { lstat, mkdir, readdir, realpath, readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { modelPreparationReceiptSchema } from '@playcraft/common/cloud-workspace/runtime';
+import { hash, hashData, preparationPath, readPreparationFile, readPreparationJson, writePreparationJson } from '../../model-preparation/pipeline-files.js';
+import { observeWorkspaceBinaryFile, writeWorkspaceBinaryFile } from './binary-write.js';
+/** Control-owned step truth. Workspace metadata is never accepted as an execution receipt. */
+export class ModelPreparationStore {
+    workspaceId;
+    directoryName;
+    pipelineId;
+    stepId;
+    root;
+    constructor(stateDir, workspaceId, directoryName, pipelineId, stepId) {
+        this.workspaceId = workspaceId;
+        this.directoryName = directoryName;
+        this.pipelineId = pipelineId;
+        this.stepId = stepId;
+        if (!/^[a-f0-9-]{36}$/.test(workspaceId) || !/^[a-f0-9-]{36}$/.test(pipelineId) || stepId.length < 1 || stepId.length > 128)
+            throw Error('model_prepare_scope_invalid');
+        this.root = join(stateDir, 'model-preparations', hashData({ workspaceId, directoryName }), pipelineId, hash(stepId));
+    }
+    async read() {
+        const value = await readPreparationJson(this.root, 'record.json');
+        if (value && (value.schemaVersion !== 1 || value.workspaceId !== this.workspaceId || value.directoryName !== this.directoryName ||
+            value.pipelineId !== this.pipelineId || value.stepId !== this.stepId))
+            throw Error('model_prepare_scope_mismatch');
+        if (value?.receipt) {
+            const parsed = modelPreparationReceiptSchema.parse(value.receipt), { receiptHash, ...body } = parsed;
+            if (hashData(body) !== receiptHash)
+                throw Error('model_prepare_receipt_changed');
+        }
+        return value;
+    }
+    async write(value) {
+        if (value.workspaceId !== this.workspaceId || value.directoryName !== this.directoryName || value.pipelineId !== this.pipelineId || value.stepId !== this.stepId)
+            throw Error('model_prepare_scope_mismatch');
+        if (value.receipt)
+            modelPreparationReceiptSchema.parse(value.receipt);
+        await writePreparationJson(join(this.root, 'record.json'), value);
+    }
+}
+/** New standalone template baseline, including preserved instructions; never traverse repository internals. */
+export async function targetPreparationSnapshot(root) {
+    const result = [];
+    let size = 0;
+    async function walk(prefix = '') {
+        for (const entry of await readdir(join(root, prefix), { withFileTypes: true })) {
+            if (['.git', 'node_modules'].includes(entry.name))
+                continue;
+            const path = prefix ? `${prefix}/${entry.name}` : entry.name;
+            preparationPath(path);
+            if (entry.isSymbolicLink())
+                throw Error('model_prepare_target_unsafe');
+            if (entry.isDirectory())
+                await walk(path);
+            else {
+                const file = await readPreparationFile(root, path);
+                size += file.bytes.length;
+                if (result.length >= 1024 || size > 256 * 1024 * 1024)
+                    throw Error('model_prepare_target_bound');
+                result.push({ path, contentHash: file.contentHash, bytes: file.bytes.length });
+            }
+        }
+    }
+    await walk();
+    return result.sort((a, b) => a.path.localeCompare(b.path, 'en'));
+}
+export function preparationWriteFiles(result) {
+    return result.files.filter(file => !['AGENTS.md', 'README.md'].includes(file.path));
+}
+/** Every output is either its frozen preimage or this exact transaction's postimage. */
+export async function promotePreparationProject(store, target, record, options) {
+    if (!record.result || !record.targetSnapshot)
+        throw Error('model_prepare_transaction_missing');
+    if (await realpath(target) !== target || !(await lstat(target)).isDirectory())
+        throw Error('model_prepare_target_unsafe');
+    const expected = new Map(record.targetSnapshot.map(file => [file.path, file.contentHash]));
+    if (!record.transaction) {
+        const actual = await targetPreparationSnapshot(target);
+        if (hashData(actual) !== hashData(record.targetSnapshot))
+            throw Error('model_prepare_target_changed');
+        record.transaction = { files: preparationWriteFiles(record.result).map(file => ({ ...file, before: expected.get(file.path) ?? null })), published: [] };
+        record.phase = 'promoting';
+        await store.write(record);
+    }
+    const transaction = record.transaction;
+    const expectedPaths = new Set([...record.targetSnapshot.map(file => file.path), ...transaction.files.map(file => file.path)]);
+    for (const file of await targetPreparationSnapshot(target)) {
+        if (!expectedPaths.has(file.path))
+            throw Error('model_prepare_target_changed');
+        const write = transaction.files.find(item => item.path === file.path);
+        if (file.contentHash !== (expected.get(file.path) ?? null) && (!write || file.contentHash !== write.contentHash))
+            throw Error('model_prepare_target_changed');
+    }
+    // A removed non-output instruction is also a conflict, rather than a reason to recreate it.
+    for (const file of record.targetSnapshot)
+        if (!transaction.files.some(item => item.path === file.path) &&
+            (await observeWorkspaceBinaryFile(target, file.path))?.contentHash !== file.contentHash)
+            throw Error('model_prepare_target_changed');
+    for (const file of transaction.files) {
+        options.signal?.throwIfAborted();
+        await options.assertCurrent();
+        const current = await observeWorkspaceBinaryFile(target, file.path);
+        if (current?.contentHash !== file.contentHash) {
+            if ((current?.contentHash ?? null) !== file.before)
+                throw Error('model_prepare_target_changed');
+            const source = await readPreparationFile(record.result.projectRoot, file.path);
+            if (source.contentHash !== file.contentHash || source.bytes.length !== file.bytes)
+                throw Error('model_prepare_worker_output_changed');
+            if (current) {
+                const backup = join(store.root, 'preimages', file.path);
+                await mkdir(dirname(backup), { recursive: true, mode: 0o700 }); // private: controller-only preparation state
+                const old = await readPreparationFile(target, file.path);
+                if (old.contentHash !== file.before)
+                    throw Error('model_prepare_target_changed');
+                const { writeFile } = await import('node:fs/promises');
+                await writeFile(backup, old.bytes, { flag: 'wx', mode: 0o600 }).catch(async (error) => {
+                    if (error.code !== 'EEXIST' || hash(await readFile(backup)) !== file.before)
+                        throw error;
+                });
+            }
+            await writeWorkspaceBinaryFile(target, { path: file.path, contentBase64: source.bytes.toString('base64'), expectedContentHash: file.before });
+        }
+        if (!transaction.published.includes(file.path)) {
+            const actual = await observeWorkspaceBinaryFile(target, file.path);
+            if (!actual || actual.contentHash !== file.contentHash)
+                throw Error('model_prepare_target_changed');
+            await options.onFile({ path: file.path, ...actual });
+            transaction.published.push(file.path);
+            await store.write(record);
+        }
+    }
+    await options.assertCurrent();
+}