@playcraft/cli 0.1.34 → 0.1.36-beta1

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

package/dist/recording/recorder.js

@@ -1,293 +0,0 @@
-import { execFile } from 'node:child_process';
-import { createHash, randomUUID } from 'node:crypto';
-import { createReadStream } from 'node:fs';
-import { access, appendFile, mkdir, readFile, rename, stat, writeFile } from 'node:fs/promises';
-import { isAbsolute, join, relative, resolve, sep } from 'node:path';
-import { performance } from 'node:perf_hooks';
-import { setTimeout as delay } from 'node:timers/promises';
-import { promisify } from 'node:util';
-import { createRequire } from 'node:module';
-import { canonicalReplicaJson, replicaRecordingMetadataSchema, } from '@playcraft/common/agent-tools';
-import { prepareArtifactDirectory, writeJsonAtomic } from '../video-replication/evidence.js';
-import { probeVideo } from '../video-replication/media.js';
-import { VideoCliError } from '../video-replication/messages.js';
-import { computeProjectInputDigest } from './project-digest.js';
-import { RecordingError, recordingMessage } from './messages.js';
-import { parseRecordingScenario, recordingControls, recordingPoint, recordingUrl } from './scenario.js';
-const execute = promisify(execFile);
-const require = createRequire(import.meta.url);
-const relativeFile = (root, path) => relative(root, path).split(sep).join('/');
-const sha = (value) => createHash('sha256').update(value).digest('hex');
-const printableUrl = (value) => { try {
-    const url = new URL(value);
-    return `${url.origin}${url.pathname}`;
-}
-catch {
-    return '[unavailable]';
-} };
-export async function hashRecordingFile(path) {
-    const hash = createHash('sha256');
-    for await (const bytes of createReadStream(path))
-        hash.update(bytes);
-    return hash.digest('hex');
-}
-async function mediaCommand(tool, args, signal) {
-    const executable = process.env[tool === 'ffmpeg' ? 'FFMPEG_PATH' : 'FFPROBE_PATH'] || tool;
-    if (executable !== tool && !isAbsolute(executable))
-        throw new RecordingError('invalidArguments', 64);
-    try {
-        return (await execute(executable, args, { timeout: 60_000, maxBuffer: 1024 * 1024, encoding: 'utf8', signal })).stdout;
-    }
-    catch (error) {
-        if (signal?.aborted)
-            throw signal.reason;
-        throw new RecordingError('recordingFailed');
-    }
-}
-export async function waitUntil(origin, atMs, signal) {
-    // Timers can wake before a fractional deadline. Never dispatch input or finish a capture early.
-    for (;;) {
-        signal.throwIfAborted();
-        const remaining = origin + atMs - performance.now();
-        if (remaining <= 0)
-            return;
-        await delay(Math.ceil(remaining), undefined, { signal });
-    }
-}
-async function dispatchStep(page, session, scenario, step, origin, signal, emit) {
-    const point = recordingPoint(scenario, step.type === 'tap' ? step : step.path[0]);
-    if (step.type === 'tap') {
-        if (scenario.pointer === 'touch')
-            await page.touchscreen.tap(point.x, point.y);
-        else
-            await page.mouse.click(point.x, point.y);
-        emit(point, 'tap', step.atMs);
-        return;
-    }
-    if (scenario.pointer === 'touch')
-        await session.send('Input.dispatchTouchEvent', { type: 'touchStart', touchPoints: [{ ...point, id: 1 }] });
-    else {
-        await page.mouse.move(point.x, point.y);
-        await page.mouse.down();
-    }
-    emit(point, 'start', step.atMs);
-    let completed = false;
-    try {
-        for (const next of step.path.slice(1)) {
-            await waitUntil(origin, step.atMs + next.offsetMs, signal);
-            const actual = recordingPoint(scenario, next);
-            if (scenario.pointer === 'touch')
-                await session.send('Input.dispatchTouchEvent', { type: 'touchMove', touchPoints: [{ ...actual, id: 1 }] });
-            else
-                await page.mouse.move(actual.x, actual.y);
-            emit(actual, 'move', step.atMs + next.offsetMs);
-        }
-        completed = true;
-    }
-    finally {
-        const release = scenario.pointer === 'touch' ? session.send('Input.dispatchTouchEvent', { type: 'touchEnd', touchPoints: [] }) : page.mouse.up();
-        if (completed) {
-            await release;
-            emit(recordingPoint(scenario, step.path.at(-1)), 'end', step.atMs + step.path.at(-1).offsetMs);
-        }
-        else
-            await release.catch(() => { });
-    }
-}
-async function recordOne(browser, root, url, scenario, variant, signal) {
-    const directory = variant.kind === 'candidate' ? root : join(root, 'controls', variant.id);
-    await mkdir(join(directory, 'screenshots'), { recursive: true });
-    const eventPath = join(directory, 'events.jsonl');
-    const consolePath = join(directory, 'console.jsonl');
-    await writeFile(eventPath, '', { flag: 'wx', mode: 0o600 });
-    await writeFile(consolePath, '', { flag: 'wx', mode: 0o600 });
-    const context = await browser.newContext({
-        viewport: { width: scenario.viewport.width, height: scenario.viewport.height }, deviceScaleFactor: scenario.viewport.deviceScaleFactor,
-        hasTouch: scenario.pointer === 'touch', isMobile: scenario.pointer === 'touch', serviceWorkers: 'block',
-        acceptDownloads: false, recordVideo: { dir: join(directory, 'capture'), size: { width: scenario.viewport.width, height: scenario.viewport.height } },
-    });
-    let logs = Promise.resolve();
-    let logBytes = 0;
-    let failed;
-    const runtime = { pageErrors: 0, consoleErrors: 0, failedRequests: 0 };
-    let origin = performance.now();
-    let inputOriginMs = Date.now();
-    const log = (path, value) => {
-        const line = `${JSON.stringify(value)}\n`;
-        logBytes += Buffer.byteLength(line);
-        if (logBytes > 16 * 1024 * 1024) {
-            failed = new RecordingError('recordingFailed');
-            return;
-        }
-        logs = logs.then(() => appendFile(path, line));
-    };
-    const closeOnAbort = () => { void context.close().catch(() => { }); };
-    signal.addEventListener('abort', closeOnAbort, { once: true });
-    let closed = false;
-    try {
-        signal.throwIfAborted();
-        const page = await context.newPage();
-        const video = page.video();
-        if (!video)
-            throw new RecordingError('browserUnavailable');
-        page.on('console', message => {
-            if (message.type() === 'error')
-                runtime.consoleErrors++;
-            log(consolePath, { atMs: performance.now() - origin, kind: 'console', level: message.type(), text: message.text().slice(0, 32768) });
-        });
-        page.on('pageerror', error => { runtime.pageErrors++; log(consolePath, { atMs: performance.now() - origin, kind: 'pageerror', level: 'error', text: error.message.slice(0, 32768) }); });
-        page.on('requestfailed', request => { runtime.failedRequests++; log(consolePath, { atMs: performance.now() - origin, kind: 'requestfailed', level: 'error', url: printableUrl(request.url()), text: request.failure()?.errorText }); });
-        context.on('page', popup => { if (popup !== page) {
-            runtime.pageErrors++;
-            log(consolePath, { atMs: performance.now() - origin, kind: 'popup', level: 'error', text: 'recording.popupUnsupported' });
-            void popup.close().catch(() => { });
-        } });
-        await context.route('**/*', async (route) => {
-            if (route.request().isNavigationRequest() && new URL(route.request().url()).origin !== url.origin) {
-                failed = new RecordingError('navigationFailed');
-                await route.abort();
-            }
-            else
-                await route.continue();
-        });
-        page.on('dialog', dialog => { runtime.pageErrors++; log(consolePath, { atMs: performance.now() - origin, kind: 'dialog', level: 'error', text: dialog.message().slice(0, 32768) }); void dialog.dismiss(); });
-        const response = await page.goto(url.href, { waitUntil: 'load', timeout: 30_000 });
-        if (!response?.ok() || new URL(page.url()).origin !== url.origin || page.isClosed())
-            throw new RecordingError('navigationFailed');
-        const initial = join(directory, 'screenshots', 'initial.png');
-        await page.screenshot({ path: initial, timeout: 10_000 });
-        origin = performance.now();
-        inputOriginMs = Date.now();
-        const screenshots = [{ path: relativeFile(root, initial), sha256: await hashRecordingFile(initial), atMs: 0 }];
-        const session = await context.newCDPSession(page);
-        log(eventPath, { kind: 'recording-start', plannedAtMs: 0, actualAtMs: 0, inputOriginMs, navigationUrl: printableUrl(url.href), finalUrl: printableUrl(page.url()), device: scenario.pointer, reset: scenario.reset, seedApplied: false });
-        for (const step of scenario.steps) {
-            await waitUntil(origin, step.atMs, signal);
-            if (failed)
-                throw failed;
-            const omitted = variant.omittedStepIds.includes(step.id);
-            const points = (step.type === 'tap' ? [{ offsetMs: 0, x: step.x, y: step.y }] : step.path).map(point => ({ ...point, actual: recordingPoint(scenario, point) }));
-            if (omitted) {
-                log(eventPath, { stepId: step.id, kind: step.type, plannedAtMs: step.atMs, actualAtMs: performance.now() - origin, device: scenario.pointer, points, status: 'omitted' });
-                continue;
-            }
-            const before = join(directory, 'screenshots', `${step.id}-before.png`);
-            await page.screenshot({ path: before, timeout: 10_000 });
-            screenshots.push({ path: relativeFile(root, before), sha256: await hashRecordingFile(before), atMs: Math.round(performance.now() - origin) });
-            const started = performance.now() - origin;
-            log(eventPath, { stepId: step.id, kind: step.type, plannedAtMs: step.atMs, actualAtMs: started, device: scenario.pointer, points, status: 'started' });
-            try {
-                await dispatchStep(page, session, scenario, step, origin, signal, (point, phase, plannedAtMs) => log(eventPath, { stepId: step.id, kind: 'pointer', phase, plannedAtMs, actualAtMs: performance.now() - origin, device: scenario.pointer, actual: point, status: 'dispatched' }));
-                log(eventPath, { stepId: step.id, kind: step.type, plannedAtMs: step.atMs, actualAtMs: started, completedAtMs: performance.now() - origin, device: scenario.pointer, points, status: 'dispatched' });
-            }
-            catch (error) {
-                log(eventPath, { stepId: step.id, kind: step.type, plannedAtMs: step.atMs, actualAtMs: started, device: scenario.pointer, points, status: 'failed' });
-                throw error;
-            }
-            const after = join(directory, 'screenshots', `${step.id}-after.png`);
-            await page.screenshot({ path: after, timeout: 10_000 });
-            screenshots.push({ path: relativeFile(root, after), sha256: await hashRecordingFile(after), atMs: Math.round(performance.now() - origin) });
-        }
-        await waitUntil(origin, scenario.durationMs, signal);
-        if (failed)
-            throw failed;
-        log(eventPath, { kind: 'recording-end', plannedAtMs: scenario.durationMs, actualAtMs: performance.now() - origin, status: 'completed' });
-        const closingAt = Date.now();
-        await context.close();
-        closed = true;
-        const closedAt = Date.now();
-        await logs;
-        const raw = join(directory, 'raw-capture.webm');
-        await rename(await video.path(), raw);
-        const rawProbe = JSON.parse(await mediaCommand('ffprobe', ['-v', 'error', '-show_entries', 'format=duration:stream=avg_frame_rate,codec_type', '-of', 'json', raw], signal));
-        const rawDuration = Number(rawProbe.format.duration) * 1000;
-        const stream = rawProbe.streams.find(value => value.codec_type === 'video');
-        const rate = stream?.avg_frame_rate.split('/').map(Number);
-        const fps = rate && rate[0] > 0 && rate[1] > 0 ? rate[0] / rate[1] : 0;
-        if (!Number.isFinite(rawDuration) || rawDuration <= 0 || !fps)
-            throw new RecordingError('recordingFailed');
-        // The encoder's final frame falls inside the measured context-close interval.
-        const rawOriginMs = closingAt - rawDuration;
-        const offsetMs = Math.max(0, inputOriginMs - rawOriginMs);
-        const candidate = join(directory, 'candidate.mp4');
-        await mediaCommand('ffmpeg', ['-v', 'error', '-nostdin', '-i', raw, '-ss', (offsetMs / 1000).toFixed(6), '-t', (scenario.durationMs / 1000).toFixed(6), '-an', '-c:v', 'libx264', '-preset', 'ultrafast', '-crf', '20', '-pix_fmt', 'yuv420p', '-movflags', '+faststart', candidate], signal);
-        const probed = await probeVideo(candidate, signal);
-        const uncertaintyMs = closedAt - closingAt + 1000 / fps + Math.max(0, rawOriginMs - inputOriginMs);
-        if (probed.source.width !== scenario.viewport.width || probed.source.height !== scenario.viewport.height || probed.source.durationMs < scenario.durationMs - uncertaintyMs - 1000 / fps)
-            throw new RecordingError('recordingFailed');
-        return {
-            ...variant, video: { path: relativeFile(root, candidate), source: probed.source, fps },
-            events: { path: relativeFile(root, eventPath), sha256: await hashRecordingFile(eventPath) }, console: { path: relativeFile(root, consolePath), sha256: await hashRecordingFile(consolePath) },
-            timing: { inputOriginMs, videoOriginMs: inputOriginMs, uncertaintyMs }, runtime, screenshots,
-        };
-    }
-    finally {
-        signal.removeEventListener('abort', closeOnAbort);
-        if (!closed)
-            await context.close().catch(() => { });
-        await logs;
-    }
-}
-export async function recordPlayable(options, signal) {
-    const runId = randomUUID();
-    let out;
-    let browser;
-    let prepared = false;
-    try {
-        const url = recordingUrl(options.url);
-        if (!options.scenario || options.browserPath && !isAbsolute(options.browserPath))
-            throw new RecordingError('invalidArguments', 64);
-        const scenarioStat = await stat(options.scenario).catch(() => { throw new RecordingError('invalidArguments', 64); });
-        if (!scenarioStat.isFile() || scenarioStat.size > 1024 * 1024)
-            throw new RecordingError('invalidArguments', 64);
-        let scenario;
-        try {
-            scenario = parseRecordingScenario(JSON.parse(await readFile(options.scenario, 'utf8')));
-        }
-        catch {
-            throw new RecordingError('invalidArguments', 64);
-        }
-        const scenarioSha256 = sha(canonicalReplicaJson(scenario));
-        const configuredPath = options.browserPath || process.env.PLAYCRAFT_CHROMIUM_PATH || '/usr/bin/chromium';
-        if (!isAbsolute(configuredPath))
-            throw new RecordingError('invalidArguments', 64);
-        await access(configuredPath).catch(() => { throw new RecordingError('browserUnavailable'); });
-        out = resolve(options.out || join('.playcraft', 'video-replication', runId, 'recording'));
-        const project = await computeProjectInputDigest(process.cwd(), [out]);
-        await prepareArtifactDirectory(out, runId, false);
-        prepared = true;
-        await writeJsonAtomic(join(out, 'metadata.json'), { schemaVersion: 'playcraft.replica-recording.v1', runId, state: 'recording', scenarioSha256 });
-        const ffmpeg = (await mediaCommand('ffmpeg', ['-version'], signal)).split('\n')[0];
-        if (!process.env.PLAYWRIGHT_BROWSERS_PATH && await access('/opt/playcraft/playwright').then(() => true, () => false))
-            process.env.PLAYWRIGHT_BROWSERS_PATH = '/opt/playcraft/playwright';
-        const { chromium } = await import('playwright-core');
-        browser = await chromium.launch({ executablePath: configuredPath, headless: true, args: ['--mute-audio', '--disable-dev-shm-usage', '--enable-unsafe-swiftshader', '--use-gl=angle', '--use-angle=swiftshader', ...(process.getuid?.() === 0 ? ['--no-sandbox'] : [])] }).catch(() => { throw new RecordingError('browserUnavailable'); });
-        process.stderr.write(`[record] ${recordingMessage('recording')}\n`);
-        const candidate = await recordOne(browser, out, url, scenario, { id: 'candidate', kind: 'candidate', omittedStepIds: [] }, signal);
-        const controls = [];
-        for (const control of recordingControls(scenario))
-            controls.push(await recordOne(browser, out, url, scenario, control, signal));
-        const current = await computeProjectInputDigest(process.cwd(), [out]);
-        if (current.sha256 !== project.sha256)
-            throw new RecordingError('projectChanged', 64);
-        const metadata = replicaRecordingMetadataSchema.parse({
-            schemaVersion: 'playcraft.replica-recording.v1', runId, state: 'completed', scenario, scenarioSha256, project,
-            toolVersions: { cli: require('../../package.json').version, playwright: require('playwright-core/package.json').version, browser: browser.version(), ffmpeg },
-            conditions: { audio: 'muted', seedSupport: scenario.seed ? 'best-effort' : 'not-requested', serverStateReset: 'not-guaranteed' },
-            candidate, controls,
-        });
-        await writeJsonAtomic(join(out, 'metadata.json'), metadata);
-        return { exitCode: 0, envelope: { schemaVersion: 'playcraft.video-cli.v1', command: 'playable record', runId, state: 'completed', ok: true,
-                artifacts: { metadata: join(out, 'metadata.json'), candidate: join(out, candidate.video.path), controls: controls.map(control => join(out, control.video.path)) }, result: metadata } };
-    }
-    catch (error) {
-        const code = error instanceof RecordingError ? error.code : error instanceof VideoCliError && error.code === 'outputConflict' ? 'outputConflict' : signal.aborted ? signal.reason?.name === 'TimeoutError' ? 'timedOut' : 'interrupted' : 'recordingFailed';
-        const exitCode = error instanceof RecordingError || error instanceof VideoCliError ? error.exitCode : signal.aborted ? code === 'timedOut' ? 75 : 130 : 4;
-        if (out && prepared)
-            await writeJsonAtomic(join(out, 'metadata.json'), { schemaVersion: 'playcraft.replica-recording.v1', runId, state: 'failed', error: { code } }).catch(() => { });
-        return { exitCode, envelope: { schemaVersion: 'playcraft.video-cli.v1', command: 'playable record', runId, state: 'failed', ok: false, ...(out && prepared ? { artifacts: { metadata: join(out, 'metadata.json') } } : {}), error: { code, message: recordingMessage(code) } } };
-    }
-    finally {
-        await browser?.close().catch(() => { });
-    }
-}

package/dist/recording/scenario.js

@@ -1,50 +0,0 @@
-import { replicaScenarioSchema } from '@playcraft/common/agent-tools';
-import { RecordingError } from './messages.js';
-export function recordingUrl(value) {
-    try {
-        if (!value)
-            throw new Error();
-        const url = new URL(value);
-        if (url.protocol !== 'http:' || !['127.0.0.1', '[::1]', 'localhost'].includes(url.hostname) || url.username || url.password || url.hash)
-            throw new Error();
-        return url;
-    }
-    catch {
-        throw new RecordingError('invalidUrl', 64);
-    }
-}
-export function parseRecordingScenario(value) {
-    const parsed = replicaScenarioSchema.safeParse(value);
-    if (!parsed.success)
-        throw new RecordingError('invalidArguments', 64);
-    const scenario = parsed.data;
-    if (scenario.draft || scenario.viewport.width % 2 || scenario.viewport.height % 2 || scenario.steps.length > 63 || scenario.steps.some(step => step.id.length > 110))
-        throw new RecordingError('invalidArguments', 64);
-    const ids = new Set();
-    let previousEnd = -1;
-    for (const step of scenario.steps) {
-        if (ids.has(step.id) || step.atMs < previousEnd)
-            throw new RecordingError('invalidArguments', 64);
-        ids.add(step.id);
-        const end = step.atMs + (step.type === 'drag' ? step.path.at(-1).offsetMs : 0);
-        if (end >= scenario.durationMs)
-            throw new RecordingError('invalidArguments', 64);
-        if (step.type === 'drag' && (step.path[0].offsetMs !== 0 || step.path.some((point, index) => index > 0 && point.offsetMs <= step.path[index - 1].offsetMs)))
-            throw new RecordingError('invalidArguments', 64);
-        previousEnd = end;
-    }
-    const required = new Set(scenario.requiredEffects.map(effect => effect.stepId));
-    if ([...required].some(id => !ids.has(id)) || (scenario.controls.noInput ? 1 : 0) + (scenario.controls.omitRequiredSteps ? required.size : 0) > 4)
-        throw new RecordingError('invalidArguments', 64);
-    return scenario;
-}
-export function recordingControls(scenario) {
-    return [
-        ...(scenario.controls.noInput ? [{ id: 'control-no-input', kind: 'no-input', omittedStepIds: scenario.steps.map(step => step.id) }] : []),
-        ...(scenario.controls.omitRequiredSteps ? [...new Set(scenario.requiredEffects.map(effect => effect.stepId))].map(id => ({ id: `control-omit-${id}`, kind: 'omit-step', omittedStepIds: [id] })) : []),
-    ];
-}
-export function recordingPoint(scenario, point) {
-    const rect = scenario.contentRect;
-    return { x: (rect.x + point.x * rect.width) * scenario.viewport.width, y: (rect.y + point.y * rect.height) * scenario.viewport.height };
-}

package/dist/utils/environment-endpoints.js

@@ -1,17 +0,0 @@
-function publicBase(value) {
-    const base = new URL(value);
-    if (!['http:', 'https:'].includes(base.protocol) || base.username || base.password || base.search || base.hash) {
-        throw new Error('invalid_environment_endpoint');
-    }
-    base.pathname = base.pathname.replace(/\/+$/, '');
-    return base;
-}
-function append(base, path) {
-    return new URL(`${base.toString().replace(/\/+$/, '')}/${path.replace(/^\/+/, '')}`);
-}
-/** Accept either a public deployment base or its /api endpoint, without duplicating /api. */
-export function businessEndpoint(apiUrl, path) {
-    const base = publicBase(apiUrl);
-    base.pathname = base.pathname.replace(/\/api$/, '');
-    return append(base, path);
-}

package/dist/utils/tool-operation-journal.js

@@ -1,124 +0,0 @@
-import { createHash, randomUUID } from 'node:crypto';
-import { mkdirSync, readdirSync, readFileSync, writeFileSync, renameSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { isAbsolute, join } from 'node:path';
-import { isAgentToolRequestId } from '@playcraft/common/agent-tools';
-/** Operations this process is sending now; never continued by another call of this process. */
-const inFlight = new Set();
-/** Linux start time of a process, so a reused pid is not taken for the process that held it. */
-function startOf(pid) {
-    try {
-        const stat = readFileSync(`/proc/${pid}/stat`, 'utf8');
-        return stat.slice(stat.lastIndexOf(')') + 2).split(' ')[19] ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-function holderAlive(holder) {
-    if (!holder || holder.pid === process.pid)
-        return false;
-    try {
-        process.kill(holder.pid, 0);
-    }
-    catch (error) {
-        if (error.code !== 'EPERM')
-            return false;
-    }
-    return holder.start === null || startOf(holder.pid) === holder.start;
-}
-/** Persist an identity before sending. Store neither credentials nor request/response bodies. */
-export function beginToolOperation(path, serializedBody, recoverId, options = {}) {
-    const directory = process.env.PLAYCRAFT_TOOL_REQUEST_DIR ?? join(homedir(), '.playcraft', 'tool-requests');
-    if (!isAbsolute(directory))
-        throw new Error('PLAYCRAFT_TOOL_REQUEST_DIR must be an absolute path');
-    mkdirSync(directory, { recursive: true, mode: 0o700 });
-    const inputHash = createHash('sha256').update(serializedBody).digest('hex');
-    // Rerunning the same command while its outcome is unknown continues that operation: the server
-    // answers the same identity with its receipt instead of running it again.
-    const unconfirmed = recoverId === undefined && !options.newRequest
-        ? findUnconfirmed(directory, path, inputHash)
-        : undefined;
-    const identifier = recoverId ?? unconfirmed?.requestId ?? randomUUID();
-    if (!isAgentToolRequestId(identifier))
-        throw new Error('Invalid PLAYCRAFT_TOOL_REQUEST_ID');
-    const requestId = identifier.toLowerCase();
-    const file = join(directory, `${requestId}.json`);
-    const now = new Date().toISOString();
-    const holder = { pid: process.pid, start: startOf(process.pid) };
-    const entry = {
-        version: 1,
-        requestId,
-        path,
-        inputHash,
-        state: 'unconfirmed',
-        holder,
-        createdAt: now,
-        updatedAt: now,
-    };
-    let createdNew = false;
-    try {
-        writeFileSync(file, JSON.stringify(entry), { flag: 'wx', mode: 0o600 });
-        createdNew = true;
-    }
-    catch (error) {
-        if (error.code !== 'EEXIST')
-            throw error;
-        const previous = JSON.parse(readFileSync(file, 'utf8'));
-        if (previous.version !== 1 ||
-            previous.requestId !== requestId ||
-            previous.path !== path ||
-            previous.inputHash !== inputHash)
-            throw new Error(`Tool request ${requestId} conflicts with its durable local record`);
-    }
-    const update = (change) => {
-        const current = JSON.parse(readFileSync(file, 'utf8'));
-        const temporary = `${file}.${randomUUID()}.tmp`;
-        writeFileSync(temporary, JSON.stringify({ ...current, ...change, updatedAt: new Date().toISOString() }), { flag: 'wx', mode: 0o600 });
-        renameSync(temporary, file);
-    };
-    // Only the sender holds an operation; a concurrent run of the same command gets its own.
-    inFlight.add(requestId);
-    if (unconfirmed || recoverId !== undefined)
-        update({ holder });
-    return {
-        requestId,
-        /** This call created the identity; a refusal cannot settle an older unknown operation. */
-        createdNew,
-        /** An explicit recovery, or a server that did not acknowledge the identity, reads only. */
-        settledOnly: recoverId !== undefined || unconfirmed?.receiptOnly === true,
-        file,
-        complete: () => update({ state: 'completed' }),
-        /** A definite refusal: the request was not carried out, so a rerun is a new operation. */
-        reject: () => update({ state: 'rejected' }),
-        /** The outcome stays unknown and a rerun may only read the receipt. */
-        requireReceipt: () => update({ receiptOnly: true }),
-        /** This call is done with the operation; a later run of the command may continue it. */
-        release: () => inFlight.delete(requestId),
-    };
-}
-function findUnconfirmed(directory, path, inputHash) {
-    let latest;
-    for (const name of readdirSync(directory)) {
-        if (!name.endsWith('.json'))
-            continue;
-        try {
-            const entry = JSON.parse(readFileSync(join(directory, name), 'utf8'));
-            if (entry.version === 1 &&
-                entry.state === 'unconfirmed' &&
-                entry.path === path &&
-                entry.inputHash === inputHash &&
-                isAgentToolRequestId(entry.requestId) &&
-                (!latest || entry.updatedAt > latest.updatedAt) &&
-                // Still being sent, here or by another live process: that run is not interrupted.
-                // Checked last, so only this command's candidates cost a process probe.
-                !inFlight.has(entry.requestId) &&
-                !holderAlive(entry.holder))
-                latest = entry;
-        }
-        catch {
-            // A torn or foreign file is not an operation of this command.
-        }
-    }
-    return latest;
-}