@playcraft/cli 0.1.40-beta → 0.1.41-prod

package/dist/video-replication/comparison.js

@@ -1,216 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { readdir } from 'node:fs/promises';
-import { join, resolve } from 'node:path';
-import { setTimeout as delay } from 'node:timers/promises';
-import { canonicalReplicaJson, evaluateReplicaComparison, replicaDefaultPolicy, replicaPolicySchema, replicaValidationResultSchema, validateReplicaComparisonContext, validateReplicaComparisonContent, videoComparisonRequestSchema, videoComparisonRunSchema, videoModelCatalogSchema, } from '@playcraft/common/agent-tools';
-import { ensureVideoEvidenceGitExcluded } from '../utils/video-evidence-git.js';
-import { requireVideoId, resolveVideoWorkspace, uploadVideo } from './client.js';
-import { VideoCliError, videoMessage } from './messages.js';
-import { comparisonMessage, ComparisonCliError } from './comparison-messages.js';
-import { comparisonSha256, readComparisonJson } from './comparison-files.js';
-import { preflightComparison } from './comparison-preflight.js';
-import { comparisonOutputPath, comparisonOutputRoot, writeComparisonJson } from './comparison-output.js';
-async function prepareComparisonOutput(out, runId, resume) {
-    if (!(await ensureVideoEvidenceGitExcluded(process.cwd())))
-        console.error(videoMessage('gitExcludeWarning'));
-    await comparisonOutputRoot(out, true);
-    await comparisonOutputPath(out, 'request.json');
-    const names = await readdir(out);
-    if (!names.length && !resume)
-        return;
-    try {
-        const saved = await readComparisonJson(join(out, 'request.json'));
-        if (resume && saved.schemaVersion === 'playcraft.video-comparison-local-request.v1' && saved.runId === runId && saved.out === out)
-            return;
-    }
-    catch { /* Preserve unrelated output directories. */ }
-    throw new VideoCliError('outputConflict', 64);
-}
-export async function readComparisonRun(client, runId, workspaceId, signal, cancel = false) {
-    const value = cancel ? await client.post(`/video-comparison/${runId}/cancel`, { workspaceId, runId }, { signal })
-        : await client.get(`/video-comparison/${runId}`, { workspaceId }, { signal });
-    let run;
-    try {
-        run = videoComparisonRunSchema.parse(value);
-    }
-    catch {
-        throw new ComparisonCliError('comparisonResult');
-    }
-    if (run.runId !== runId || run.workspaceId !== workspaceId || run.comparison && run.comparison.runId !== runId)
-        throw new ComparisonCliError('comparisonResult');
-    return run;
-}
-export function comparisonRunResult(command, run) {
-    const status = run.comparison?.status;
-    const exitCode = run.state === 'uncertain' ? 75 : ['failed', 'cancelled'].includes(run.state) ? 4
-        : status === 'fail' ? 2 : status === 'inconclusive' ? 3 : 0;
-    return { exitCode, envelope: { schemaVersion: 'playcraft.video-cli.v1', command, runId: run.runId, state: run.state,
-            ok: run.state === 'completed' && status === 'pass', result: run } };
-}
-export function validateComparisonResult(value, request, local) {
-    try {
-        const result = replicaValidationResultSchema.parse(value);
-        if (result.runId !== request.runId || result.model.configId !== request.modelConfigId || result.model.processing !== request.processing
-            || result.recordingHash !== comparisonSha256(canonicalReplicaJson(request.recording))
-            || result.policySha256 !== comparisonSha256(canonicalReplicaJson(request.policy))
-            || canonicalReplicaJson(result.policy) !== canonicalReplicaJson(request.policy))
-            throw new Error('identity');
-        const expectedInputs = local.inputs.map(item => ({ id: item.id, role: item.role, source: item.video.source }));
-        if (canonicalReplicaJson([...result.inputs].sort((a, b) => a.id.localeCompare(b.id))) !== canonicalReplicaJson([...expectedInputs].sort((a, b) => a.id.localeCompare(b.id))))
-            throw new Error('sources');
-        const context = { inputs: result.inputs, analysis: request.analysis, recording: request.recording, policy: request.policy, processing: request.processing, fps: request.fps };
-        const content = validateReplicaComparisonContent({ summary: result.summary, evidence: result.evidence, alignments: result.alignments,
-            dimensions: result.dimensions, findings: result.findings, controlChecks: result.controlChecks,
-            timings: result.timings, missingEvidence: result.missingEvidence }, context);
-        // Recompute acceptance, including all missing evidence reported by the service.
-        const computed = evaluateReplicaComparison(content, context);
-        if (result.status !== computed.status || result.ok !== computed.ok || result.scope !== request.policy.scope
-            || canonicalReplicaJson(result.coverage) !== canonicalReplicaJson(computed.coverage)
-            || canonicalReplicaJson(result.timingChecks) !== canonicalReplicaJson(computed.timingChecks))
-            throw new Error('decision');
-        return result;
-    }
-    catch {
-        throw new ComparisonCliError('comparisonResult');
-    }
-}
-async function recheckComparisonInputs(saved, deps, signal) {
-    const actual = await preflightComparison({ reference: saved.referencePath, analysis: saved.analysisPath, candidate: saved.candidatePath,
-        recording: saved.recordingPath, out: saved.out, signal, probe: deps.probe });
-    if (canonicalReplicaJson(actual.recording) !== canonicalReplicaJson(saved.local.recording)
-        || canonicalReplicaJson(actual.analysis) !== canonicalReplicaJson(saved.local.analysis)
-        || canonicalReplicaJson(actual.inputs.map(item => ({ id: item.id, role: item.role, source: item.video.source })))
-            !== canonicalReplicaJson(saved.local.inputs.map(item => ({ id: item.id, role: item.role, source: item.video.source }))))
-        throw new ComparisonCliError('invalidRecording', 64);
-    return actual;
-}
-export async function executeVideoComparison(options, signal, deps) {
-    let saved;
-    let runId;
-    let out;
-    let submitted = false;
-    try {
-        const workspaceId = await resolveVideoWorkspace(options.workspace);
-        if (options.resume && [options.reference, options.analysis, options.candidate, options.recording, options.policy, options.processing, options.fps, options.modelConfig].some(value => value !== undefined))
-            throw new ComparisonCliError('invalidComparison', 64);
-        if (!options.resume && (!options.reference || !options.analysis || !options.candidate || !options.recording))
-            throw new ComparisonCliError('invalidComparison', 64);
-        const processing = options.processing ?? 'static';
-        const fps = options.fps === undefined ? processing === 'static' ? 4 : undefined : Number(options.fps);
-        if (!['static', 'agentic'].includes(processing) || fps !== undefined && ![1, 2, 4, 8].includes(fps) || processing === 'agentic' && fps !== undefined)
-            throw new ComparisonCliError('invalidComparison', 64);
-        runId = options.resume ? requireVideoId(options.resume) : randomUUID();
-        out = resolve(options.out ?? join('.playcraft/video-replication', runId));
-        await prepareComparisonOutput(out, runId, !!options.resume);
-        let run;
-        if (options.resume) {
-            try {
-                saved = await readComparisonJson(join(out, 'request.json'), 8 * 1024 * 1024);
-                if (saved.schemaVersion !== 'playcraft.video-comparison-local-request.v1' || saved.runId !== runId || saved.workspaceId !== workspaceId || saved.out !== out || !saved.request)
-                    throw new Error('identity');
-                saved.request = videoComparisonRequestSchema.parse(saved.request);
-                if (saved.request.runId !== runId || saved.request.workspaceId !== workspaceId)
-                    throw new Error('request');
-            }
-            catch {
-                throw new ComparisonCliError('comparisonResume', 64);
-            }
-            submitted = true;
-            saved.local = await preflightComparison({ reference: saved.referencePath, analysis: saved.analysisPath, candidate: saved.candidatePath,
-                recording: saved.recordingPath, out, signal, probe: deps.probe });
-            if (canonicalReplicaJson(saved.local.recording) !== canonicalReplicaJson(saved.request.recording)
-                || canonicalReplicaJson(saved.local.analysis) !== canonicalReplicaJson(saved.request.analysis))
-                throw new ComparisonCliError('comparisonResume', 64);
-            // Recovery only reads the existing task. It cannot upload or submit another inference.
-            run = await readComparisonRun(deps.client, runId, workspaceId, signal);
-        }
-        else {
-            let policy;
-            try {
-                policy = options.policy ? replicaPolicySchema.parse(await readComparisonJson(resolve(options.policy))) : replicaDefaultPolicy;
-            }
-            catch {
-                throw new ComparisonCliError('invalidComparison', 64);
-            }
-            deps.progress('probing');
-            const local = await preflightComparison({ reference: options.reference, analysis: options.analysis, candidate: options.candidate,
-                recording: options.recording, out, signal, probe: deps.probe });
-            try {
-                validateReplicaComparisonContext({ inputs: local.inputs.map(item => ({ id: item.id, role: item.role, source: item.video.source })),
-                    analysis: local.analysis, recording: local.recording, policy, processing: processing, fps });
-            }
-            catch {
-                throw new ComparisonCliError('invalidComparison', 64);
-            }
-            const catalog = videoModelCatalogSchema.parse(await deps.client.get('/video-models', { workspaceId }, { signal }));
-            const configId = options.modelConfig ? requireVideoId(options.modelConfig) : catalog.defaultConfigId;
-            const model = catalog.models.find(item => item.configId === configId);
-            if (!model || !model.processing.includes(processing) || model.maxVideos < local.inputs.length)
-                throw new ComparisonCliError('comparisonUnavailable', 64);
-            saved = { schemaVersion: 'playcraft.video-comparison-local-request.v1', runId, workspaceId, out,
-                referencePath: resolve(options.reference), analysisPath: resolve(options.analysis), candidatePath: resolve(options.candidate), recordingPath: resolve(options.recording),
-                local, state: 'uploading', createdAt: new Date().toISOString() };
-            await writeComparisonJson(out, 'request.json', saved);
-            const inputs = [];
-            for (const input of local.inputs) {
-                deps.progress('uploading');
-                const mediaId = await uploadVideo(input.video, workspaceId, deps, signal);
-                inputs.push({ id: input.id, role: input.role, mediaId });
-            }
-            const request = videoComparisonRequestSchema.parse({ schemaVersion: 'playcraft.video-comparison-request.v1', workspaceId, runId,
-                inputs, analysis: local.analysis, recording: local.recording, policy, processing, ...(fps !== undefined && { fps }), modelConfigId: configId });
-            saved = { ...saved, request, state: 'submitting' };
-            await writeComparisonJson(out, 'request.json', saved);
-            await recheckComparisonInputs(saved, deps, signal);
-            deps.progress('submitting');
-            submitted = true;
-            const response = await deps.client.post('/video-comparison', request, { signal, onPrepared: async (operation) => {
-                    saved = { ...saved, requestId: operation.requestId };
-                    await writeComparisonJson(out, 'request.json', saved);
-                } });
-            try {
-                run = videoComparisonRunSchema.parse(response);
-            }
-            catch {
-                throw new ComparisonCliError('comparisonResult');
-            }
-            if (run.runId !== runId || run.workspaceId !== workspaceId)
-                throw new ComparisonCliError('comparisonResult');
-        }
-        while (['pending', 'uploading', 'submitting', 'running'].includes(run.state)) {
-            deps.progress('waiting');
-            await delay(Math.max(250, Math.min(run.pollAfterMs, 10_000)), undefined, { signal });
-            run = await readComparisonRun(deps.client, runId, workspaceId, signal);
-        }
-        await writeComparisonJson(out, 'task.json', run);
-        if (run.state === 'uncertain')
-            throw new VideoCliError('uncertain', 75);
-        if (run.state !== 'completed')
-            return comparisonRunResult('video compare', run);
-        if (!saved.request || !run.comparison)
-            throw new ComparisonCliError('comparisonResult');
-        await recheckComparisonInputs(saved, deps, signal);
-        const comparison = validateComparisonResult(run.comparison, saved.request, saved.local);
-        deps.progress('extracting');
-        const artifacts = await deps.materialize({ comparison, request: saved.request, inputs: saved.local.inputs, out, signal });
-        await writeComparisonJson(out, 'request.json', { ...saved, state: 'completed' });
-        const result = comparisonRunResult('video compare', { ...run, comparison });
-        result.envelope.artifacts = artifacts;
-        result.envelope.result = { status: comparison.status, scope: comparison.scope, coverage: comparison.coverage };
-        return result;
-    }
-    catch (error) {
-        const timeout = signal.aborted && signal.reason?.name === 'TimeoutError';
-        const interrupted = signal.aborted && !timeout;
-        const known = error instanceof VideoCliError || error instanceof ComparisonCliError;
-        const code = timeout ? 'timeoutReached' : interrupted ? 'interrupted' : known ? error.code : submitted ? 'uncertain' : 'comparisonFailed';
-        const exitCode = timeout ? 75 : interrupted ? 130 : known ? error.exitCode : submitted ? 75 : 4;
-        if (saved && out && submitted && (exitCode === 75 || exitCode === 130))
-            await writeComparisonJson(out, 'request.json', { ...saved, state: 'uncertain' }).catch(() => { });
-        const message = error instanceof ComparisonCliError ? comparisonMessage(error.code) : error instanceof VideoCliError ? videoMessage(error.code)
-            : timeout ? videoMessage('timeoutReached') : interrupted ? videoMessage('interrupted') : submitted ? videoMessage('uncertain') : comparisonMessage('comparisonFailed');
-        return { exitCode, envelope: { schemaVersion: 'playcraft.video-cli.v1', command: 'video compare', runId,
-                state: exitCode === 75 || exitCode === 130 ? 'uncertain' : 'failed', ok: false,
-                ...(saved && out && { artifacts: { request: join(out, 'request.json') } }), error: { code, message, ...(interrupted && { remoteCancellationConfirmed: false }) } } };
-    }
-}

package/dist/video-replication/evidence.js

@@ -1,165 +0,0 @@
-import { createHash } from 'node:crypto';
-import { readFile, readdir, writeFile } from 'node:fs/promises';
-import { basename, dirname, join, resolve } from 'node:path';
-import sharp from 'sharp';
-import { videoUnderstandingAnalysisSchema, validateVideoUnderstandingContent, } from '@playcraft/common/agent-tools';
-import { openVideo, runMediaTool, verifyVideo } from './media.js';
-import { VideoCliError, videoMessage } from './messages.js';
-import { ensureVideoEvidenceGitExcluded } from '../utils/video-evidence-git.js';
-import { comparisonOutputPath, comparisonOutputRoot, writeComparisonArtifact, writeComparisonJson } from './comparison-output.js';
-import { ComparisonCliError } from './comparison-messages.js';
-async function videoOutput(action) {
-    try {
-        return await action();
-    }
-    catch (error) {
-        if (error instanceof ComparisonCliError && error.code === 'unsafeOutput')
-            throw new VideoCliError('unsafeOutput', 64);
-        throw error;
-    }
-}
-export async function writeJsonAtomic(path, value) {
-    await videoOutput(async () => {
-        await comparisonOutputRoot(dirname(path), true);
-        await writeComparisonJson(dirname(path), basename(path), value);
-    });
-}
-export async function prepareArtifactDirectory(out, runId, resume) {
-    if (!(await ensureVideoEvidenceGitExcluded(process.cwd())))
-        console.error(videoMessage('gitExcludeWarning'));
-    await videoOutput(async () => {
-        await comparisonOutputRoot(out, true);
-        await comparisonOutputPath(out, 'request.json');
-    });
-    const names = await readdir(out);
-    if (!names.length && !resume)
-        return;
-    try {
-        const saved = JSON.parse(await readFile(join(out, 'request.json'), 'utf8'));
-        if (resume && saved.schemaVersion === 'playcraft.video-request.v1' && saved.runId === runId && saved.out === resolve(out))
-            return;
-    }
-    catch { /* An unrelated or incomplete output directory must not be overwritten. */ }
-    throw new VideoCliError('outputConflict', 64);
-}
-export async function loadSavedRequest(out, runId, workspaceId) {
-    try {
-        await videoOutput(() => comparisonOutputPath(out, 'request.json'));
-        const value = JSON.parse(await readFile(join(out, 'request.json'), 'utf8'));
-        if (value.schemaVersion !== 'playcraft.video-request.v1' || value.runId !== runId || value.workspaceId !== workspaceId || value.out !== resolve(out) || typeof value.videoPath !== 'string')
-            throw new Error('invalid');
-        return value;
-    }
-    catch {
-        throw new VideoCliError('resumeMissing', 64);
-    }
-}
-const escapeXml = (text) => text.replace(/[&<>"']/g, c => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&apos;' })[c]);
-const escapeMarkdown = (text) => text.replace(/([\\`*_[\]<>])/g, '\\$1');
-export function renderVideoAnalysis(analysis, frames) {
-    const lines = [`# ${videoMessage('summary')}`, '', escapeMarkdown(analysis.summary), '', videoMessage('transcriptNotice'), ''];
-    for (const [key, items] of [
-        ['observations', analysis.observations], ['inferences', analysis.inferences], ['unknowns', analysis.unknowns],
-    ]) {
-        lines.push(`## ${videoMessage(key)}`, '');
-        for (const item of items) {
-            const confidence = 'confidence' in item ? ` (${item.confidence})` : '';
-            lines.push(`- **${escapeMarkdown(item.id)}**${confidence}: ${escapeMarkdown(item.text)}`);
-        }
-        lines.push('');
-    }
-    lines.push(`## ${videoMessage('events')}`, '');
-    for (const event of analysis.events)
-        lines.push(`- ${escapeMarkdown(event.id)} [${event.startMs}–${event.endMs} ms]: ${event.kind}`);
-    lines.push('', `## ${videoMessage('hints')}`, '');
-    for (const [key, items] of Object.entries(analysis.reconstructionHints)) {
-        lines.push(`### ${videoMessage(key === 'candidateRules' ? 'rules' : key)}`, '');
-        for (const item of items)
-            lines.push(`- ${escapeMarkdown(item)}`);
-        lines.push('');
-    }
-    lines.push(`## ${videoMessage('evidence')}`, '');
-    for (const evidence of analysis.evidence)
-        lines.push(`- ${escapeMarkdown(evidence.id)} [${evidence.startMs}–${evidence.endMs} ms]: [frame](${frames.get(evidence.id)})`);
-    return `${lines.join('\n')}\n`;
-}
-/** Materialize only validated original-video timestamps; the model never supplies file paths. */
-export async function materializeVideoEvidence(input) {
-    let analysis;
-    try {
-        analysis = videoUnderstandingAnalysisSchema.parse(input.analysis);
-        validateVideoUnderstandingContent({
-            summary: analysis.summary, observations: analysis.observations, events: analysis.events,
-            evidence: analysis.evidence, inferences: analysis.inferences, unknowns: analysis.unknowns,
-            reconstructionHints: analysis.reconstructionHints,
-        }, analysis.source, input.request?.clip);
-    }
-    catch {
-        throw new VideoCliError('invalidResult');
-    }
-    // Refuse any redirected destination before replacing evidence from a previous attempt.
-    await videoOutput(async () => {
-        await comparisonOutputRoot(input.out, true);
-        for (const path of [...analysis.evidence.map(item => `keyframes/${item.id}.png`), 'analysis.json', 'analysis.md', 'manifest.json', 'contact-sheet.jpg'])
-            await comparisonOutputPath(input.out, path);
-    });
-    const file = await openVideo(input.sourcePath);
-    const frames = new Map();
-    const manifestFrames = [];
-    const tiles = [];
-    const width = 240;
-    const height = 200;
-    const columns = Math.min(4, analysis.evidence.length);
-    try {
-        await verifyVideo(file, analysis.source);
-        const frameOutput = await runMediaTool('ffprobe', [
-            '-v', 'error', '-protocol_whitelist', 'file,pipe', '-format_whitelist', 'mov,matroska,webm',
-            '-select_streams', 'v:0', '-show_entries', 'frame=best_effort_timestamp_time', '-of', 'csv=p=0', '/dev/fd/3',
-        ], file.fd, input.signal);
-        const rawFrameTimes = frameOutput.split('\n').map(line => Number.parseFloat(line) * 1000).filter(Number.isFinite);
-        const firstFrameTime = rawFrameTimes[0] ?? 0;
-        const frameTimes = rawFrameTimes.map(time => time - firstFrameTime).filter(time => time >= 0 && time < analysis.source.durationMs);
-        if (!frameTimes.length)
-            throw new VideoCliError('invalidResult');
-        for (const [index, evidence] of analysis.evidence.entries()) {
-            input.signal?.throwIfAborted();
-            const path = `keyframes/${evidence.id}.png`;
-            // Quantize the model's suggested midpoint to a real decoded frame, including the final frame.
-            const requestedTimeMs = (evidence.startMs + evidence.endMs) / 2;
-            const timeMs = frameTimes.reduce((best, candidate) => Math.abs(candidate - requestedTimeMs) < Math.abs(best - requestedTimeMs) ? candidate : best);
-            await videoOutput(() => writeComparisonArtifact(input.out, path, temporary => runMediaTool('ffmpeg', [
-                '-v', 'error', '-nostdin', '-y', '-protocol_whitelist', 'file,pipe', '-format_whitelist', 'mov,matroska,webm',
-                '-ss', (Math.max(0, timeMs - 0.01) / 1000).toFixed(6), '-i', '/dev/fd/3', '-map', '0:v:0',
-                '-frames:v', '1', '-vf', 'scale=min(1280\\,iw):-2', '-threads', '1', temporary,
-            ], file.fd, input.signal)));
-            const bytes = await readFile(join(input.out, path));
-            const metadata = await sharp(bytes).metadata();
-            if (!metadata.width || !metadata.height)
-                throw new VideoCliError('invalidResult');
-            frames.set(evidence.id, path);
-            manifestFrames.push({ evidenceId: evidence.id, timeMs, requestedTimeMs, path, sha256: createHash('sha256').update(bytes).digest('hex') });
-            const thumbnail = await sharp(bytes).resize(width, height - 30, { fit: 'contain', background: '#f4f4f4' }).png().toBuffer();
-            const label = Buffer.from(`<svg width="${width}" height="30"><rect width="100%" height="100%" fill="white"/><text x="8" y="20" font-size="12">${escapeXml(evidence.id)} ${(timeMs / 1000).toFixed(2)}s</text></svg>`);
-            const tile = await sharp({ create: { width, height, channels: 3, background: '#ffffff' } }).composite([{ input: thumbnail, top: 0, left: 0 }, { input: label, top: height - 30, left: 0 }]).png().toBuffer();
-            tiles.push({ input: tile, left: (index % columns) * width, top: Math.floor(index / columns) * height });
-        }
-        await verifyVideo(file, analysis.source);
-    }
-    finally {
-        await file.close();
-    }
-    const contactSheet = join(input.out, 'contact-sheet.jpg');
-    await videoOutput(() => writeComparisonArtifact(input.out, 'contact-sheet.jpg', temporary => sharp({ create: { width: columns * width, height: Math.ceil(tiles.length / columns) * height, channels: 3, background: '#dddddd' } }).composite(tiles).jpeg({ quality: 85 }).toFile(temporary)));
-    // Keep analysis.json compatible with the shared schema; local frame references live in the manifest.
-    const analysisPath = join(input.out, 'analysis.json');
-    const markdown = join(input.out, 'analysis.md');
-    await writeJsonAtomic(analysisPath, analysis);
-    await videoOutput(() => writeComparisonArtifact(input.out, 'analysis.md', temporary => writeFile(temporary, renderVideoAnalysis(analysis, frames), { mode: 0o600, flag: 'wx' })));
-    const manifest = join(input.out, 'manifest.json');
-    await writeJsonAtomic(manifest, {
-        schemaVersion: 'playcraft.video-evidence.v1', runId: analysis.runId, state: 'completed', source: analysis.source, model: analysis.model,
-        analysis: 'analysis.json', markdown: 'analysis.md', contactSheet: 'contact-sheet.jpg',
-        frames: manifestFrames, frameTimeSemantics: 'nearest-decoded-original-video-frame',
-    });
-    return { manifest, analysis: analysisPath, markdown, contactSheet, keyframes: manifestFrames.map(frame => join(input.out, frame.path)) };
-}

package/dist/video-replication/media.js

@@ -1,111 +0,0 @@
-import { spawn } from 'node:child_process';
-import { createHash } from 'node:crypto';
-import { open, realpath } from 'node:fs/promises';
-import { isAbsolute } from 'node:path';
-import { VIDEO_MAX_BYTES, videoSourceSchema, } from '@playcraft/common/agent-tools';
-import { VideoCliError } from './messages.js';
-/** No shell, external protocols, or unbounded child-process output. */
-export function runMediaTool(tool, args, inputFd, signal) {
-    return new Promise((resolve, reject) => {
-        const override = process.env[tool === 'ffmpeg' ? 'FFMPEG_PATH' : 'FFPROBE_PATH'];
-        if (override && !isAbsolute(override)) {
-            reject(new VideoCliError('mediaTool'));
-            return;
-        }
-        const child = spawn(override || tool, args, { stdio: ['ignore', 'pipe', 'pipe', inputFd], signal });
-        let output = '';
-        let settled = false;
-        const finish = (error) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            if (error)
-                reject(error);
-            else
-                resolve(output);
-        };
-        const timer = setTimeout(() => {
-            child.kill('SIGKILL');
-            finish(new VideoCliError('mediaTool'));
-        }, 30_000);
-        child.stdout.on('data', chunk => {
-            output += chunk.toString();
-            if (output.length > 1024 * 1024) {
-                child.kill('SIGKILL');
-                finish(new VideoCliError('videoFormat'));
-            }
-        });
-        child.stderr.on('data', () => { });
-        child.once('error', error => finish(error.name === 'AbortError' ? error : new VideoCliError('mediaTool')));
-        child.once('close', code => finish(code === 0 ? undefined : new VideoCliError('videoFormat')));
-    });
-}
-export async function openVideo(path) {
-    try {
-        const file = await open(path, 'r');
-        const stat = await file.stat();
-        if (!stat.isFile()) {
-            await file.close();
-            throw new VideoCliError('videoMissing', 64);
-        }
-        if (stat.size <= 0 || stat.size > VIDEO_MAX_BYTES) {
-            await file.close();
-            throw new VideoCliError('videoQuota', 64);
-        }
-        return file;
-    }
-    catch (error) {
-        if (error instanceof VideoCliError)
-            throw error;
-        throw new VideoCliError('videoMissing', 64);
-    }
-}
-async function digests(file) {
-    const sha = createHash('sha256');
-    const md5 = createHash('md5');
-    for await (const chunk of file.createReadStream({ autoClose: false, start: 0 })) {
-        sha.update(chunk);
-        md5.update(chunk);
-    }
-    return { sha256: sha.digest('hex'), contentMd5: md5.digest('base64') };
-}
-export async function probeVideo(path, signal) {
-    const absolute = await realpath(path).catch(() => { throw new VideoCliError('videoMissing', 64); });
-    const file = await openVideo(absolute);
-    try {
-        const stat = await file.stat();
-        const magic = Buffer.alloc(16);
-        await file.read(magic, 0, magic.length, 0);
-        const isIso = magic.subarray(4, 8).toString('ascii') === 'ftyp';
-        const isWebm = magic.readUInt32BE(0) === 0x1a45dfa3;
-        if (!isIso && !isWebm)
-            throw new VideoCliError('videoFormat', 64);
-        const output = await runMediaTool('ffprobe', [
-            '-v', 'error', '-protocol_whitelist', 'file,pipe', '-format_whitelist', 'mov,matroska,webm',
-            '-show_entries', 'format=duration,format_name:stream=codec_type,width,height,duration',
-            '-of', 'json', '/dev/fd/3',
-        ], file.fd, signal);
-        const result = JSON.parse(output);
-        const video = result.streams?.find(stream => stream.codec_type === 'video');
-        if (!video)
-            throw new VideoCliError('videoFormat', 64);
-        const durationMs = Number(result.format?.duration ?? video.duration) * 1000;
-        const hashes = await digests(file);
-        const parsed = videoSourceSchema.safeParse({
-            sha256: hashes.sha256, sizeBytes: stat.size, durationMs, width: video.width, height: video.height,
-            mimeType: isWebm ? 'video/webm' : magic.subarray(8, 12).toString('ascii') === 'qt  ' ? 'video/quicktime' : 'video/mp4',
-        });
-        if (!parsed.success)
-            throw new VideoCliError('videoQuota', 64);
-        return { path: absolute, source: parsed.data, contentMd5: hashes.contentMd5 };
-    }
-    finally {
-        await file.close();
-    }
-}
-export async function verifyVideo(file, expected) {
-    const stat = await file.stat();
-    if (stat.size !== expected.sizeBytes || (await digests(file)).sha256 !== expected.sha256)
-        throw new VideoCliError('sourceChanged', 64);
-}

package/dist/video-replication/messages.js

@@ -1,89 +0,0 @@
-const messages = {
-    en: {
-        topic: 'Video understanding and replica comparison with evidence frames',
-        models: 'List authorized video models and supported processing modes',
-        understand: 'Understand a local reference video using a managed video model',
-        jobs: 'Inspect or cancel an existing analysis without submitting new inference',
-        get: 'Read an existing video task state', cancel: 'Explicitly request remote cancellation',
-        workspace: 'Workspace UUID (defaults to the nearest workspace context file)',
-        json: 'Print machine-readable JSON (always enabled)', video: 'Local MP4, MOV or WebM file',
-        question: 'Focused question about the video', context: 'Prior analysis.json for this video',
-        processing: 'auto | agentic | static', fps: 'Static sampling: 1 | 2 | 4 | 8',
-        clip: 'Static clip in original video seconds: start:end',
-        model: 'Authorized model configuration UUID', out: 'Artifact directory',
-        timeout: 'Maximum local wait in seconds; the remote task remains recoverable',
-        resume: 'Resume this existing run UUID; cannot be combined with new inputs',
-        invalidArguments: 'Invalid video command arguments.',
-        workspaceMissing: 'Specify --workspace or run inside a Cloud Workspace checkout.',
-        workspaceMismatch: 'The explicit workspace does not match the checkout context.',
-        videoMissing: 'The video must be a readable regular file.',
-        videoQuota: 'The video exceeds 100 MiB or 180 seconds, or has unsupported dimensions.',
-        videoFormat: 'The file is not a supported MP4, MOV or WebM video.',
-        mediaTool: 'FFmpeg and ffprobe are required. Check the managed runtime installation.',
-        outputConflict: 'The artifact directory belongs to another run. Choose an empty directory.',
-        unsafeOutput: 'The artifact directory contains a linked or unsupported output path.',
-        gitExcludeWarning: 'The local Git ignore rule could not be updated. Video analysis will continue; do not commit .playcraft/video-replication evidence to the repository.',
-        invalidContext: 'The context is invalid or belongs to a different video.',
-        invalidResult: 'The video service returned invalid or incomplete evidence.',
-        sourceChanged: 'The video changed since it was probed or the task was created.',
-        uploadFailed: 'Video upload could not be completed.',
-        modelUnavailable: 'No authorized model supports the requested video processing mode.',
-        resumeMissing: 'The saved request is missing or does not match this run and workspace.',
-        timeoutReached: 'Local waiting ended. Resume this run to check its existing result.',
-        interrupted: 'Interrupted. Remote cancellation was not requested or confirmed.',
-        uncertain: 'The remote outcome is unknown. Check this run; do not submit another analysis.',
-        remoteFailed: 'The remote analysis failed or was cancelled.',
-        failed: 'Video understanding failed. Inspect the saved request and task before retrying.',
-        probing: 'Inspecting the video', uploading: 'Uploading the video',
-        submitting: 'Submitting the analysis', waiting: 'Waiting for the existing analysis',
-        extracting: 'Extracting evidence frames',
-        summary: 'Summary', observations: 'Observed facts', events: 'Events',
-        inferences: 'Inferences', unknowns: 'Unknowns', hints: 'Reconstruction suggestions',
-        evidence: 'Evidence', entities: 'Entities', assets: 'Assets', rules: 'Candidate rules',
-        transcriptNotice: 'Observed events cover only the demonstrated video. Inferred controls and hidden rules remain uncertain.',
-    },
-    zh: {
-        topic: '视频理解与复刻比较，抽取证据关键帧',
-        models: '列出有权使用的视频模型和处理模式',
-        understand: '使用受管视频模型理解本地参考视频',
-        jobs: '核对或取消已有任务，不新建推理', get: '读取已有视频任务状态', cancel: '明确请求远端取消',
-        workspace: '工作区编号，默认读取最近的工作区上下文文件',
-        json: '输出机器可读的 JSON（始终启用）', video: '本地 MP4、MOV 或 WebM 文件',
-        question: '需要确认的视频问题', context: '同一视频的已有 analysis.json',
-        processing: 'auto | agentic | static', fps: '静态抽样：1 | 2 | 4 | 8',
-        clip: '原视频上的静态片段秒数：开始:结束', model: '有权使用的模型配置编号', out: '制品输出目录',
-        timeout: '本地等待的最长秒数，远端任务仍可恢复', resume: '恢复已有任务编号，不能与新输入组合使用',
-        invalidArguments: '视频命令参数无效。', workspaceMissing: '请指定 --workspace，或在云端工作区目录内运行。',
-        workspaceMismatch: '指定的工作区与当前目录的工作区上下文不一致。',
-        videoMissing: '视频必须是可读的普通文件。', videoQuota: '视频超出 100 MiB、180 秒或支持的画面尺寸。',
-        videoFormat: '文件不是支持的 MP4、MOV 或 WebM 视频。', mediaTool: '需要 FFmpeg 和 ffprobe，请检查受管运行环境安装。',
-        outputConflict: '输出目录属于另一轮任务，请使用空目录。', invalidContext: '上下文无效，或属于另一份视频。',
-        unsafeOutput: '制品目录包含符号链接或不支持的输出路径。',
-        gitExcludeWarning: '无法更新 Git 本地忽略规则。视频分析将继续，请勿将 .playcraft/video-replication 证据提交到仓库。',
-        invalidResult: '视频服务返回的证据无效或不完整。', sourceChanged: '视频在探测后或任务创建后发生了变化。',
-        uploadFailed: '视频上传未完成。', modelUnavailable: '没有有权使用且支持所需视频模式的模型。',
-        resumeMissing: '找不到保存的请求，或请求与任务、工作区不一致。',
-        timeoutReached: '本地等待结束，请恢复此任务核对已有结果。',
-        interrupted: '操作已中断，尚未请求或确认远端取消。',
-        uncertain: '远端结果未知，请核对此任务，不要另建分析。', remoteFailed: '远端分析失败或已取消。',
-        failed: '视频理解失败，请先核对已保存的请求和任务再重试。',
-        probing: '正在探测视频', uploading: '正在上传视频', submitting: '正在提交分析',
-        waiting: '正在等待已有分析', extracting: '正在抽取证据关键帧',
-        summary: '概述', observations: '观察事实', events: '事件', inferences: '推断', unknowns: '未知项',
-        hints: '复刻建议', evidence: '证据', entities: '实体', assets: '素材', rules: '候选规则',
-        transcriptNotice: '观察事件仅覆盖视频展示的路径；操作方式和隐藏规则的推断仍需确认。',
-    },
-};
-export function videoMessage(key) {
-    const locale = process.env.PLAYCRAFT_LANGUAGE || process.env.LANG || 'en';
-    return messages[locale.startsWith('zh') ? 'zh' : 'en'][key];
-}
-export class VideoCliError extends Error {
-    code;
-    exitCode;
-    constructor(code, exitCode = 4) {
-        super(videoMessage(code));
-        this.code = code;
-        this.exitCode = exitCode;
-    }
-}

package/dist/workspace/messages.js

@@ -1,35 +0,0 @@
-const messages = {
-    en: {
-        description: 'Download cloud workspaces and push local commits back',
-        clone: 'Clone the current workspace files, including uncommitted changes',
-        push: 'Push local commits back; reject concurrent cloud changes',
-        workspaceId: 'Cloud workspace identifier', directory: 'Engineering directory, or root for the whole workspace',
-        target: 'Local checkout directory', url: 'PlayCraft service base address, including any environment prefix',
-        token: 'Personal access token', json: 'Print structured output',
-        invalidTarget: 'Invalid workspace identifier, directory, or service address.',
-        directoryExists: 'The target directory already exists. Choose an empty new directory.',
-        metadataMissing: 'No workspace checkout metadata found. Run workspace clone first.',
-        cleanRequired: 'Commit or discard local changes before running workspace push.',
-        notReady: 'Workspace access is not ready. Open the workspace and retry.',
-        conflict: 'Cloud files changed since this checkout. Clone again and merge your changes before pushing.',
-        failed: 'Workspace transfer failed', cloned: 'Workspace cloned:', pushed: 'Local commits pushed to the cloud workspace.',
-        tooLarge: 'Workspace transfer exceeds the 256 MiB (Mebibyte, binary megabyte) or 20,000 file limit. Use direct download for larger workspaces.',
-        login: 'Log in to the target environment using playcraft login --url',
-    },
-    zh: {
-        description: '下载云工作区，并将本地提交推送回来', clone: '克隆当前工作区文件，包含尚未提交的修改',
-        push: '把本地提交推送回来；云端有新修改时拒绝覆盖', workspaceId: '云工作区标识',
-        directory: '工程目录；root 表示整个工作区', target: '本地克隆目录',
-        url: 'PlayCraft 服务基址，保留环境路径前缀', token: '个人访问令牌', json: '输出结构化结果',
-        invalidTarget: '工作区标识、目录或服务地址无效。', directoryExists: '目标目录已存在，请选择新的目录。',
-        metadataMissing: '未找到工作区克隆信息，请先运行 workspace clone。', cleanRequired: '请先提交或丢弃本地修改，再运行 workspace push。',
-        notReady: '工作区访问尚未就绪，请打开工作区后重试。', conflict: '云端文件在克隆后发生变化，请重新克隆并合并本地修改后再推送。',
-        failed: '工作区传输失败', cloned: '工作区已克隆到：', pushed: '本地提交已推送回云工作区。',
-        tooLarge: '工作区传输超过 256 MiB（Mebibyte，二进制兆字节）或 20,000 个文件的限制。较大的工作区请使用直接下载。',
-        login: '请使用 playcraft login --url 登录目标环境',
-    },
-};
-export function workspaceMessage(key) {
-    const locale = process.env.PLAYCRAFT_LANGUAGE || process.env.LANG || 'en';
-    return messages[locale.startsWith('zh') ? 'zh' : 'en'][key];
-}