@playcraft/cli 0.1.37-beta → 0.1.38-beta

package/dist/workspace-runtime/persistence/journal.js

@@ -296,9 +296,16 @@ export class RuntimeJournal {
     }
     apply(dump) {
         const group = dump.snapshot.executionGroup;
+        const events = dump.snapshot.events ?? this.snapshot.events;
+        // Keep history in place: copying it on every streamed delta grows quadratically.
+        for (const event of dump.committedEvents ?? [])
+            events[sourceEventKey(event.source)] = event;
+        for (const event of dump.eventChanges ?? [])
+            events[sourceEventKey(event.source)] = event;
         this.snapshot = {
             ...emptySnapshot(),
             ...dump.snapshot,
+            events,
             executionGroup: {
                 stopConfirmed: group?.stopConfirmed === true,
                 replaced: group?.replaced === true,

package/dist/workspace-runtime/persistence/sqlite-worker.js

@@ -83,8 +83,7 @@ function dispatch(type, payload) {
             case 'allocateEvent':
                 return allocateEvent(database, body);
             case 'commitIdentity':
-                commitIdentity(database, body.event);
-                return;
+                return { eventChanges: commitIdentity(database, body.event).committedEvents };
             case 'ingest':
                 return ingest(database, body);
             case 'bindTurn':
@@ -108,7 +107,7 @@ function dispatch(type, payload) {
         }
     });
     const extra = write();
-    return { ...dump(database), ...(extra && typeof extra === 'object' ? extra : {}) };
+    return { ...dump(database, type === 'reclaim'), ...(extra && typeof extra === 'object' ? extra : {}) };
 }
 function openDatabase(payload) {
     if (db)
@@ -820,13 +819,14 @@ function reclaim(database, minRetainMs) {
         }
     }
 }
-function dump(database) {
+function dump(database, includeEvents = true) {
     const snapshot = {
         workspaces: bucketObject(database, 'workspaces'),
         workspaceFileRevisions: workspaceFiles(database),
         operations: operationsObject(database),
         receipts: bucketObject(database, 'receipts'),
-        events: eventsObject(database),
+        // Startup and reclamation replace history; ordinary writes return only their new events.
+        ...(includeEvents ? { events: eventsObject(database) } : {}),
         sessions: bucketObject(database, 'sessions'),
         terminals: bucketObject(database, 'terminals'),
         fileRevisions: bucketObject(database, 'file_revisions'),

package/dist/workspace-runtime/production/content-changes.js

@@ -0,0 +1,36 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execute = promisify(execFile);
+const reference = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/;
+const excludedDirectories = new Set(['node_modules', 'dist', 'build', 'coverage', 'docs', 'test', 'tests', '__tests__']);
+const contentExtension = /\.(?:[cm]?[jt]sx?|vue|svelte|html?|css|s[ac]ss|less|json5?|ya?ml|xml|glsl|wgsl|vert|frag|lua|py|svg|png|jpe?g|webp|avif|gif|bmp|mp[34]|wav|ogg|m4a|webm|glb|gltf|fbx|obj|bin|atlas|woff2?|ttf|otf)$/i;
+function contentPath(path) {
+    const parts = path.split('/');
+    if (parts.some(part => part.startsWith('.') || excludedDirectories.has(part)))
+        return false;
+    const name = parts.at(-1);
+    if (/^(?:package(?:-lock)?\.json|npm-shrinkwrap\.json|pnpm-lock\.yaml|yarn\.lock|bun\.lockb?|tsconfig(?:\.[^.]+)?\.json|(?:vite|vitest|webpack|eslint|prettier)\.config\..+)$/i.test(name))
+        return false;
+    return contentExtension.test(name);
+}
+/** A completed native turn is useful only when code, runtime configuration, or assets changed. */
+export async function requireProductionContentChanges(root, before, after) {
+    if (!reference.test(before) || !reference.test(after))
+        throw new Error('production_change_reference_invalid');
+    const { stdout } = await execute('git', ['-c', 'core.hooksPath=/dev/null', '-c', 'core.fsmonitor=false', '-C', root,
+        'diff', '--raw', '--no-abbrev', '--no-renames', '-z', before, after, '--'], {
+        timeout: 90_000, maxBuffer: 64 * 1024 * 1024,
+        env: { PATH: process.env.PATH, HOME: root, GIT_CONFIG_GLOBAL: '/dev/null', GIT_CONFIG_NOSYSTEM: '1', GIT_TERMINAL_PROMPT: '0' },
+    });
+    const records = stdout.split('\0'), paths = [];
+    for (let index = 0; index + 1 < records.length; index += 2) {
+        const [oldMode, newMode, oldBlob, newBlob] = records[index].slice(1).split(' ');
+        const path = records[index + 1];
+        if ((oldMode === '100644' || oldMode === '100755' || newMode === '100644' || newMode === '100755')
+            && oldBlob !== newBlob && contentPath(path))
+            paths.push(path);
+    }
+    if (!paths.length)
+        throw new Error('production_generation_no_content_change');
+    return paths;
+}

package/dist/workspace-runtime/production/stages.js

@@ -3,7 +3,7 @@ import { createHash } from 'node:crypto';
 import { lstat, mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { promisify } from 'node:util';
-import { batchBaselineSnapshotSchema, batchSourceSnapshotSchema } from '@playcraft/common/cloud-workspace/runtime';
+import { batchBaselineSnapshotSchema, batchSavedEvidenceSchema, batchSourceSnapshotSchema } from '@playcraft/common/cloud-workspace/runtime';
 import { checkoutBatchCommit, freezeBatchCommit } from '../workspaces/batch-commit.js';
 import { grantWorkspaceTraversal, openDirectoryToDevelopment } from '../workspaces/directory-access.js';
 import { registerWorkspaceDirectory } from '../workspaces/directories.js';
@@ -20,6 +20,8 @@ import { workspaceDirectoryOccupied } from '../workspaces/directory-maintenance.
 import { ensureWorkspaceSkills } from '../workspaces/skills.js';
 import { cachedProductionSourceArchive, captureProductionSourceArchive } from './source-archive.js';
 import { prepareWorkspaceCheckout } from '../workspaces/prepare.js';
+import { snapshotWorkspaceTree } from '../workspaces/git.js';
+import { requireProductionContentChanges } from './content-changes.js';
 const execute = promisify(execFile);
 const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
 const hash = (body) => createHash('sha256').update(body).digest('hex');
@@ -170,7 +172,15 @@ export async function executeProductionStage(state, input, processRecord, track)
         await registerWorkspaceDirectory(state, directory, state.acceptedLeaseFence, sourceDirectoryName);
     }
     const root = await workspaceRoot(state, workspaceId, input.directoryName);
+    const variantChanges = async (commitHash) => {
+        if (!directSource || resultId === input.task.attemptId)
+            return undefined;
+        const source = batchSourceSnapshotSchema.parse(manifest.sourceSnapshot);
+        return requireProductionContentChanges(root, source.commitHash, commitHash);
+    };
     if (stage === 'prepare') {
+        if (input.payload.repairCommitHash !== undefined && await git(root, 'rev-parse', 'HEAD') !== input.payload.repairCommitHash)
+            throw new Error('production_repair_commit_mismatch');
         await settleDependencyInstalls(state);
         if (!(await lstat(join(root, 'package.json')).catch(() => undefined)))
             return { prepared: true, directoryName: input.directoryName, emptySource: true };
@@ -200,15 +210,34 @@ export async function executeProductionStage(state, input, processRecord, track)
         return { prepared: true, directoryName: input.directoryName };
     }
     if (stage === 'generate') {
+        const beforeTree = await snapshotWorkspaceTree(root);
         await runProductionNative(state, input, root, processRecord, track);
         await resolveProductionDependencies(root);
-        return { generated: true };
+        const afterTree = await snapshotWorkspaceTree(root);
+        const changedPaths = await requireProductionContentChanges(root, beforeTree, afterTree);
+        await variantChanges(afterTree);
+        return { generated: true, changes: { beforeTree, afterTree, changedPaths } };
     }
     if (stage === 'save') {
         const binding = state.journal.getWorkspace(workspaceId);
         const branch = input.directoryName === 'basic' ? binding.branchName : binding.directories?.find(value => value.directoryName === input.directoryName)?.branchName;
         if ((input.git && input.git.branchName !== branch) || await git(root, 'symbolic-ref', '--short', 'HEAD') !== branch)
             throw new Error('production_git_binding_mismatch');
+        if (input.payload.saved !== undefined) {
+            const saved = batchSavedEvidenceSchema.parse(input.payload.saved);
+            if (input.task.kind !== 'retry' || saved.attemptId === input.task.attemptId || saved.workspaceId !== workspaceId
+                || saved.resultVersionId !== resultId || saved.commitHash !== saved.pushedCommitHash)
+                throw new Error('production_recovery_saved_identity_mismatch');
+            if (await git(root, 'rev-parse', 'HEAD') !== saved.commitHash)
+                throw new Error('production_repair_commit_mismatch');
+            const snapshot = await freezeBatchCommit({ source: { workspaceId, root }, commitHash: saved.commitHash, snapshotId: `${input.task.attemptId}-save` });
+            if (snapshot.checksum !== saved.sourceDigest)
+                throw new Error('production_recovery_source_mismatch');
+            if (await snapshotWorkspaceTree(root) !== await git(root, 'rev-parse', `${saved.commitHash}^{tree}`))
+                throw new Error('production_recovery_worktree_changed');
+            await variantChanges(snapshot.commitHash);
+            return { snapshot, saved: { ...saved, attemptId: input.task.attemptId } };
+        }
         await run(root, 'chmod -R u+rwX,g+rwX .').catch(() => undefined);
         await excludeFromGit(root);
         await excludeFromGit(root, '/.env*');
@@ -220,6 +249,7 @@ export async function executeProductionStage(state, input, processRecord, track)
         await run(root, productionLocalCommitCommand(), env, true);
         const commitHash = await git(root, 'rev-parse', 'HEAD');
         const snapshot = await freezeBatchCommit({ source: { workspaceId, root }, commitHash, snapshotId: `${input.task.attemptId}-save` });
+        await variantChanges(snapshot.commitHash);
         return { snapshot, saved: { attemptId: input.task.attemptId, resultVersionId: resultId, workspaceId, sourceDigest: snapshot.checksum, commitHash, pushedCommitHash: commitHash } };
     }
     if (stage === 'freeze') {
@@ -237,6 +267,7 @@ export async function executeProductionStage(state, input, processRecord, track)
         const snapshot = (previous('freeze')?.snapshot ?? previous('save')?.snapshot);
         if (!snapshot || snapshot.commitHash !== saved.commitHash || snapshot.checksum !== saved.sourceDigest)
             throw new Error('production_saved_snapshot_mismatch');
+        await variantChanges(snapshot.commitHash);
         const destination = join(root, '.playcraft-temp', `production-${input.task.attemptId}`);
         const removeDestination = async () => {
             try {

package/dist/workspace-runtime/production/storage.js

@@ -1,4 +1,21 @@
 const taskUrl = (input) => `${input.callbackUrl.replace(/\/+$/, '')}/internal/cloud-production/tasks/${input.task.taskId}`;
+async function objectFailure(response, input, operation) {
+    const value = await response.json().catch(() => undefined);
+    const body = value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+    const reason = [body.reason, body.code, body.message, body.error]
+        .find((value) => typeof value === 'string' && /^[a-z0-9_]{1,128}$/.test(value)
+        && !value.includes(input.runnerToken));
+    // Keep callback status and machine codes; never record its URL, headers, or response body.
+    try {
+        console.error(JSON.stringify({ event: 'production.object_transfer_failed', taskId: input.task.taskId,
+            attemptId: input.task.attemptId, workspaceId: input.task.workspaceId, directoryName: input.directoryName,
+            stage: input.stage, leaseFence: input.lease.fence, operation, status: response.status, reason }));
+    }
+    catch { /* Diagnostics must preserve the original failure. */ }
+    return new Error(operation === 'get'
+        ? response.status === 404 ? 'object_missing' : 'object_get_failed'
+        : response.status === 409 ? 'object_conflict' : 'object_put_failed');
+}
 /** Build output travels through the Runtime that leased the task; engineering files travel through Git. */
 export function productionOutputStore(input) {
     const object = (key) => `${taskUrl(input)}/objects/${key.split('/').map(encodeURIComponent).join('/')}`;
@@ -6,17 +23,15 @@ export function productionOutputStore(input) {
     return {
         async get(key) {
             const response = await fetch(object(key), { headers, redirect: 'error', signal: AbortSignal.timeout(60_000) });
-            if (response.status === 404)
-                throw new Error('object_missing');
             if (!response.ok)
-                throw new Error('object_get_failed');
+                throw await objectFailure(response, input, 'get');
             return Buffer.from(await response.arrayBuffer());
         },
         async put(key, body) {
             const response = await fetch(object(key), { method: 'PUT', body: new Uint8Array(body), redirect: 'error', signal: AbortSignal.timeout(60_000),
                 headers: { ...headers, 'content-type': 'application/octet-stream' } });
             if (!response.ok)
-                throw new Error(response.status === 409 ? 'object_conflict' : 'object_put_failed');
+                throw await objectFailure(response, input, 'put');
         },
     };
 }

package/dist/workspace-runtime/workspaces/files.js

@@ -2,7 +2,7 @@ import { lstat, mkdir, readdir, readFile, realpath, writeFile } from 'node:fs/pr
 import { dirname, join, relative, resolve, sep } from 'node:path';
 import { hashWorkspaceFileContent, workspaceFileContentSchema, workspaceFileListSchema, workspaceRelativePathSchema, } from '@playcraft/common/cloud-workspace/runtime';
 import { sampleDiskFile } from './disk-snapshot.js';
-const SKIP_DIRECTORY_NAMES = new Set(['.git', 'node_modules']);
+const SKIP_DIRECTORY_NAMES = new Set(['.git', 'node_modules', '.playcraft-temp']);
 const LARGE_FILE_STREAM_THRESHOLD = 8 * 1024 * 1024;
 export class InvalidWorkspacePathError extends Error {
     code = 'invalid_workspace_path';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playcraft/cli",
-  "version": "0.1.37-beta",
+  "version": "0.1.38-beta",
   "private": false,
   "type": "module",
   "engines": {
@@ -51,8 +51,8 @@
     "@gltf-transform/core": "^4.3.0",
     "@gltf-transform/extensions": "^4.3.0",
     "@gltf-transform/functions": "^4.3.0",
-    "@playcraft/build": "^0.1.37-beta",
-    "@playcraft/common": "^0.1.37-beta",
+    "@playcraft/build": "^0.1.38-beta",
+    "@playcraft/common": "^0.1.38-beta",
     "better-sqlite3-pinned": "npm:better-sqlite3@13.0.3",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",