@playcraft/cli 0.1.60-beta → 0.1.62-beta

package/dist/workspace-runtime/workspaces/platform-export.js

@@ -84,8 +84,9 @@ async function request(state, path, init) {
 }
 /**
  * Saves the directory (commit + push), then exports that commit for the channels through the
- * platform, as the delivery panel's Export does. Each channel repeats its latest export of the
- * branch, or uses the defaults without one. A standalone workspace first becomes a project.
+ * platform, as the delivery panel's Export does. Each channel uses that panel's fixed HTML or
+ * ZIP choice. Other options repeat the channel's latest export of the branch, or stay empty
+ * without one. A standalone workspace first becomes a project.
  */
 export async function startPlatformExport(state, input) {
     await promoteStandalone(state, input);
@@ -121,7 +122,6 @@ export async function startPlatformExport(state, input) {
             branchName: status.branch,
             commitHash: commit,
             platforms: input.channels,
-            ...(input.format ? { format: input.format } : {}),
             clientRequestId: input.clientRequestId,
         },
     });

package/dist/workspace-runtime/workspaces/procedural-3d/candidate.js

@@ -0,0 +1,129 @@
+import { randomUUID } from 'node:crypto';
+import { lstat, readdir, rename, rm } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { ensureSharedDirectory } from '../shared-write.js';
+import { createHostReviewFiles } from './review-page.js';
+import { REVIEW_DIRECTORY, REVIEW_PAGE, reviewProfileHash, validateRenderReceipt, } from './review-contracts.js';
+import { checkedFile, copySnapshot, dependencyHash, digest, relativeFile, snapshotFiles, verifyFiles, } from './files.js';
+export async function freezeCandidate(root, jobRoot, input, lockedHelpers) {
+    if ((!input.review && (!input.pagePath || !input.files.includes(input.pagePath))) ||
+        !input.sourcePaths.includes('src/createObjectModel.ts') ||
+        input.files.includes('object-sculpt-spec.json') ||
+        input.sourcePaths.some((path) => !input.files.includes(path)))
+        throw new Error('procedural_skill_missing_candidate_inputs');
+    const files = await snapshotFiles(join(jobRoot, 'workspace'), input.files);
+    if (input.review) {
+        if (!lockedHelpers ||
+            input.pagePath ||
+            !input.files.includes(input.review.factoryPath) ||
+            input.files.some((path) => path.toLowerCase().startsWith(`${REVIEW_DIRECTORY}/`)))
+            throw new Error('procedural_skill_invalid_review_input');
+        for (const file of createHostReviewFiles(input.review, lockedHelpers))
+            files.push({ ...file, hash: digest(file.bytes) });
+        files.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+        if (files.length > 256 ||
+            files.reduce((size, file) => size + file.bytes.length, 0) > 64 * 1024 * 1024)
+            throw new Error('procedural_skill_size_limit');
+    }
+    const id = randomUUID();
+    await copySnapshot(root, join(jobRoot, 'candidates', id, 'source'), files);
+    const spec = await checkedFile(join(jobRoot, 'workspace'), 'object-sculpt-spec.json');
+    await copySnapshot(root, join(jobRoot, 'candidates', id), [{ path: 'spec.json', bytes: spec }]);
+    const hashes = files.map(({ path, hash }) => ({ path, hash }));
+    return {
+        id,
+        files: hashes,
+        sourcePaths: [...new Set(input.sourcePaths)].sort(),
+        sourceHash: digest(JSON.stringify(hashes)),
+        dependencyHash: await dependencyHash(root),
+        pagePath: relativeFile(input.review ? REVIEW_PAGE : input.pagePath),
+        views: input.views,
+        specHash: digest(spec),
+        expectedSpecHash: digest(spec),
+        passId: input.passId,
+        ...(input.review
+            ? {
+                hostReview: {
+                    profile: input.review.profile,
+                    profileHash: reviewProfileHash(input.review.profile),
+                    helperHash: digest(lockedHelpers.scene),
+                    profileHelperHash: digest(lockedHelpers.profile),
+                },
+            }
+            : {}),
+    };
+}
+export const candidateWorkspaceFiles = (candidate) => candidate.hostReview
+    ? candidate.files.filter((file) => !file.path.startsWith(`${REVIEW_DIRECTORY}/`))
+    : candidate.files;
+export async function verifyCandidate(root, jobRoot, candidate) {
+    if ((await dependencyHash(root)) !== candidate.dependencyHash)
+        throw new Error('procedural_skill_dependencies_changed');
+    await verifyFiles(join(jobRoot, 'workspace'), candidateWorkspaceFiles(candidate));
+    await verifyFiles(join(jobRoot, 'candidates', candidate.id, 'source'), candidate.files);
+    if (digest(await checkedFile(join(jobRoot, 'workspace'), 'object-sculpt-spec.json')) !==
+        candidate.expectedSpecHash ||
+        digest(await checkedFile(join(jobRoot, 'candidates', candidate.id), 'spec.json')) !==
+            candidate.specHash)
+        throw new Error('procedural_skill_spec_changed');
+    if (!candidate.captures?.length)
+        throw new Error('procedural_skill_captures_missing');
+    await verifyFiles(jobRoot, candidate.captures);
+    if (candidate.hostReview) {
+        if (!candidate.renderReceipt)
+            throw new Error('procedural_skill_review_receipt_missing');
+        const bytes = await checkedFile(jobRoot, candidate.renderReceipt.path);
+        if (digest(bytes) !== candidate.renderReceipt.hash)
+            throw new Error('procedural_skill_review_receipt_changed');
+        validateRenderReceipt(JSON.parse(bytes.toString('utf8')), candidate.hostReview.profile, candidate.views);
+    }
+}
+/** Publish a new immutable source directory; never overwrite the agent's current factory. */
+export async function adoptCandidate(root, jobRoot, candidate, assetId) {
+    await verifyCandidate(root, jobRoot, candidate);
+    if (candidate.review?.decision !== 'accept' ||
+        candidate.review.sourceHash !== candidate.sourceHash)
+        throw new Error('procedural_skill_review_required');
+    if (!/^[a-z][a-z0-9-]{0,63}$/.test(assetId))
+        throw new Error('procedural_skill_invalid_asset_id');
+    const relative = `src/generated/${assetId}/${candidate.id}`;
+    const target = join(root, relative);
+    const expected = candidate.files.filter((file) => candidate.sourcePaths.includes(file.path));
+    await ensureSharedDirectory(root, dirname(target));
+    const existing = await lstat(target).catch((error) => {
+        if (error.code === 'ENOENT')
+            return undefined;
+        throw error;
+    });
+    if (existing) {
+        if (!existing.isDirectory() || existing.isSymbolicLink())
+            throw new Error('procedural_skill_adoption_conflict');
+        const expectedPaths = new Set(expected.map((file) => file.path));
+        const checkTree = async (directory = '') => {
+            for (const item of await readdir(join(target, directory), { withFileTypes: true })) {
+                const path = directory ? `${directory}/${item.name}` : item.name;
+                if (item.isDirectory() && expected.some((file) => file.path.startsWith(`${path}/`)))
+                    await checkTree(path);
+                else if (!item.isFile() || !expectedPaths.has(path))
+                    throw new Error('procedural_skill_adoption_conflict');
+            }
+        };
+        await checkTree();
+        await verifyFiles(target, expected);
+        return { path: relative, sourceHash: candidate.sourceHash };
+    }
+    const staging = `${target}.${randomUUID()}.pending`;
+    try {
+        const files = await Promise.all(expected.map(async (file) => ({
+            path: file.path,
+            bytes: await checkedFile(join(jobRoot, 'candidates', candidate.id, 'source'), file.path),
+        })));
+        await copySnapshot(root, staging, files);
+        await verifyFiles(staging, expected);
+        await rename(staging, target);
+        return { path: relative, sourceHash: candidate.sourceHash };
+    }
+    finally {
+        await rm(staging, { recursive: true, force: true });
+    }
+}

package/dist/workspace-runtime/workspaces/procedural-3d/contracts.js

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+export const requestSchema = z
+    .object({
+    action: z.enum([
+        'describe',
+        'preflight',
+        'prepare',
+        'status',
+        'recover',
+        'next',
+        'run-step',
+        'request-correction',
+        'capture',
+        'review',
+        'adopt',
+    ]),
+    runId: z.string().uuid().optional(),
+    expectedRevision: z.number().int().nonnegative().optional(),
+    input: z.record(z.unknown()).default({}),
+})
+    .strict();
+export const captureSchema = z
+    .object({
+    pagePath: z.string(),
+    files: z.array(z.string()).min(2).max(256),
+    sourcePaths: z.array(z.string()).min(1).max(128),
+    views: z
+        .array(z.enum(['front', 'right', 'back', 'left', 'hero']))
+        .min(3)
+        .max(5)
+        .default(['front', 'right', 'hero']),
+})
+    .strict()
+    .refine((input) => new Set(input.views).size === input.views.length && input.views.includes('hero'));

package/dist/workspace-runtime/workspaces/procedural-3d/files.js

@@ -0,0 +1,83 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { lstat, mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { dirname, join, resolve } from 'node:path';
+import { ensureSharedDirectory, writeSharedFile } from '../shared-write.js';
+export const digest = (data) => createHash('sha256').update(data).digest('hex');
+export function relativeFile(value) {
+    if (!value ||
+        value.length > 512 ||
+        value.includes('\\') ||
+        value.includes('\0') ||
+        value.split('/').some((part) => !part || part === '.' || part === '..') ||
+        value.startsWith('/'))
+        throw new Error('procedural_skill_invalid_path');
+    return value;
+}
+export async function checkedFile(root, path, max = 16 * 1024 * 1024) {
+    const segments = relativeFile(path).split('/');
+    let current = resolve(root);
+    const base = await lstat(current);
+    if (!base.isDirectory() || base.isSymbolicLink())
+        throw new Error('procedural_skill_invalid_path');
+    for (let index = 0; index < segments.length; index++) {
+        current = join(current, segments[index]);
+        const stat = await lstat(current);
+        if (stat.isSymbolicLink() ||
+            (index < segments.length - 1
+                ? !stat.isDirectory()
+                : !stat.isFile() || stat.nlink !== 1 || stat.size > max))
+            throw new Error('procedural_skill_invalid_file');
+    }
+    return readFile(current);
+}
+export async function snapshotFiles(root, paths) {
+    if (!paths.length || paths.length > 256 || new Set(paths).size !== paths.length)
+        throw new Error('procedural_skill_invalid_files');
+    const files = [];
+    let size = 0;
+    for (const path of [...paths].sort()) {
+        const bytes = await checkedFile(root, path);
+        size += bytes.length;
+        if (size > 64 * 1024 * 1024)
+            throw new Error('procedural_skill_size_limit');
+        files.push({ path, bytes, hash: digest(bytes) });
+    }
+    return files;
+}
+export async function verifyFiles(root, files) {
+    for (const file of files)
+        if (digest(await checkedFile(root, file.path)) !== file.hash)
+            throw new Error('procedural_skill_candidate_changed');
+}
+export async function dependencyHash(root) {
+    const parts = [];
+    for (const name of ['package.json', 'pnpm-lock.yaml', 'package-lock.json', 'yarn.lock']) {
+        try {
+            parts.push(`${name}:${digest(await checkedFile(root, name, 16 * 1024 * 1024))}`);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    if (!parts.some((part) => part.startsWith('package.json:')))
+        throw new Error('procedural_skill_project_dependencies_missing');
+    return digest(parts.join('\n'));
+}
+/** Control-owned provenance is separate from the agent-writable job workspace. */
+export async function writeControlJson(path, value) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 }); // private
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, JSON.stringify(value), { flag: 'wx', mode: 0o600 }); // private
+        await rename(temporary, path);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+export async function copySnapshot(root, target, files) {
+    await ensureSharedDirectory(root, target);
+    for (const file of files)
+        await writeSharedFile(root, join(target, relativeFile(file.path)), file.bytes);
+}