@playcraft/cli 0.1.59-beta → 0.1.61-beta

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);
+}