@playcraft/cli 0.1.33 → 0.1.35-prod

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

package/dist/workspace/transfer-client.js

@@ -1,174 +0,0 @@
-import { randomUUID } from 'node:crypto';
-import { existsSync } from 'node:fs';
-import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { RESOURCE_GRANT_ACTIONS, workspaceSessionScopeSchema } from '@playcraft/common/cloud-workspace/runtime';
-import { PlayCraftHttpClient } from '../utils/playcraft-http-client.js';
-import { transferGit, WORKSPACE_TRANSFER_MAX_BYTES } from '../workspace-runtime/workspaces/transfer.js';
-import { workspaceMessage as message } from './messages.js';
-const META_FILE = '.playcraft-workspace.json';
-export function workspaceServiceUrl(baseUrl, path) {
-    const base = new URL(baseUrl);
-    if (!['http:', 'https:'].includes(base.protocol) || base.username || base.password || base.search || base.hash)
-        throw new Error(message('invalidTarget'));
-    return `${base.toString().replace(/\/+$/, '')}/${path.replace(/^\/+/, '')}`;
-}
-async function request(client, path, init = {}) {
-    const headers = new Headers(init.headers);
-    headers.set('Authorization', `Bearer ${client.token}`);
-    headers.set('X-Request-Id', client.requestId);
-    const response = await fetch(workspaceServiceUrl(client.baseUrl, path), {
-        ...init, headers, redirect: 'error', signal: AbortSignal.timeout(180_000),
-    });
-    if (response.ok)
-        return response;
-    const body = await response.json().catch(() => ({}));
-    const value = body && typeof body === 'object' ? body : {};
-    const code = String(value.reason ?? value.code ?? value.message ?? value.error ?? response.status);
-    if (code.includes('workspace_transfer_conflict'))
-        throw new Error(message('conflict'));
-    if (code.includes('workspace_transfer_too_large'))
-        throw new Error(message('tooLarge'));
-    if (response.status === 401)
-        throw new Error(`${message('login')} ${client.baseUrl}`);
-    throw new Error(`${message('failed')}: ${code}`);
-}
-async function json(client, path, body) {
-    const response = await request(client, path, body === undefined ? {} : {
-        method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body),
-    });
-    const value = await response.json();
-    return (value?.result ?? value);
-}
-async function ensureAccess(client, workspaceId, directoryName) {
-    const workspace = await json(client, `/api/cloud-workspaces/${workspaceId}`);
-    const scope = workspace.projectId
-        ? `/api/projects/${encodeURIComponent(workspace.projectId)}/cloud-workspaces/${workspaceId}`
-        : `/api/cloud-workspaces/${workspaceId}`;
-    let grant = await json(client, `${scope}/runtime-grants`, {
-        clientRequestId: `workspace-cli-${randomUUID()}`, actions: RESOURCE_GRANT_ACTIONS,
-    });
-    for (let attempt = 0; grant.grantStatus === 'pending' && grant.grantRequestId && attempt < 60; attempt++) {
-        await new Promise(resolve => setTimeout(resolve, 500));
-        grant = await json(client, `${scope}/runtime-grants/${encodeURIComponent(grant.grantRequestId)}`);
-    }
-    if (grant.grantStatus !== 'ready')
-        throw new Error(message('notReady'));
-    let operation = await json(client, `/runtime/workspaces/${workspaceId}/ensure`, { clientRequestId: randomUUID(), directoryName: directoryName === 'root' ? 'basic' : directoryName });
-    for (let attempt = 0; operation.operationId && ['queued', 'dispatched', 'accepted'].includes(operation.status ?? '') && attempt < 60; attempt++) {
-        await new Promise(resolve => setTimeout(resolve, 500));
-        operation = await json(client, `/runtime/operations/${encodeURIComponent(operation.operationId)}`);
-    }
-    if (operation.status !== 'completed')
-        throw new Error(message('notReady'));
-}
-async function readBounded(response) {
-    const chunks = [];
-    let length = 0;
-    if (!response.body)
-        throw new Error(message('failed'));
-    const reader = response.body.getReader();
-    try {
-        while (true) {
-            const next = await reader.read();
-            if (next.done)
-                break;
-            length += next.value.byteLength;
-            if (length > WORKSPACE_TRANSFER_MAX_BYTES)
-                throw new Error(message('tooLarge'));
-            chunks.push(next.value);
-        }
-    }
-    finally {
-        await reader.cancel();
-    }
-    return Buffer.concat(chunks);
-}
-export async function workspaceClone(options) {
-    const workspaceId = options.workspaceId.trim(), directoryName = options.directory ?? 'basic';
-    if (!/^[a-f0-9-]{36}$/i.test(workspaceId) || !workspaceSessionScopeSchema.safeParse(directoryName).success)
-        throw new Error(message('invalidTarget'));
-    const target = resolve(options.dir?.trim() || `workspace-${workspaceId}-${directoryName}`);
-    if (existsSync(target))
-        throw new Error(message('directoryExists'));
-    const client = new PlayCraftHttpClient(options);
-    await ensureAccess(client, workspaceId, directoryName);
-    const temporary = await mkdtemp(join(tmpdir(), 'playcraft-clone-'));
-    let created = false;
-    try {
-        const response = await request(client, `/runtime/workspaces/${workspaceId}/git-bundle?directoryName=${encodeURIComponent(directoryName)}`);
-        const tree = response.headers.get('x-playcraft-workspace-tree');
-        if (!tree || !/^[a-f0-9]{40,64}$/.test(tree))
-            throw new Error(message('failed'));
-        const bundlePath = join(temporary, 'workspace.bundle');
-        await writeFile(bundlePath, await readBounded(response), { mode: 0o600 });
-        await mkdir(target);
-        created = true;
-        transferGit(temporary, ['clone', '--', bundlePath, target]);
-        if (transferGit(target, ['rev-parse', 'HEAD^{tree}']) !== tree)
-            throw new Error(message('failed'));
-        transferGit(target, ['config', '--unset-all', 'remote.origin.url']);
-        const meta = { schemaVersion: 'playcraft.workspace-checkout.v1', workspaceId, directoryName,
-            baseUrl: client.baseUrl, tree };
-        await writeFile(join(target, META_FILE), `${JSON.stringify(meta, null, 2)}\n`);
-        const excludePath = join(target, '.git', 'info', 'exclude');
-        const exclude = await readFile(excludePath, 'utf8').catch(() => '');
-        await writeFile(excludePath, `${exclude}\n/${META_FILE}\n`);
-        if (options.json)
-            console.log(JSON.stringify({ ok: true, command: 'workspace.clone', data: { ...meta, dir: target } }));
-        else
-            console.log(`${message('cloned')} ${target}`);
-    }
-    catch (error) {
-        if (created)
-            await rm(target, { recursive: true, force: true });
-        throw error;
-    }
-    finally {
-        await rm(temporary, { recursive: true, force: true });
-    }
-}
-export async function workspacePush(options = {}) {
-    const root = resolve(options.dir?.trim() || process.cwd());
-    let meta;
-    try {
-        meta = JSON.parse(await readFile(join(root, META_FILE), 'utf8'));
-        if (meta.schemaVersion !== 'playcraft.workspace-checkout.v1' || !/^[a-f0-9-]{36}$/i.test(meta.workspaceId) ||
-            !workspaceSessionScopeSchema.safeParse(meta.directoryName).success || !/^[a-f0-9]{40,64}$/.test(meta.tree))
-            throw new Error();
-        workspaceServiceUrl(meta.baseUrl, '/');
-    }
-    catch {
-        throw new Error(message('metadataMissing'));
-    }
-    if (transferGit(root, ['status', '--porcelain']).length > 0)
-        throw new Error(message('cleanRequired'));
-    const client = new PlayCraftHttpClient({ url: options.url || meta.baseUrl, token: options.token });
-    if (workspaceServiceUrl(client.baseUrl, '/') !== workspaceServiceUrl(meta.baseUrl, '/'))
-        throw new Error(message('invalidTarget'));
-    await ensureAccess(client, meta.workspaceId, meta.directoryName);
-    const temporary = await mkdtemp(join(tmpdir(), 'playcraft-push-'));
-    try {
-        const bundlePath = join(temporary, 'workspace.bundle');
-        transferGit(root, ['bundle', 'create', bundlePath, 'HEAD']);
-        const bundle = await readFile(bundlePath);
-        if (bundle.byteLength > WORKSPACE_TRANSFER_MAX_BYTES)
-            throw new Error(message('tooLarge'));
-        const response = await request(client, `/runtime/workspaces/${meta.workspaceId}/git-bundle?directoryName=${encodeURIComponent(meta.directoryName)}`, {
-            method: 'POST', headers: { 'content-type': 'application/octet-stream', 'x-playcraft-workspace-tree': meta.tree }, body: bundle,
-        });
-        const result = await response.json();
-        if (!/^[a-f0-9]{40,64}$/.test(result.tree))
-            throw new Error(message('failed'));
-        meta.tree = result.tree;
-        await writeFile(join(root, META_FILE), `${JSON.stringify(meta, null, 2)}\n`);
-        if (options.json)
-            console.log(JSON.stringify({ ok: true, command: 'workspace.push', data: result }));
-        else
-            console.log(message('pushed'));
-    }
-    finally {
-        await rm(temporary, { recursive: true, force: true });
-    }
-}