@playcraft/cli 0.1.35-prod → 0.1.37-beta

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

@@ -0,0 +1,288 @@
+import { spawnSync } from 'node:child_process';
+import { createHash, randomUUID } from 'node:crypto';
+import { constants } from 'node:fs';
+import { chmod, copyFile, lstat, mkdir, mkdtemp, open, readdir, realpath, rename, rm, rmdir, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve, sep } from 'node:path';
+import { isCredentialFile } from './git.js';
+export const WORKSPACE_TRANSFER_MAX_BYTES = 256 * 1024 * 1024;
+const MAX_FILES = 20_000;
+const EXCLUDED = new Set(['.git', 'node_modules', '.playcraft-workspace.json', '.playcraft.json']);
+export class WorkspaceTransferError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+    }
+}
+function excluded(path) {
+    const parts = path.split('/');
+    return parts.some(part => EXCLUDED.has(part.toLowerCase()) || /^\.playcraft-(?:credential|transfer)-.*\.tmp$/i.test(part)) ||
+        parts.some((part, index) => part === '.playcraft' && /^(?:workspace-context(?:\..*)?|video-replication)$/.test(parts[index + 1] ?? '')) ||
+        isCredentialFile(path);
+}
+export function transferGit(root, args) {
+    const env = { PATH: process.env.PATH, HOME: tmpdir(),
+        GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: '/dev/null', GIT_TERMINAL_PROMPT: '0', GIT_ALLOW_PROTOCOL: 'file' };
+    const result = spawnSync('git', ['-c', 'core.hooksPath=/dev/null', '-c', 'commit.gpgsign=false',
+        '-c', 'core.autocrlf=false', '-c', 'user.name=PlayCraft Workspace', '-c', 'user.email=workspace@playcraft.local', ...args], { cwd: root, encoding: 'utf8', env, timeout: 120_000, maxBuffer: 8 * 1024 * 1024 });
+    if (result.status !== 0)
+        throw new WorkspaceTransferError('workspace_transfer_git_failed');
+    return result.stdout.trim();
+}
+async function copySnapshot(source, target) {
+    let bytes = 0, files = 0;
+    async function copy(directory, prefix) {
+        const directoryInfo = await lstat(directory);
+        const directoryReal = await realpath(directory);
+        if (!directoryInfo.isDirectory() || directoryInfo.isSymbolicLink() ||
+            (directoryReal !== source && !directoryReal.startsWith(`${source}${sep}`)))
+            throw new WorkspaceTransferError('workspace_transfer_conflict');
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            const path = prefix ? `${prefix}/${entry.name}` : entry.name;
+            if (excluded(path))
+                continue;
+            const from = join(directory, entry.name), to = join(target, path);
+            const info = await lstat(from);
+            if (info.isSymbolicLink())
+                continue;
+            if (info.isDirectory()) {
+                await mkdir(to, { recursive: true });
+                await copy(from, path);
+            }
+            else if (info.isFile()) {
+                bytes += info.size;
+                files++;
+                if (bytes > WORKSPACE_TRANSFER_MAX_BYTES || files > MAX_FILES)
+                    throw new WorkspaceTransferError('workspace_transfer_too_large');
+                if (!(await realpath(from)).startsWith(`${source}${sep}`))
+                    throw new WorkspaceTransferError('workspace_transfer_conflict');
+                const handle = await open(from, constants.O_RDONLY | constants.O_NOFOLLOW);
+                try {
+                    const before = await handle.stat();
+                    if (!before.isFile() || before.dev !== info.dev || before.ino !== info.ino || before.size !== info.size ||
+                        before.mtimeMs !== info.mtimeMs || before.ctimeMs !== info.ctimeMs)
+                        throw new WorkspaceTransferError('workspace_transfer_conflict');
+                    const chunks = [];
+                    let size = 0;
+                    for await (const chunk of handle.createReadStream({ autoClose: false })) {
+                        size += chunk.length;
+                        if (size > before.size)
+                            throw new WorkspaceTransferError('workspace_transfer_conflict');
+                        chunks.push(chunk);
+                    }
+                    const after = await handle.stat();
+                    if (size !== before.size || after.size !== before.size || after.mtimeMs !== before.mtimeMs || after.ctimeMs !== before.ctimeMs)
+                        throw new WorkspaceTransferError('workspace_transfer_conflict');
+                    await writeFile(to, Buffer.concat(chunks));
+                }
+                finally {
+                    await handle.close();
+                }
+                await chmod(to, info.mode & 0o111 ? 0o755 : 0o644);
+            }
+        }
+    }
+    await copy(source, '');
+}
+async function matchesFile(root, path, expected) {
+    const target = await safeTarget(root, path);
+    const info = await lstat(target).catch(error => { if (['ENOENT', 'ENOTDIR'].includes(error.code))
+        return undefined; throw error; });
+    if (!expected)
+        return !info || info.isDirectory();
+    if (!info?.isFile() || Boolean(info.mode & 0o111) !== expected.executable)
+        return false;
+    const handle = await open(target, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const stat = await handle.stat();
+        const hash = createHash(expected.sha.length === 64 ? 'sha256' : 'sha1');
+        hash.update(`blob ${stat.size}\0`);
+        for await (const chunk of handle.createReadStream({ autoClose: false }))
+            hash.update(chunk);
+        return hash.digest('hex') === expected.sha;
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function removeEmptyParents(root, target) {
+    let parent = dirname(target);
+    while (parent !== root) {
+        if ((await readdir(parent)).length > 0)
+            break;
+        await rmdir(parent);
+        parent = dirname(parent);
+    }
+}
+async function installFile(root, path, source, executable) {
+    const target = await safeTarget(root, path);
+    const existing = await lstat(target).catch(error => { if (error.code === 'ENOENT')
+        return undefined; throw error; });
+    if (existing?.isDirectory())
+        await rmdir(target);
+    await mkdir(dirname(target), { recursive: true });
+    const stage = join(dirname(target), `.playcraft-transfer-${randomUUID()}.tmp`);
+    try {
+        await copyFile(source, stage);
+        await chmod(stage, executable ? 0o755 : 0o644);
+        await rename(stage, target);
+    }
+    catch (error) {
+        await rm(stage, { force: true }).catch(() => undefined);
+        await removeEmptyParents(root, target).catch(() => undefined);
+        throw error;
+    }
+    finally {
+        await rm(stage, { force: true }).catch(() => undefined);
+    }
+}
+/** A fresh history contains only the current portable files, including uncommitted changes. */
+export async function createWorkspaceTransfer(root) {
+    const temporary = await mkdtemp(join(tmpdir(), 'playcraft-transfer-'));
+    const cleanup = () => rm(temporary, { recursive: true, force: true });
+    try {
+        const checkout = join(temporary, 'checkout');
+        await mkdir(checkout);
+        await copySnapshot(await realpath(root), checkout);
+        transferGit(checkout, ['init', '--initial-branch=main']);
+        transferGit(checkout, ['add', '--force', '--all']);
+        transferGit(checkout, ['commit', '--allow-empty', '-m', 'Workspace snapshot']);
+        const tree = transferGit(checkout, ['rev-parse', 'HEAD^{tree}']);
+        const head = transferGit(checkout, ['rev-parse', 'HEAD']);
+        const bundlePath = join(temporary, 'workspace.bundle');
+        transferGit(checkout, ['bundle', 'create', bundlePath, 'HEAD']);
+        return { bundlePath, tree, head, cleanup };
+    }
+    catch (error) {
+        await cleanup();
+        throw error;
+    }
+}
+function treeEntries(root) {
+    const entries = transferGit(root, ['ls-tree', '-r', '-z', 'HEAD']).split('\0').filter(Boolean).map(line => {
+        const match = /^(100644|100755) blob ([a-f0-9]{40,64})\t(.+)$/s.exec(line);
+        if (!match)
+            throw new WorkspaceTransferError('invalid_workspace_transfer');
+        const path = match[3];
+        if (path.length > 1024 || path.includes('\\') || path.startsWith('/') || /[\x00-\x1f\x7f]/.test(path) ||
+            path.split('/').some(part => !part || part === '.' || part === '..') || excluded(path))
+            throw new WorkspaceTransferError('invalid_workspace_transfer');
+        return { path, sha: match[2], executable: match[1] === '100755' };
+    });
+    if (entries.length > MAX_FILES)
+        throw new WorkspaceTransferError('workspace_transfer_too_large');
+    const normalized = entries.map(entry => entry.path.toLowerCase());
+    if (new Set(normalized).size !== entries.length)
+        throw new WorkspaceTransferError('invalid_workspace_transfer');
+    return entries;
+}
+async function safeTarget(root, path) {
+    const target = resolve(root, path);
+    if (!target.startsWith(`${root}${sep}`))
+        throw new WorkspaceTransferError('invalid_workspace_transfer');
+    let current = root;
+    for (const segment of path.split('/')) {
+        current = join(current, segment);
+        const info = await lstat(current).catch(error => { if (['ENOENT', 'ENOTDIR'].includes(error.code))
+            return undefined; throw error; });
+        if (info?.isSymbolicLink())
+            throw new WorkspaceTransferError('workspace_transfer_symlink');
+    }
+    return target;
+}
+/** Compare the entire checkout before applying local commits, so cloud edits are never overwritten. */
+export async function applyWorkspaceTransfer(root, bundle, expectedTree) {
+    if (!/^[a-f0-9]{40,64}$/.test(expectedTree))
+        throw new WorkspaceTransferError('invalid_workspace_transfer');
+    if (!bundle.byteLength || bundle.byteLength > WORKSPACE_TRANSFER_MAX_BYTES)
+        throw new WorkspaceTransferError('workspace_transfer_too_large');
+    const rootReal = await realpath(root);
+    const temporary = await mkdtemp(join(tmpdir(), 'playcraft-import-'));
+    let current;
+    try {
+        const bundlePath = join(temporary, 'incoming.bundle'), incoming = join(temporary, 'checkout');
+        await writeFile(bundlePath, bundle, { mode: 0o600 });
+        transferGit(temporary, ['clone', '--no-checkout', '--', bundlePath, incoming]);
+        const entries = treeEntries(incoming);
+        const tree = transferGit(incoming, ['rev-parse', 'HEAD^{tree}']);
+        const head = transferGit(incoming, ['rev-parse', 'HEAD']);
+        let bytes = 0;
+        for (const entry of entries) {
+            bytes += Number(transferGit(incoming, ['cat-file', '-s', entry.sha]));
+            if (bytes > WORKSPACE_TRANSFER_MAX_BYTES)
+                throw new WorkspaceTransferError('workspace_transfer_too_large');
+        }
+        current = await createWorkspaceTransfer(rootReal);
+        if (current.tree === tree)
+            return { tree, head, changedPaths: [] };
+        if (current.tree !== expectedTree)
+            throw new WorkspaceTransferError('workspace_transfer_conflict');
+        const baseline = join(dirname(current.bundlePath), 'checkout');
+        const previous = new Map(treeEntries(baseline).map(entry => [entry.path, entry]));
+        const next = new Map(entries.map(entry => [entry.path, entry]));
+        const changedPaths = [...new Set([...previous.keys(), ...next.keys()])]
+            .filter(path => previous.get(path)?.sha !== next.get(path)?.sha || previous.get(path)?.executable !== next.get(path)?.executable);
+        for (const path of changedPaths) {
+            const target = await safeTarget(rootReal, path);
+            const info = await lstat(target).catch(error => { if (['ENOENT', 'ENOTDIR'].includes(error.code))
+                return undefined; throw error; });
+            if (next.has(path) && info?.isDirectory()) {
+                const children = await readdir(target, { recursive: true });
+                for (const child of children) {
+                    const childPath = `${path}/${child.split(sep).join('/')}`;
+                    const childInfo = await lstat(join(target, child));
+                    if (!childInfo.isDirectory() && (!previous.has(childPath) || next.has(childPath)))
+                        throw new WorkspaceTransferError('workspace_transfer_conflict');
+                }
+            }
+        }
+        transferGit(incoming, ['checkout', '--force']);
+        const recheck = await createWorkspaceTransfer(rootReal);
+        try {
+            if (recheck.tree !== expectedTree)
+                throw new WorkspaceTransferError('workspace_transfer_conflict');
+        }
+        finally {
+            await recheck.cleanup();
+        }
+        const applied = [];
+        try {
+            // Deleting files first also permits a file to become a directory, or the reverse.
+            for (const path of changedPaths.filter(path => !next.has(path)).sort((a, b) => b.length - a.length)) {
+                if (!await matchesFile(rootReal, path, previous.get(path)))
+                    throw new WorkspaceTransferError('workspace_transfer_conflict');
+                await rm(await safeTarget(rootReal, path), { force: true });
+                applied.push(path);
+                await removeEmptyParents(rootReal, join(rootReal, path));
+            }
+            for (const path of changedPaths.filter(path => next.has(path))) {
+                if (!await matchesFile(rootReal, path, previous.get(path)))
+                    throw new WorkspaceTransferError('workspace_transfer_conflict');
+                const entry = next.get(path);
+                await installFile(rootReal, path, join(incoming, path), entry.executable);
+                applied.push(path);
+            }
+        }
+        catch (error) {
+            // Roll back only our writes; never replace another writer's intervening content.
+            for (const path of applied.reverse()) {
+                if (!await matchesFile(rootReal, path, next.get(path)))
+                    throw new WorkspaceTransferError('workspace_transfer_rollback_conflict');
+                const old = previous.get(path);
+                if (old)
+                    await installFile(rootReal, path, join(baseline, path), old.executable);
+                else {
+                    await rm(await safeTarget(rootReal, path), { force: true });
+                    await removeEmptyParents(rootReal, join(rootReal, path));
+                }
+            }
+            throw error;
+        }
+        return { tree, head, changedPaths };
+    }
+    finally {
+        await current?.cleanup();
+        await rm(temporary, { recursive: true, force: true });
+    }
+}

package/dist/workspace-runtime/workspaces/turn-changes.js

@@ -0,0 +1,75 @@
+import { TURN_FILES_CHANGED_EVENT, } from '@playcraft/common/cloud-workspace/runtime';
+import { diffWorkspaceTrees, retainTurnSnapshots, snapshotWorkspaceTree } from './git.js';
+import { shareWorkspaceGit } from './shared-git.js';
+const TURN_ENDS = new Set(['turn/completed', 'turn.completed', 'turn.interrupted', 'turn.failed']);
+/**
+ * Snapshots taken when a session's turn starts, until that turn ends. Kept in memory only: a
+ * restart ends the native turn as well, and that turn then simply reports no changes.
+ */
+const started = new WeakMap();
+function turnsOf(state) {
+    let turns = started.get(state);
+    if (!turns)
+        started.set(state, turns = new Map());
+    return turns;
+}
+/**
+ * Records the work tree before a turn is sent. A directory that cannot be snapshotted (no
+ * repository, Git failure) gets no change summary; the turn itself is never held back by it.
+ */
+export async function beginTurnChanges(state, sessionId, input) {
+    turnsOf(state).delete(sessionId);
+    if (input.directoryName === 'root')
+        return;
+    await shareWorkspaceGit(state, input.root).catch(() => undefined);
+    const before = await snapshotWorkspaceTree(input.root).catch(() => undefined);
+    if (before)
+        turnsOf(state).set(sessionId, { ...input, before });
+}
+/** A turn that never started has nothing to compare. */
+export function abandonTurnChanges(state, sessionId) {
+    turnsOf(state).delete(sessionId);
+}
+/**
+ * When a session's turn ends, compares the work tree with its start and records the files that
+ * changed for that session's conversation. Returns no event when nothing changed.
+ */
+export async function finishTurnChanges(state, event) {
+    const { threadId, turnId } = event;
+    if (!TURN_ENDS.has(event.method) || !threadId || !turnId)
+        return [];
+    const session = state.journal.listSessions().find((item) => item.threadId === threadId);
+    const start = session && turnsOf(state).get(session.sessionId);
+    if (!session || !start)
+        return [];
+    turnsOf(state).delete(session.sessionId);
+    try {
+        await shareWorkspaceGit(state, start.root);
+        const after = await snapshotWorkspaceTree(start.root);
+        const { files, truncated } = await diffWorkspaceTrees(start.root, start.before, after);
+        if (!files.length)
+            return [];
+        await retainTurnSnapshots(start.root, turnId, start.before, after);
+        const changes = { threadId, turnId, before: start.before, after, files, truncated };
+        return [await state.journal.allocateSourceEvent({
+                runtimeId: state.config.runtimeId,
+                generation: state.config.generation,
+                runtimeEpoch: state.runtimeEpoch,
+                type: TURN_FILES_CHANGED_EVENT,
+                payload: {
+                    ...changes,
+                    sessionId: session.sessionId,
+                    ...(start.workspaceId ? { workspaceId: start.workspaceId } : {}),
+                    ...(start.directoryName ? { directoryName: start.directoryName } : {}),
+                },
+                occurredAt: new Date().toISOString(),
+                sessionId: session.sessionId,
+                workspaceId: start.workspaceId,
+                threadId,
+                turnId,
+            })];
+    }
+    catch {
+        return [];
+    }
+}

package/dist/workspace-runtime/workspaces/video-attachments.js

@@ -0,0 +1,49 @@
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { WORKSPACE_VIDEO_ATTACHMENT_MAX_DURATION_MS, WORKSPACE_VIDEO_ATTACHMENT_MAX_BYTES } from '@playcraft/common/cloud-workspace/runtime';
+/** Probe the opened descriptor so replacing a pathname cannot redirect the media reader. */
+export async function probeAttachmentVideo(handle) {
+    const output = await new Promise((resolve, reject) => {
+        const child = spawn(process.env.PLAYCRAFT_FFPROBE_PATH ?? 'ffprobe', [
+            '-v', 'error', '-protocol_whitelist', 'file,pipe', '-show_entries',
+            'format=format_name,duration:stream=codec_type,width,height', '-of', 'json',
+            process.platform === 'linux' ? '/proc/self/fd/3' : '/dev/fd/3',
+        ], { stdio: ['ignore', 'pipe', 'ignore', handle.fd] });
+        let text = '';
+        const timer = setTimeout(() => { child.kill('SIGKILL'); reject(new Error('invalid_attachment')); }, 15_000);
+        timer.unref();
+        child.stdout.on('data', (chunk) => {
+            text += chunk.toString('utf8');
+            if (text.length > 64 * 1024) {
+                child.kill('SIGKILL');
+                reject(new Error('invalid_attachment'));
+            }
+        });
+        child.once('error', () => { clearTimeout(timer); reject(new Error('video_probe_unavailable')); });
+        child.once('close', code => { clearTimeout(timer); code === 0 ? resolve(text) : reject(new Error('invalid_attachment')); });
+    });
+    const result = JSON.parse(output);
+    const stream = result.streams?.find(item => item.codec_type === 'video');
+    const durationMs = Math.round(Number(result.format?.duration) * 1000);
+    const formats = result.format?.format_name?.split(',') ?? [];
+    const mimeType = formats.includes('webm') ? 'video/webm' : formats.includes('mp4') ? 'video/mp4' : formats.includes('mov') ? 'video/quicktime' : undefined;
+    if (!stream || !mimeType || !Number.isFinite(durationMs) || durationMs <= 0 || durationMs > WORKSPACE_VIDEO_ATTACHMENT_MAX_DURATION_MS
+        || !Number.isSafeInteger(stream.width) || !Number.isSafeInteger(stream.height) || stream.width <= 0 || stream.height <= 0
+        || stream.width > 16384 || stream.height > 16384)
+        throw new Error('invalid_attachment');
+    return { mimeType, durationMs, width: stream.width, height: stream.height };
+}
+export async function hashAttachment(handle) {
+    const digest = createHash('sha256');
+    const chunk = Buffer.allocUnsafe(64 * 1024);
+    let position = 0;
+    for (;;) {
+        const { bytesRead } = await handle.read(chunk, 0, chunk.length, position);
+        if (!bytesRead)
+            return digest.digest('hex');
+        digest.update(chunk.subarray(0, bytesRead));
+        position += bytesRead;
+        if (position > WORKSPACE_VIDEO_ATTACHMENT_MAX_BYTES)
+            throw new Error('invalid_attachment');
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playcraft/cli",
-  "version": "0.1.35-prod",
+  "version": "0.1.37-beta",
   "private": false,
   "type": "module",
   "engines": {
@@ -14,16 +14,18 @@
     "dist",
     "templates",
     "project-template",
+    "project-template-v2",
     "engine-packs",
     "project-templates",
     "REMIX.md",
+    "SKILLS_REGISTRY.md",
     "README.md"
   ],
   "scripts": {
     "dev": "tsc -w",
-    "build": "tsc",
+    "build": "node scripts/generate-video-skills.mjs && tsc",
     "start": "node dist/index.js",
-    "test": "vitest run",
+    "test": "pnpm build && vitest run",
     "test:agent": "node scripts/run-agent-tests.mjs --list",
     "test:agent:designer": "node scripts/run-agent-tests.mjs game-designer",
     "test:agent:developer": "node scripts/run-agent-tests.mjs developer",
@@ -35,6 +37,10 @@
     "test:agent:gate": "node scripts/run-agent-tests.mjs gate",
     "test:agent:vlm": "node scripts/run-agent-tests.mjs vlm",
     "test:agent:stop": "node scripts/run-agent-tests.mjs stop",
+    "generate:platform-skills": "node scripts/generate-platform-skills.mjs",
+    "verify:platform-skills": "node scripts/generate-platform-skills.mjs --check",
+    "generate:video-skills": "node scripts/generate-video-skills.mjs",
+    "verify:video-skills": "node scripts/generate-video-skills.mjs --check && node --test scripts/generate-video-skills.test.mjs",
     "verify:agent-stop": "node scripts/verify-agent-stop.mjs",
     "verify-sprite-overlay": "node scripts/verify-sprite-overlay.mjs",
     "link": "node scripts/bump-local.js && pnpm build && npm link",
@@ -45,8 +51,9 @@
     "@gltf-transform/core": "^4.3.0",
     "@gltf-transform/extensions": "^4.3.0",
     "@gltf-transform/functions": "^4.3.0",
-    "@playcraft/build": "^0.1.34",
-    "@playcraft/common": "^0.1.34",
+    "@playcraft/build": "^0.1.37-beta",
+    "@playcraft/common": "^0.1.37-beta",
+    "better-sqlite3-pinned": "npm:better-sqlite3@13.0.3",
     "chokidar": "^4.0.3",
     "commander": "^13.1.0",
     "cors": "^2.8.6",
@@ -62,8 +69,10 @@
     "json5": "^2.2.3",
     "latest-version": "^7.0.0",
     "music-metadata": "^11.12.3",
+    "node-pty": "1.0.0",
     "ora": "^8.2.0",
     "picocolors": "^1.1.1",
+    "playwright-core": "1.52.0",
     "sharp": "^0.34.5",
     "update-notifier": "^7.3.1",
     "ws": "^8.19.0",
@@ -79,6 +88,7 @@
     "@types/sharp": "^0.32.0",
     "@types/update-notifier": "^6.0.8",
     "@types/ws": "^8.18.1",
+    "esbuild": "^0.28.1",
     "typescript": "^5.9.3",
     "vitest": "^3.2.4"
   }