@playcraft/cli 0.1.54 → 0.1.55-beta

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

@@ -0,0 +1,191 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { cp, lstat, mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import { basename, dirname, join } from 'node:path';
+import { load } from 'js-yaml';
+import { canonicalProjectSkillsJson, createCanonicalBundleArchive, effectiveProjectSkills, extractBundleArchive, inspectProjectSkills, readProjectSkillSource, readProjectSkillsLockFile, sourceTreeDigest, validateProjectSkillsSnapshot, } from '@playcraft/common/project-skills';
+import { initializeLocalProjectSkills } from '../../project-skills/local-store.js';
+import { resolveCliPackageRoot } from '../../scaffold/compose.js';
+import { selectPlatformSkillSnapshot } from '../../project-skills/builtin-import.js';
+import { EMPTY_WORKSPACE_REPOSITORY_SKILLS, EMPTY_WORKSPACE_PLATFORM_SKILLS } from './empty-template.js';
+import { excludeFromGit } from './dependencies.js';
+import { selectOptionalPlatformSkills } from './optional-platform-skills.js';
+/** Runtime availability is determined by the locked metadata, independent of unsynced source edits. */
+export async function readWorkspaceSkillSnapshot(root) {
+    const management = await lstat(join(root, '.playcraft'));
+    const declaration = join(root, '.playcraft/skills.json');
+    const stat = await lstat(declaration);
+    if (!management.isDirectory() || management.isSymbolicLink() || !stat.isFile() || stat.isSymbolicLink() || stat.size > 1024 * 1024)
+        throw new Error('workspace_skills_invalid');
+    return validateProjectSkillsSnapshot(await readFile(declaration, 'utf8'), await readProjectSkillsLockFile(root));
+}
+/** Existing managed projects keep their exact selection. Legacy source folders are adopted once. */
+export async function ensureWorkspaceSkills(root, cache, access, options = {}) {
+    await excludeFromGit(root, '/.playcraft/skills/');
+    await excludeFromGit(root, '/.playcraft/skill-artifacts/');
+    const raw = await readProjectSkillsLockFile(root);
+    if (raw !== null) {
+        await readWorkspaceSkillSnapshot(root);
+        return;
+    }
+    const inventory = await inspectProjectSkills(root);
+    if (inventory.issues.length)
+        throw new Error('workspace_skills_invalid');
+    const names = new Set(inventory.discovered.map(entry => basename(entry.root)));
+    const platformNames = EMPTY_WORKSPACE_PLATFORM_SKILLS.filter(name => !names.has(name));
+    const select = options.optionalPlatformDefaults ? selectOptionalPlatformSkills : selectPlatformSkillSnapshot;
+    const selected = platformNames.length ? await select(platformNames, access) : undefined;
+    const added = new Set();
+    await initializeLocalProjectSkills(root, cache, { enabledRoots: added, platform: selected,
+        prepareSources: async () => {
+            for (const name of EMPTY_WORKSPACE_REPOSITORY_SKILLS) {
+                if (names.has(name))
+                    continue;
+                await safeDirectory(root, '.agents/skills');
+                const source = `.agents/skills/${name}`;
+                await mkdir(join(root, source), { mode: 0o755 });
+                added.add(source);
+                const template = join(resolveCliPackageRoot(), 'project-template/.claude/skills', name);
+                for (const child of await readdir(template))
+                    await cp(join(template, child), join(root, source, child), {
+                        recursive: true, force: false, errorOnExist: true,
+                    });
+            }
+        },
+        rollbackSources: async () => {
+            for (const source of added)
+                await rm(join(root, source), { recursive: true, force: true });
+        },
+    });
+}
+async function safeDirectory(root, path) {
+    let current = root;
+    for (const segment of path.split('/')) {
+        current = join(current, segment);
+        await mkdir(current, { mode: 0o755 }).catch(error => { if (error.code !== 'EEXIST')
+            throw error; });
+        const stat = await lstat(current);
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            throw new Error('workspace_skills_invalid');
+    }
+    return current;
+}
+/** Cache misses may reconstruct only the exact locked repository bytes, never a newer source. */
+async function lockedFiles(root, cache, entry, view, loadArtifact) {
+    const persistent = await safeDirectory(root, '.playcraft/skill-artifacts');
+    const saved = join(persistent, `${entry.revision.artifactHash}.tar.gz`);
+    const path = join(cache, `${entry.revision.artifactHash}.tar.gz`);
+    let archive;
+    try {
+        const stat = await lstat(saved);
+        if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 || stat.size > 80 * 1024 * 1024)
+            throw new Error('workspace_skills_invalid_bundle');
+        archive = await readFile(saved);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+        try {
+            archive = await readFile(path);
+        }
+        catch (cacheError) {
+            if (cacheError.code !== 'ENOENT')
+                throw cacheError;
+            const declaration = view.declaration.entries.find(item => item.entryKey === entry.entryKey);
+            if (entry.revision.kind === 'source' && declaration.source.kind === 'repository') {
+                const source = await readProjectSkillSource(root, declaration);
+                if (source.sourceTreeHash !== entry.sourceTreeHash)
+                    throw new Error('workspace_skills_source_changed');
+                archive = createCanonicalBundleArchive(source.files.map(file => ({ path: file.path, data: Buffer.from(file.content) })));
+            }
+            else {
+                if (!loadArtifact)
+                    throw new Error('workspace_skills_artifact_unavailable');
+                archive = await loadArtifact(entry);
+            }
+        }
+    }
+    if (createHash('sha256').update(archive).digest('hex') !== entry.revision.artifactHash)
+        throw new Error('workspace_skills_digest_mismatch');
+    const extracted = extractBundleArchive(archive);
+    if (extracted.issues.length)
+        throw new Error('workspace_skills_invalid_bundle');
+    if (entry.revision.kind === 'source' && sourceTreeDigest(extracted.files.map(file => ({ path: file.path, content: file.data }))) !== entry.sourceTreeHash)
+        throw new Error('workspace_skills_digest_mismatch');
+    const temporary = `${saved}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporary, archive, { flag: 'wx', mode: 0o644 });
+        await rename(temporary, saved);
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+    return extracted.files;
+}
+function metadata(entryKey, content) {
+    const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(content);
+    const parsed = frontmatter ? load(frontmatter[1]) : {};
+    const data = parsed && typeof parsed === 'object' ? parsed : {};
+    return { entryKey, name: typeof data.name === 'string' ? data.name : entryKey,
+        description: typeof data.description === 'string' ? data.description : '', content };
+}
+export async function readWorkspaceSkills(root, cache, loadArtifact) {
+    const snapshot = await readWorkspaceSkillSnapshot(root);
+    const skills = await Promise.all(snapshot.lock.entries.map(async (entry) => {
+        const files = await lockedFiles(root, cache, entry, snapshot, loadArtifact);
+        const body = files.find(file => file.path === 'SKILL.md');
+        if (!body)
+            throw new Error('workspace_skills_body_missing');
+        return metadata(entry.entryKey, body.data.toString('utf8'));
+    }));
+    return { ...snapshot, lockHash: createHash('sha256').update(canonicalProjectSkillsJson(snapshot.lock)).digest('hex'), skills };
+}
+/** Read-only task generation lives outside source discovery and is omitted from Git/snapshots. */
+export async function freezeWorkspaceSkills(root, cache, loadArtifact) {
+    const snapshot = await readWorkspaceSkillSnapshot(root);
+    const entries = effectiveProjectSkills(snapshot.declaration, snapshot.lock, 'sandbox-agent');
+    const base = await safeDirectory(root, '.playcraft/skills');
+    const lockHash = createHash('sha256').update(canonicalProjectSkillsJson(snapshot.lock)).digest('hex');
+    const generation = await safeDirectory(base, lockHash);
+    const skills = [];
+    const expectedFiles = new Set();
+    for (const entry of entries) {
+        const files = await lockedFiles(root, cache, entry, snapshot, loadArtifact);
+        for (const file of files) {
+            const target = join(generation, entry.entryKey, file.path);
+            const relative = join(entry.entryKey, file.path);
+            expectedFiles.add(relative);
+            await safeDirectory(generation, dirname(relative));
+            await writeFile(target, file.data, { flag: 'wx', mode: 0o444 }).catch(async (error) => {
+                if (error.code !== 'EEXIST')
+                    throw error;
+                const stat = await lstat(target);
+                if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 || !file.data.equals(await readFile(target)))
+                    throw new Error('workspace_skills_digest_mismatch');
+            });
+        }
+        const body = files.find(file => file.path === 'SKILL.md');
+        if (!body)
+            throw new Error('workspace_skills_body_missing');
+        const info = metadata(entry.entryKey, body.data.toString('utf8'));
+        skills.push({ name: info.name, description: info.description, skillRef: entry.revision.skillRef,
+            revision: entry.revision.kind === 'source' ? entry.revision.sourceRevision : entry.revision.version,
+            path: join(generation, entry.entryKey, 'SKILL.md') });
+    }
+    const verifyTree = async (directory, relative = '') => {
+        for (const item of await readdir(directory, { withFileTypes: true })) {
+            const path = join(relative, item.name);
+            if (item.isSymbolicLink())
+                throw new Error('workspace_skills_invalid_bundle');
+            if (item.isDirectory()) {
+                if (![...expectedFiles].some(file => file.startsWith(`${path}/`)))
+                    throw new Error('workspace_skills_invalid_bundle');
+                await verifyTree(join(directory, item.name), path);
+            }
+            else if (!item.isFile() || !expectedFiles.has(path))
+                throw new Error('workspace_skills_invalid_bundle');
+        }
+    };
+    await verifyTree(generation);
+    return { declarationHash: snapshot.lock.declarationHash,
+        lockHash, skills };
+}

package/dist/workspace-runtime/workspaces/theme-asset-index.js

@@ -0,0 +1,157 @@
+import { createHash } from 'node:crypto';
+import JSON5 from 'json5';
+export class ThemeAssetIndexError extends Error {
+    code = 'parameter_asset_index_unsupported';
+    constructor() { super('parameter_asset_index_unsupported'); }
+}
+/** A bounded lexer recognizes the standard literal registry without evaluating project code. */
+function lex(source) {
+    if (Buffer.byteLength(source) > 1024 * 1024 || source.startsWith('#!'))
+        throw new ThemeAssetIndexError();
+    const result = [];
+    for (let i = 0; i < source.length;) {
+        if (/\s/.test(source[i])) {
+            i++;
+            continue;
+        }
+        if (source.startsWith('//', i)) {
+            const end = source.indexOf('\n', i + 2);
+            i = end < 0 ? source.length : end;
+            continue;
+        }
+        if (source.startsWith('/*', i)) {
+            const end = source.indexOf('*/', i + 2);
+            if (end < 0)
+                throw new ThemeAssetIndexError();
+            i = end + 2;
+            continue;
+        }
+        const start = i, char = source[i];
+        if (char === '`')
+            throw new ThemeAssetIndexError();
+        if (char === '"' || char === "'") {
+            i++;
+            for (; i < source.length; i++) {
+                if (source[i] === '\\') {
+                    i++;
+                    continue;
+                }
+                if (source[i] === char)
+                    break;
+            }
+            if (i >= source.length)
+                throw new ThemeAssetIndexError();
+            i++;
+            let value;
+            try {
+                value = JSON5.parse(source.slice(start, i));
+            }
+            catch {
+                throw new ThemeAssetIndexError();
+            }
+            if (typeof value !== 'string')
+                throw new ThemeAssetIndexError();
+            result.push({ text: source.slice(start, i), start, end: i, string: value });
+        }
+        else {
+            const identifier = /^[A-Za-z_$][A-Za-z0-9_$]*/.exec(source.slice(i))?.[0];
+            i += identifier?.length ?? 1;
+            result.push({ text: identifier ?? char, start, end: i });
+        }
+        if (result.length > 100_000)
+            throw new ThemeAssetIndexError();
+    }
+    return result;
+}
+function registry(source) {
+    const tokens = lex(source), starts = [];
+    let depth = 0;
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (!depth && token.text === 'const' && tokens[i + 1]?.text === 'assetRecordByPath')
+            starts.push(i + 2);
+        if (token.string === undefined && token.text === '{')
+            depth++;
+        if (token.string === undefined && token.text === '}')
+            depth--;
+    }
+    if (starts.length !== 1)
+        throw new ThemeAssetIndexError();
+    const exportStart = tokens.findIndex((token, i) => token.text === 'export' && tokens[i + 1]?.text === 'default' && tokens[i + 2]?.text === '{');
+    if (exportStart < 0)
+        throw new ThemeAssetIndexError();
+    let exportDepth = 1, exportsRegistry = false;
+    for (let i = exportStart + 3; i < tokens.length && exportDepth; i++) {
+        const token = tokens[i];
+        const previous = tokens[i - 1]?.text;
+        const properKey = previous === ':' && (tokens[i - 2]?.text === 'assetRecordByPath' || tokens[i - 2]?.string === 'assetRecordByPath');
+        if (exportDepth === 1 && token.text === 'assetRecordByPath' && [',', '}'].includes(tokens[i + 1]?.text ?? '')
+            && (previous === '{' || previous === ',' || properKey))
+            exportsRegistry = true;
+        if (token.string === undefined && token.text === '{')
+            exportDepth++;
+        if (token.string === undefined && token.text === '}')
+            exportDepth--;
+    }
+    if (!exportsRegistry || exportDepth !== 0)
+        throw new ThemeAssetIndexError();
+    let cursor = starts[0];
+    while (tokens[cursor] && tokens[cursor].text !== '=') {
+        if (tokens[cursor].text === ';')
+            throw new ThemeAssetIndexError();
+        cursor++;
+    }
+    if (tokens[++cursor]?.text !== '{')
+        throw new ThemeAssetIndexError();
+    cursor++;
+    const entries = new Map();
+    let lastValueEnd, trailingComma = false;
+    while (tokens[cursor]?.text !== '}') {
+        const key = tokens[cursor], colon = tokens[cursor + 1], value = tokens[cursor + 2];
+        if (key?.string === undefined || colon?.text !== ':' || !value || !/^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value.text)
+            || entries.has(key.string))
+            throw new ThemeAssetIndexError();
+        entries.set(key.string, value.text);
+        lastValueEnd = value.end;
+        cursor += 3;
+        trailingComma = tokens[cursor]?.text === ',';
+        if (trailingComma)
+            cursor++;
+        else if (tokens[cursor]?.text !== '}')
+            throw new ThemeAssetIndexError();
+        if (!tokens[cursor])
+            throw new ThemeAssetIndexError();
+    }
+    const end = tokens[cursor].start;
+    const imports = new Map();
+    for (let i = 0; i < tokens.length - 3; i++) {
+        if (tokens[i].text === 'import' && /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(tokens[i + 1].text)
+            && tokens[i + 1].text !== 'type' && tokens[i + 2].text === 'from' && tokens[i + 3].string !== undefined)
+            imports.set(tokens[i + 3].string, tokens[i + 1].text);
+    }
+    return { end, lastValueEnd, trailingComma, entries, imports, tokens };
+}
+/** Add only literal imports/entries; retain user exports, comments, unrelated mappings and files. */
+export function registerThemeAsset(source, value, importPath) {
+    if (!value || !importPath.startsWith('./') && !importPath.startsWith('../') || /[\r\n\x00]/.test(importPath))
+        throw new ThemeAssetIndexError();
+    const state = registry(source);
+    const imported = state.imports.get(importPath);
+    const existing = state.entries.get(value);
+    if (existing) {
+        if (imported === existing)
+            return source;
+        throw new ThemeAssetIndexError();
+    }
+    const variable = imported ?? '__playcraftParameterAsset_' + createHash('sha256').update(importPath).digest('hex').slice(0, 16);
+    if (!imported && state.tokens.some(token => token.string === undefined && token.text === variable))
+        throw new ThemeAssetIndexError();
+    let result = source;
+    let end = state.end;
+    if (state.lastValueEnd !== undefined && !state.trailingComma) {
+        result = result.slice(0, state.lastValueEnd) + ',' + result.slice(state.lastValueEnd);
+        end++;
+    }
+    result = result.slice(0, end) + `\n  ${JSON.stringify(value)}: ${variable},\n` + result.slice(end);
+    return (imported ? '' : `import ${variable} from ${JSON.stringify(importPath)};\n`) + result;
+}

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

@@ -0,0 +1,69 @@
+import { lstat, opendir, realpath, statfs } from 'node:fs/promises';
+import { join, sep } from 'node:path';
+import { WorkspaceTransferError } from './transfer.js';
+/** Includes dependencies and repository metadata; symbolic links never expand the charged tree. */
+export async function workspaceStorageBytes(root) {
+    const source = await realpath(root);
+    let bytes = 0;
+    const walk = async (directory) => {
+        const before = await lstat(directory), actual = await realpath(directory);
+        if (!before.isDirectory() || before.isSymbolicLink() || (actual !== source && !actual.startsWith(`${source}${sep}`)))
+            throw new WorkspaceTransferError('workspace_transfer_conflict');
+        for await (const entry of await opendir(directory)) {
+            const path = join(directory, entry.name);
+            const info = await lstat(path);
+            if (info.isSymbolicLink())
+                continue;
+            if (info.isDirectory())
+                await walk(path);
+            else if (info.isFile())
+                bytes += info.size;
+            if (!Number.isSafeInteger(bytes))
+                throw new WorkspaceTransferError('workspace_transfer_storage_unavailable');
+        }
+        const after = await lstat(directory);
+        if (after.isSymbolicLink() || after.dev !== before.dev || after.ino !== before.ino)
+            throw new WorkspaceTransferError('workspace_transfer_conflict');
+    };
+    await walk(source);
+    return bytes;
+}
+export async function transferDiskBudget(path) {
+    try {
+        const disk = await statfs(path);
+        const available = disk.bavail * disk.bsize;
+        const reserve = Math.ceil(disk.blocks * disk.bsize * 0.1);
+        if (disk.bsize <= 0 || disk.blocks <= 0 || available < 0 || reserve < 0 ||
+            !Number.isSafeInteger(available) || !Number.isSafeInteger(reserve))
+            throw new Error();
+        return { available, reserve, budget: Math.max(0, available - reserve) };
+    }
+    catch {
+        throw new WorkspaceTransferError('workspace_transfer_storage_unavailable');
+    }
+}
+export async function assertTransferDiskSpace(path, required) {
+    const disk = await transferDiskBudget(path);
+    if (required > disk.budget)
+        throw new WorkspaceTransferError('workspace_transfer_disk_full', {
+            metric: 'diskBytes', actual: required, limit: disk.budget,
+            availableBytes: disk.available, reserveBytes: disk.reserve,
+        });
+}
+export async function checkWorkspaceTransferQuota(workspaceRoot, current, incoming, limitBytes) {
+    const usedBytes = await workspaceStorageBytes(workspaceRoot);
+    const projectedBytes = Math.max(0, usedBytes - current.bytes) + incoming.bytes;
+    if (!Number.isSafeInteger(projectedBytes))
+        throw new WorkspaceTransferError('invalid_workspace_transfer');
+    if (limitBytes !== undefined && projectedBytes > limitBytes) {
+        throw new WorkspaceTransferError('workspace_transfer_quota_exceeded', {
+            metric: 'workspaceBytes', actual: projectedBytes, limit: limitBytes, usedBytes,
+            currentBytes: current.bytes, incomingBytes: incoming.bytes, fileCount: incoming.files,
+        });
+    }
+    const disk = await transferDiskBudget(workspaceRoot);
+    // The staged replacement may coexist with the old file until its atomic rename.
+    await assertTransferDiskSpace(workspaceRoot, incoming.bytes);
+    return { limitBytes: limitBytes ?? null, usedBytes, projectedBytes,
+        diskAvailableBytes: disk.available, diskReserveBytes: disk.reserve };
+}