@playcraft/cli 0.1.53-beta → 0.1.54

package/dist/project-skills/local-store.js

@@ -1,221 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { mkdir, readFile, rename, rm, writeFile, lstat } from 'node:fs/promises';
-import { join, resolve } from 'node:path';
-import { homedir } from 'node:os';
-import { projectSkillsMessage as t } from './messages.js';
-import { buildLocalProjectSkillsSnapshot, canonicalProjectSkillsJson, extractBundleArchive, createCanonicalBundleArchive, readProjectSkillSource, sourceTreeDigest, readProjectSkillsLockFile, inspectProjectSkills, setProjectSkillEnabled, validateProjectSkillsSnapshot, declarationDigest, effectiveProjectSkills, PROJECT_SKILLS_DECLARATION_PATH, PROJECT_SKILLS_LOCK_PATH, } from '@playcraft/common/project-skills';
-export const projectSkillsCache = () => process.env.PLAYCRAFT_SKILLS_CACHE_DIR
-    ? resolve(process.env.PLAYCRAFT_SKILLS_CACHE_DIR) : join(homedir(), '.playcraft', 'skill-artifacts');
-export async function readLocalProjectSkillSnapshot(directory) {
-    const inventory = await inspectProjectSkills(directory);
-    if (inventory.issues.length)
-        throw new Error(JSON.stringify(inventory.issues));
-    return validateProjectSkillsSnapshot(inventory.declaration, await readProjectSkillsLockFile(directory));
-}
-/** Serializes local writers; an interrupted pair is diagnosed by the declaration digest. */
-async function change(directory, action) {
-    const management = join(directory, '.playcraft');
-    await mkdir(management, { recursive: true });
-    if ((await lstat(management)).isSymbolicLink())
-        throw new Error('Linked project management directory');
-    const lease = join(management, 'skills-write.lock');
-    await writeFile(lease, `${process.pid}\n`, { flag: 'wx', mode: 0o600 });
-    try {
-        return await action();
-    }
-    finally {
-        await rm(lease);
-    }
-}
-async function writeSnapshot(directory, snapshot) {
-    validateProjectSkillsSnapshot(snapshot.declaration, snapshot.lock);
-    for (const [file, value] of [[PROJECT_SKILLS_DECLARATION_PATH, snapshot.declaration], [PROJECT_SKILLS_LOCK_PATH, snapshot.lock]]) {
-        const target = join(directory, file), temporary = `${target}.${randomUUID()}.tmp`;
-        await writeFile(temporary, `${canonicalProjectSkillsJson(value)}\n`, { flag: 'wx', mode: 0o644 });
-        await rename(temporary, target);
-    }
-}
-/** Initializes an unmanaged checkout with one complete source and release snapshot under the existing writer lease. */
-export async function initializeLocalProjectSkills(directory, cache, options) {
-    return change(directory, async () => {
-        if (await readProjectSkillsLockFile(directory) !== null)
-            throw new Error('skills_revision_conflict');
-        const declarationPath = join(directory, PROJECT_SKILLS_DECLARATION_PATH);
-        let originalDeclaration;
-        try {
-            const stat = await lstat(declarationPath);
-            if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 1024 * 1024)
-                throw new Error('workspace_skills_invalid');
-            originalDeclaration = await readFile(declarationPath);
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT')
-                throw error;
-        }
-        let configurationWriteStarted = false;
-        try {
-            await options.prepareSources?.();
-            const snapshot = buildLocalProjectSkillsSnapshot(await inspectProjectSkills(directory));
-            for (const entry of snapshot.declaration.entries)
-                if (entry.source.kind === 'repository' && options.enabledRoots.has(entry.source.root))
-                    entry.enabled = true;
-            if (options.platform) {
-                const platform = validateProjectSkillsSnapshot(options.platform.declaration, options.platform.lock);
-                if (platform.declaration.entries.some(entry => entry.source.kind !== 'registry'))
-                    throw new Error('workspace_skills_invalid');
-                snapshot.declaration.entries.push(...platform.declaration.entries);
-                snapshot.lock.entries.push(...platform.lock.entries);
-            }
-            snapshot.lock.declarationHash = declarationDigest(snapshot.declaration);
-            validateProjectSkillsSnapshot(snapshot.declaration, snapshot.lock);
-            await mkdir(cache, { recursive: true, mode: 0o700 });
-            // Every artifact is ready before the first configuration write; an input/output failure cannot leave a valid subset lock.
-            for (const artifact of [...snapshot.artifacts, ...(options.platform?.artifacts ?? [])]) {
-                if (createHash('sha256').update(artifact.archive).digest('hex') !== artifact.artifactHash)
-                    throw new Error('workspace_skills_digest_mismatch');
-                const target = join(cache, `${artifact.artifactHash}.tar.gz`), temporary = `${target}.${randomUUID()}.tmp`;
-                try {
-                    await writeFile(temporary, artifact.archive, { flag: 'wx', mode: 0o600 });
-                    await rename(temporary, target);
-                }
-                finally {
-                    await rm(temporary, { force: true });
-                }
-            }
-            configurationWriteStarted = true;
-            await writeSnapshot(directory, snapshot);
-            return { declaration: snapshot.declaration, lock: snapshot.lock };
-        }
-        catch (error) {
-            if (configurationWriteStarted) {
-                if (originalDeclaration === undefined)
-                    await rm(declarationPath, { force: true });
-                else {
-                    const temporary = `${declarationPath}.${randomUUID()}.tmp`;
-                    try {
-                        await writeFile(temporary, originalDeclaration, { flag: 'wx', mode: 0o644 });
-                        await rename(temporary, declarationPath);
-                    }
-                    finally {
-                        await rm(temporary, { force: true });
-                    }
-                }
-                await rm(join(directory, PROJECT_SKILLS_LOCK_PATH), { force: true });
-            }
-            await options.rollbackSources?.();
-            throw error;
-        }
-    });
-}
-export async function syncLocalProjectSkills(directory, cache = projectSkillsCache()) {
-    return change(directory, async () => {
-        let previous;
-        try {
-            previous = await readProjectSkillsLockFile(directory) ?? undefined;
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT')
-                throw error;
-        }
-        const snapshot = buildLocalProjectSkillsSnapshot(await inspectProjectSkills(directory), previous);
-        await mkdir(cache, { recursive: true, mode: 0o700 });
-        for (const artifact of snapshot.artifacts) {
-            const target = join(cache, `${artifact.artifactHash}.tar.gz`);
-            const temporary = `${target}.${randomUUID()}.tmp`;
-            await writeFile(temporary, artifact.archive, { flag: 'wx', mode: 0o600 });
-            await rename(temporary, target);
-        }
-        await writeSnapshot(directory, snapshot);
-        return { declaration: snapshot.declaration, lock: snapshot.lock };
-    });
-}
-export async function enableLocalProjectSkill(directory, entryKey, enabled) {
-    return change(directory, async () => {
-        const previous = await readLocalProjectSkillSnapshot(directory);
-        const next = setProjectSkillEnabled(previous.declaration, previous.lock, entryKey, enabled);
-        // Disabled required dependencies are shown immediately, before changing either file.
-        for (const surface of ['portal-agent', 'sandbox-agent', 'build-time'])
-            effectiveProjectSkills(next.declaration, next.lock, surface);
-        await writeSnapshot(directory, next);
-        return next;
-    });
-}
-/** Restores exact cached bytes to a new generation. Never writes source directories. */
-export async function installFrozenProjectSkills(directory, cache = projectSkillsCache()) {
-    const snapshot = await readLocalProjectSkillSnapshot(directory);
-    const generation = join(cache, 'runs', randomUUID());
-    const effective = effectiveProjectSkills(snapshot.declaration, snapshot.lock, 'sandbox-agent');
-    try {
-        await mkdir(generation, { recursive: true, mode: 0o700 });
-        for (const entry of effective) {
-            const cached = join(cache, `${entry.revision.artifactHash}.tar.gz`);
-            let archive;
-            try {
-                archive = await readFile(cached);
-            }
-            catch (error) {
-                if (error.code !== 'ENOENT' || entry.revision.kind !== 'source')
-                    throw error;
-                const declaration = snapshot.declaration.entries.find(item => item.entryKey === entry.entryKey);
-                const source = await readProjectSkillSource(directory, declaration);
-                if (source.sourceTreeHash !== entry.sourceTreeHash)
-                    throw new Error(`Source digest mismatch: ${entry.entryKey}`);
-                archive = createCanonicalBundleArchive(source.files.map(file => ({ path: file.path, data: Buffer.from(file.content) })));
-                if (createHash('sha256').update(archive).digest('hex') !== entry.revision.artifactHash)
-                    throw new Error(`Artifact digest mismatch: ${entry.entryKey}`);
-                await writeFile(cached, archive, { flag: 'wx', mode: 0o600 }).catch(error => { if (error.code !== 'EEXIST')
-                    throw error; });
-            }
-            if (createHash('sha256').update(archive).digest('hex') !== entry.revision.artifactHash)
-                throw new Error(`Artifact digest mismatch: ${entry.entryKey}`);
-            const extracted = extractBundleArchive(archive);
-            if (extracted.issues.length)
-                throw new Error(JSON.stringify(extracted.issues));
-            if (entry.revision.kind === 'source' && sourceTreeDigest(extracted.files.map(file => ({ path: file.path, content: file.data }))) !== entry.sourceTreeHash)
-                throw new Error(`Source digest mismatch: ${entry.entryKey}`);
-            for (const file of extracted.files) {
-                const target = join(generation, entry.entryKey, file.path);
-                await mkdir(join(target, '..'), { recursive: true });
-                await writeFile(target, file.data, { flag: 'wx', mode: 0o444 });
-            }
-        }
-        return { generation, entries: effective.length, declarationHash: snapshot.lock.declarationHash };
-    }
-    catch (error) {
-        await rm(generation, { recursive: true, force: true });
-        throw error;
-    }
-}
-export async function explainLocalProjectSkills(directory) {
-    const { declaration, lock } = await readLocalProjectSkillSnapshot(directory);
-    return declaration.entries.map((entry) => ({ ...entry, locked: lock.entries.find((locked) => locked.entryKey === entry.entryKey), reason: entry.enabled ? 'enabled_in_project' : 'disabled_in_project' }));
-}
-export async function adoptServerProjectSkillSnapshot(directory, expected, response, checkpoint) {
-    const next = validateProjectSkillsSnapshot(response.declaration, response.lock);
-    const withoutIdentity = (snapshot) => ({
-        declaration: { ...snapshot.declaration, entries: snapshot.declaration.entries.map(entry => ({ ...entry,
-                source: entry.source.kind === 'repository' ? { kind: entry.source.kind, root: entry.source.root } : entry.source })) },
-        entries: snapshot.lock.entries.map(entry => ({ entryKey: entry.entryKey, sourceTreeHash: entry.sourceTreeHash,
-            dependencies: entry.dependencies,
-            revision: entry.revision.kind === 'source' ? { ...entry.revision, skillRef: undefined } : entry.revision })),
-    });
-    if (canonicalProjectSkillsJson(withoutIdentity(expected)) !== canonicalProjectSkillsJson(withoutIdentity(next)))
-        throw new Error(t('reconcileChanged'));
-    return change(directory, async () => {
-        const current = await readLocalProjectSkillSnapshot(directory);
-        if (canonicalProjectSkillsJson(current) !== canonicalProjectSkillsJson(expected))
-            throw new Error(t('reconcileChanged'));
-        for (const entry of current.declaration.entries) {
-            if (entry.source.kind !== 'repository')
-                continue;
-            const source = await readProjectSkillSource(directory, entry);
-            if (source.sourceTreeHash !== current.lock.entries.find(item => item.entryKey === entry.entryKey)?.sourceTreeHash)
-                throw new Error(t('reconcileChanged'));
-        }
-        checkpoint();
-        const changed = canonicalProjectSkillsJson(current) !== canonicalProjectSkillsJson(next);
-        if (changed)
-            await writeSnapshot(directory, next);
-        return { changed };
-    });
-}

package/dist/project-skills/messages.js

@@ -1,80 +0,0 @@
-const messages = {
-    en: {
-        importBuiltins: 'Import published platform skills in Cloud Workspace; preserve exact existing revisions',
-        platformRequired: 'Use Cloud Workspace’s Skills panel to import published platform skills. Local template import is unavailable.',
-        expectedDeclarationHash: 'Expected declaration digest from the current skill lock',
-        expectedLockHash: 'Expected digest of the canonical current skill lock',
-        reconcile: 'Register the pushed commit and adopt verified platform skill identities',
-        reconcileChanged: 'The branch, source bytes, or settings changed. Sync, commit and push the current project before reconciling.',
-        reconcilePending: 'Indexing continues on the server. Retry reconcile later. Operation:',
-        reconcileFailed: 'Skill indexing failed. Inspect the project adoption operation and retry it.',
-        reconcileNext: 'Skills are registered. Run skills project reconcile to adopt the verified identities locally.',
-        reconcileCommit: 'Verified skill identities saved. Commit the declaration and lock, then run remix push.',
-        reconcileUnchanged: 'Local skills match the registered platform revisions.',
-        pushIndexFailed: 'Git push succeeded, but skill indexing did not finish. Run skills project reconcile to retry.',
-        unregistered: 'New skill sources are not in the project lock. Run skills project sync before starting a task.',
-        online: 'Download missing exact artifacts using this Remix’s platform authorization',
-        downloadMismatch: 'The server has no authorized artifact matching this local lock. Sync the project first.',
-        commitRequired: 'Skill source or lock changes are ready. Commit them, then run remix push again.',
-        run: 'Run a task with the frozen project skills in OpenCode 1.18.31',
-        usage: 'Show locally reported skill deliveries (no chat upload)',
-        model: 'OpenCode model identifier; credentials come from the local environment',
-        runner: 'Managed skills require OpenCode 1.18.31.',
-        sync: 'Save source revisions and cache their exact artifacts offline',
-        install: 'Restore exactly the saved lock from the local cache',
-        frozen: 'Require exact locked artifacts',
-        enable: 'Enable a project skill for the next run',
-        disable: 'Disable a project skill for the next run',
-        explain: 'Explain configured revisions, sources and enablement',
-        description: 'Inspect and validate this project’s managed skills',
-        inspect: 'Inspect source directories and declarations without changing files',
-        verify: 'Validate the saved lock and local source bytes',
-        directory: 'Project directory',
-        json: 'Print structured output',
-        verified: 'Local skill sources and configuration match the lock. Server authorization and runner verification are separate checks.',
-        failed: 'Skill verification failed',
-        missing: 'The project does not have a managed declaration and lock yet.',
-        changed: 'Source files have changed since the saved revision',
-    },
-    zh: {
-        importBuiltins: '在云工作区导入已发布平台技能，保留已有精确修订',
-        platformRequired: '请在云工作区的技能面板导入已发布平台技能；本地模板导入已停用。',
-        expectedDeclarationHash: '当前技能锁中的声明摘要',
-        expectedLockHash: '当前技能锁规范化内容的摘要',
-        reconcile: '登记已推送的提交，并采用平台核验后的技能身份',
-        reconcileChanged: '分支、源文件或配置发生变化，请同步、提交并推送当前项目后再对账。',
-        reconcilePending: '服务端仍在登记，请稍后重新运行 reconcile。操作编号：',
-        reconcileFailed: '技能登记失败，请检查项目接管操作并重试。',
-        reconcileNext: '技能源已登记，请运行 skills project reconcile 在本地采用已核验的身份。',
-        reconcileCommit: '已保存核验后的技能身份，请提交声明和锁文件，然后运行 remix push。',
-        reconcileUnchanged: '本地技能与平台登记的修订一致。',
-        pushIndexFailed: 'Git 推送成功，但技能登记未完成。请运行 skills project reconcile 重试。',
-        unregistered: '发现尚未登记到项目锁的技能源，请先运行 skills project sync 再开始任务。',
-        online: '使用此 Remix 的平台权限下载缺失的精确制品',
-        downloadMismatch: '服务端没有与此本地锁匹配的授权制品，请先同步项目。',
-        commitRequired: '技能源或锁文件已更新，请提交这些修改后再次运行 remix push。',
-        run: '使用固定项目技能和 OpenCode 1.18.31 运行任务',
-        usage: '查看本地自报的技能加载记录（不上传聊天）',
-        model: 'OpenCode 模型标识；凭据使用本地环境',
-        runner: '受控技能需要 OpenCode 1.18.31。',
-        sync: '保存源修订并离线缓存精确制品',
-        install: '按锁从本地缓存还原精确制品',
-        frozen: '要求精确锁定制品',
-        enable: '在下次运行中启用项目技能',
-        disable: '在下次运行中停用项目技能',
-        explain: '解释配置的修订、来源与启停状态',
-        description: '检查和验证当前项目的受控技能',
-        inspect: '检查技能源目录和声明，不修改文件',
-        verify: '验证已保存的锁和本地源文件',
-        directory: '项目目录',
-        json: '输出结构化结果',
-        verified: '本地技能源和配置与锁一致。服务端授权和运行器验证仍需单独检查。',
-        failed: '技能验证失败',
-        missing: '此项目还没有受控技能声明和锁。',
-        changed: '源文件与已保存的修订不一致',
-    },
-};
-export function projectSkillsMessage(key) {
-    const locale = process.env.PLAYCRAFT_LANGUAGE || process.env.LANG || 'en';
-    return messages[locale.startsWith('zh') ? 'zh' : 'en'][key];
-}

package/dist/project-skills/reconcile.js

@@ -1,62 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { PlayCraftHttpClient } from '../utils/playcraft-http-client.js';
-import { readRemixLocalMeta } from '../remix/local-git.js';
-import { readLocalProjectSkillSnapshot, adoptServerProjectSkillSnapshot } from './local-store.js';
-import { projectSkillsMessage as t } from './messages.js';
-/** Register the saved commit, then adopt only identity changes for the same local bytes and settings. */
-export async function reconcileLocalProjectSkills(directory, options = {}) {
-    const metadata = readRemixLocalMeta(directory);
-    const git = (args) => {
-        const result = spawnSync('git', args, { cwd: directory, encoding: 'utf8' });
-        if (result.status !== 0)
-            throw new Error(t('reconcileChanged'));
-        return result.stdout.trim();
-    };
-    if (git(['branch', '--show-current']) !== metadata.branch)
-        throw new Error(t('reconcileChanged'));
-    const commit = git(['rev-parse', 'HEAD']);
-    const snapshot = await readLocalProjectSkillSnapshot(directory);
-    const paths = [
-        '.playcraft/skills.json',
-        '.playcraft/skills.lock.json',
-        ...snapshot.declaration.entries.flatMap((entry) => entry.source.kind === 'repository' ? [entry.source.root, ...(entry.projectFiles ?? [])] : []),
-    ];
-    if (git(['status', '--porcelain', '--', ...paths]))
-        throw new Error(t('commitRequired'));
-    const client = new PlayCraftHttpClient(options);
-    const base = `/projects/${encodeURIComponent(metadata.projectId)}/skills`;
-    const query = new URLSearchParams({ branch: metadata.branch });
-    const request = () => ({ signal: AbortSignal.timeout(30_000), redirect: 'error' });
-    const view = await client.get(`${base}/config?${query}`, undefined, request());
-    let operation = await client.post(`${base}/index`, { branch: metadata.branch, commit, expectedRevisionId: view.configuration?.id ?? null }, request());
-    const deadline = Date.now() + 15 * 60_000;
-    while (!['completed', 'failed', 'blocked', 'cancelled'].includes(operation.phase)) {
-        if (Date.now() > deadline)
-            throw new Error(`${t('reconcilePending')} ${operation.id}`);
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-        operation = await client.get(`${base}/adoptions/${operation.id}?${query}`, undefined, request());
-    }
-    if (operation.phase !== 'completed')
-        throw new Error(operation.issues?.[0]?.detail || t('reconcileFailed'));
-    const updated = await client.get(`${base}/config?${query}`, undefined, request());
-    if (!updated.configuration || updated.configuration.id !== operation.configRevisionId)
-        throw new Error(t('reconcileChanged'));
-    if (!options.write)
-        return {
-            operationId: operation.id,
-            configRevisionId: operation.configRevisionId,
-            commit,
-            message: t('reconcileNext'),
-        };
-    const result = await adoptServerProjectSkillSnapshot(directory, snapshot, updated.configuration, () => {
-        if (git(['rev-parse', 'HEAD']) !== commit || git(['status', '--porcelain', '--', ...paths]))
-            throw new Error(t('reconcileChanged'));
-    });
-    return {
-        ...result,
-        operationId: operation.id,
-        configRevisionId: operation.configRevisionId,
-        commit,
-        message: result.changed ? t('reconcileCommit') : t('reconcileUnchanged'),
-    };
-}

package/dist/project-skills/remote-cache.js

@@ -1,51 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { mkdir, writeFile, rename, readFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { PlayCraftHttpClient } from '../utils/playcraft-http-client.js';
-import { readRemixLocalMeta } from '../remix/local-git.js';
-import { readLocalProjectSkillSnapshot, projectSkillsCache } from './local-store.js';
-import { projectSkillsMessage as t } from './messages.js';
-/** Only exact project-authorized revisions; identifiers inside Git never grant download access. */
-export async function downloadLocalProjectSkillArtifacts(directory, cache = projectSkillsCache()) {
-    const meta = readRemixLocalMeta(directory), client = new PlayCraftHttpClient();
-    const snapshot = await readLocalProjectSkillSnapshot(directory);
-    const query = new URLSearchParams({ branch: meta.branch });
-    const view = await client.get(`/projects/${encodeURIComponent(meta.projectId)}/skills/config?${query}`);
-    await mkdir(cache, { recursive: true, mode: 0o700 });
-    let downloaded = 0;
-    for (const locked of snapshot.lock.entries) {
-        const file = join(cache, `${locked.revision.artifactHash}.tar.gz`);
-        try {
-            if (createHash('sha256').update(await readFile(file)).digest('hex') === locked.revision.artifactHash)
-                continue;
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT')
-                throw error;
-        }
-        const authorized = view.entries?.find(entry => entry.entryKey === locked.entryKey && entry.artifactHash === locked.revision.artifactHash);
-        if (!authorized)
-            throw new Error(t('downloadMismatch'));
-        const response = await fetch(client.url(`/projects/${encodeURIComponent(meta.projectId)}/skills/versions/${authorized.versionId}/archive?${query}`), {
-            headers: { Authorization: `Bearer ${client.token}`, 'X-Request-Id': client.requestId }, redirect: 'error', signal: AbortSignal.timeout(60000),
-        });
-        if (!response.ok || !response.body)
-            throw new Error(`${t('downloadMismatch')} (${response.status})`);
-        const parts = [];
-        let size = 0;
-        for await (const chunk of response.body) {
-            size += chunk.byteLength;
-            if (size > 80 * 1024 * 1024)
-                throw new Error(t('downloadMismatch'));
-            parts.push(Buffer.from(chunk));
-        }
-        const archive = Buffer.concat(parts);
-        if (createHash('sha256').update(archive).digest('hex') !== locked.revision.artifactHash)
-            throw new Error(t('downloadMismatch'));
-        const temporary = `${file}.${randomUUID()}.tmp`;
-        await writeFile(temporary, archive, { mode: 0o600, flag: 'wx' });
-        await rename(temporary, file);
-        downloaded++;
-    }
-    return { downloaded };
-}

package/dist/project-skills/validation.js

@@ -1,19 +0,0 @@
-import { readProjectSkillSource, inspectProjectSkills } from '@playcraft/common/project-skills';
-import { readLocalProjectSkillSnapshot } from './local-store.js';
-import { projectSkillsMessage as t } from './messages.js';
-export async function verifyLocalProjectSkills(directory) {
-    const snapshot = await readLocalProjectSkillSnapshot(directory);
-    const inventory = await inspectProjectSkills(directory);
-    if (inventory.sources.length !== snapshot.declaration.entries.filter(entry => entry.source.kind === 'repository').length) {
-        throw new Error(t('unregistered'));
-    }
-    for (const entry of snapshot.declaration.entries) {
-        if (entry.source.kind !== 'repository')
-            continue;
-        const actual = await readProjectSkillSource(directory, entry);
-        const expected = snapshot.lock.entries.find((locked) => locked.entryKey === entry.entryKey);
-        if (actual.sourceTreeHash !== expected?.sourceTreeHash)
-            throw new Error(`${t('changed')}: ${entry.entryKey}`);
-    }
-    return { valid: true, declarationHash: snapshot.lock.declarationHash, entries: snapshot.lock.entries.length, scope: 'local-source-and-config' };
-}

package/dist/recording/messages.js

@@ -1,40 +0,0 @@
-const messages = {
-    en: {
-        topic: 'Record a playable with real browser input', record: 'Record a scenario and fresh-context interaction controls',
-        url: 'Running playable URL on this workspace loopback interface', scenario: 'Validated scenario JSON file',
-        out: 'Empty artifact directory', browser: 'Absolute Chromium executable path', timeout: 'Maximum recording time in seconds',
-        invalidArguments: 'Invalid recording arguments or scenario.', invalidUrl: 'The playable URL must use HTTP on the workspace loopback interface without credentials.',
-        browserUnavailable: 'Chromium or the Playwright video encoder is unavailable. Check the workspace image.',
-        navigationFailed: 'The playable did not navigate successfully or left its authorized origin.',
-        projectChanged: 'Project inputs changed while recording. Record the current project again.',
-        projectUnavailable: 'The project input digest could not be completed safely.',
-        recordingFailed: 'Recording failed. Inspect the partial recording and runtime logs.',
-        outputConflict: 'The recording output directory must be empty.',
-        recording: 'Recording the playable and interaction controls',
-        timedOut: 'Recording timed out. Partial evidence was preserved.', interrupted: 'Recording was interrupted. Partial evidence was preserved.',
-    },
-    zh: {
-        topic: '使用真实浏览器输入录制可玩作品', record: '录制操作场景和使用独立空上下文的交互对照',
-        url: '当前工作区回环地址上的作品服务', scenario: '经过验证的操作场景文件', out: '空的证据输出目录',
-        browser: 'Chromium 可执行文件的绝对路径', timeout: '录制最长秒数', invalidArguments: '录制参数或场景无效。',
-        invalidUrl: '作品地址必须使用工作区回环接口的 HTTP 协议，不能包含凭据。',
-        browserUnavailable: 'Chromium 或 Playwright 视频编码器不可用，请检查工作区镜像。',
-        navigationFailed: '作品导航失败，或跳转离开了授权来源。', projectChanged: '录制时工程输入发生了变化，请基于当前工程重新录制。',
-        projectUnavailable: '无法安全完成工程输入摘要。', recordingFailed: '录制失败，请检查保留的局部录像和运行日志。',
-        outputConflict: '录制输出目录必须为空。', recording: '正在录制作品和交互对照',
-        timedOut: '录制超时，已保留局部证据。', interrupted: '录制已中断，已保留局部证据。',
-    },
-};
-export function recordingMessage(key) {
-    const language = process.env.PLAYCRAFT_LANGUAGE || process.env.LANG || 'en';
-    return messages[language.startsWith('zh') ? 'zh' : 'en'][key];
-}
-export class RecordingError extends Error {
-    code;
-    exitCode;
-    constructor(code, exitCode = 4) {
-        super(recordingMessage(code));
-        this.code = code;
-        this.exitCode = exitCode;
-    }
-}

package/dist/recording/project-digest.js

@@ -1,85 +0,0 @@
-import { createHash } from 'node:crypto';
-import { execFile } from 'node:child_process';
-import { lstat, open, readdir, realpath } from 'node:fs/promises';
-import { basename, dirname, relative, resolve, sep } from 'node:path';
-import { promisify } from 'node:util';
-import { RecordingError } from './messages.js';
-const execute = promisify(execFile);
-const excludedNames = new Set(['.git', 'node_modules', '.DS_Store']);
-const excludedRoots = new Set(['.agents', '.claude', '.codex', '.next', '.vite', '.cache', '.tmp', 'tmp', 'temp', 'dist', 'build', 'coverage', '.playcraft-preview-out', '.playcraft-temp']);
-const excludedInternalPaths = ['.playcraft/video-replication', '.playcraft/skills', '.playcraft/skill-artifacts', '.playcraft/skills.json', '.playcraft/skills.lock.json', '.playcraft/workspace-context.json'];
-const inside = (root, path) => path === root || path.startsWith(`${root}${sep}`);
-const canonicalPath = async (path) => {
-    const absolute = resolve(path);
-    try {
-        return await realpath(absolute);
-    }
-    catch {
-        const parent = dirname(absolute);
-        if (parent === absolute)
-            throw new RecordingError('projectUnavailable', 64);
-        return resolve(await canonicalPath(parent), basename(absolute));
-    }
-};
-/** Hash source, resources, configuration and dependency manifests, including untracked inputs. */
-export async function computeProjectInputDigest(root, excludedOutputDirectories = []) {
-    try {
-        const actualRoot = await realpath(root);
-        const excluded = await Promise.all(excludedOutputDirectories.map(canonicalPath));
-        if (excluded.some(target => inside(target, actualRoot)))
-            throw new RecordingError('projectUnavailable', 64);
-        const hash = createHash('sha256');
-        let fileCount = 0;
-        let totalBytes = 0;
-        const walk = async (directory) => {
-            const entries = (await readdir(directory, { withFileTypes: true })).sort((a, b) => a.name.localeCompare(b.name, 'en'));
-            for (const entry of entries) {
-                if (excludedNames.has(entry.name) || directory === actualRoot && excludedRoots.has(entry.name))
-                    continue;
-                const path = resolve(directory, entry.name);
-                if (excluded.some(target => inside(target, path)))
-                    continue;
-                const rel = relative(actualRoot, path).split(sep).join('/');
-                if (excludedInternalPaths.some(target => rel === target || rel.startsWith(`${target}/`)))
-                    continue;
-                const before = await lstat(path);
-                if (before.isDirectory()) {
-                    await walk(path);
-                    continue;
-                }
-                if (before.isSymbolicLink()) {
-                    const target = await realpath(path);
-                    if (!inside(actualRoot, target) || (await lstat(target)).isDirectory())
-                        throw new RecordingError('projectUnavailable', 64);
-                }
-                else if (!before.isFile())
-                    throw new RecordingError('projectUnavailable', 64);
-                const file = await open(path, 'r');
-                try {
-                    const initial = await file.stat();
-                    totalBytes += initial.size;
-                    if (++fileCount > 50_000 || totalBytes > 1024 * 1024 * 1024)
-                        throw new RecordingError('projectUnavailable', 64);
-                    const content = createHash('sha256');
-                    for await (const bytes of file.createReadStream({ autoClose: false }))
-                        content.update(bytes);
-                    const after = await file.stat();
-                    if (initial.size !== after.size || initial.mtimeMs !== after.mtimeMs || initial.ino !== after.ino)
-                        throw new RecordingError('projectChanged', 64);
-                    hash.update(`${JSON.stringify(rel)}:${initial.mode & 0o777}:${initial.size}:${content.digest('hex')}\n`);
-                }
-                finally {
-                    await file.close();
-                }
-            }
-        };
-        await walk(actualRoot);
-        const gitCommit = await execute('git', ['-C', actualRoot, 'rev-parse', 'HEAD'], { timeout: 5000, maxBuffer: 1024, encoding: 'utf8' }).then(value => value.stdout.trim()).catch(() => null);
-        return { root: actualRoot, gitCommit: gitCommit && /^[a-f0-9]{40,64}$/.test(gitCommit) ? gitCommit : null, sha256: hash.digest('hex'), fileCount };
-    }
-    catch (error) {
-        if (error instanceof RecordingError)
-            throw error;
-        throw new RecordingError('projectUnavailable', 64);
-    }
-}