@playcraft/cli 0.1.41-prod → 0.1.43-beta

package/dist/commands/tools-batch.js

@@ -0,0 +1,87 @@
+import { readFile } from 'node:fs/promises';
+import { batchCreateSchema, batchPromptCreateSchema } from '@playcraft/common/cloud-workspace/runtime';
+import { AgentApiClient } from '../utils/agent-api-client.js';
+import { handleError } from './tools-utils.js';
+const messages = {
+    en: {
+        create: 'Create and automatically run independent Remix variants from one prompt',
+        input: 'Path to the batch draft JSON (JavaScript Object Notation, 数据交换格式) file',
+        status: 'Read a batch and its generation status',
+        id: 'Batch identifier',
+        created: 'Batch created',
+        prompt: 'The complete batch generation request', workspace: 'Source workspace identifier',
+        directory: 'Source engineering directory; defaults to basic', request: 'Stable batch creation identity for retries',
+        team: 'Team identifier for a standalone workspace', invalidMode: 'Provide either --prompt with --workspace-id or --input, exclusively.',
+        requestRequired: 'Prompt creation requires a stable --client-request-id; reuse it when retrying the same request.',
+        help: '\nUse --prompt with --workspace-id and a stable --client-request-id. The platform plans and generates independent Remix directories while preserving the source. An omitted count defaults to 3; maximum 10. --input also accepts existing structured drafts.\n',
+        confirmation: 'Generation is queued. Read the batch status to track its results.',
+        review: 'This existing draft requires baseline approval in the browser.',
+    },
+    zh: {
+        create: '用一个 prompt 创建并自动生成独立 Remix 变体',
+        input: '批次草案 JSON (JavaScript Object Notation, 数据交换格式) 文件路径',
+        status: '查询批次及生成状态',
+        id: '批次标识',
+        created: '批次已创建',
+        prompt: '完整的批量生成需求', workspace: '来源 workspace 标识',
+        directory: '来源工程目录，默认 basic', request: '用于重试的稳定批次创建标识',
+        team: '独立工作区所属团队标识', invalidMode: '请选择 --prompt 配合 --workspace-id，或 --input，两种方式不能同时使用。',
+        requestRequired: '使用 prompt 创建时必须提供稳定的 --client-request-id，重试同一请求时复用该标识。',
+        help: '\n使用 --prompt、--workspace-id 和稳定的 --client-request-id。平台自动规划，在副本中生成独立 Remix，保持来源不变。未指定数量默认 3 个，最多 10 个。--input 也兼容现有结构化草案。\n',
+        confirmation: '生成已排队，可查询批次状态追踪各项成果。',
+        review: '此历史草案需要在浏览器确认基准。',
+    },
+};
+const language = () => /^zh/i.test(process.env.PLAYCRAFT_LANG ?? process.env.LANG ?? '') ? messages.zh : messages.en;
+export async function createBatchDraft(path, client = new AgentApiClient()) {
+    const draft = batchCreateSchema.parse(JSON.parse(await readFile(path, 'utf8')));
+    return client.post('/create-batch', draft);
+}
+export async function createPromptBatch(input, client = new AgentApiClient()) {
+    return client.post('/create-batch', batchPromptCreateSchema.parse(input));
+}
+export function registerBatchCommands(tools) {
+    const t = language();
+    tools.command('create-batch')
+        .description(t.create)
+        .option('--input <path>', t.input)
+        .option('--prompt <text>', t.prompt)
+        .option('--workspace-id <id>', t.workspace)
+        .option('--source-directory <name>', t.directory, 'basic')
+        .option('--client-request-id <id>', t.request)
+        .option('--team-id <id>', t.team)
+        .option('--json', 'JSON (JavaScript Object Notation, 数据交换格式)')
+        .addHelpText('after', t.help)
+        .action(async (opts) => {
+        try {
+            if (Boolean(opts.input) === Boolean(opts.prompt))
+                throw new Error(t.invalidMode);
+            if (opts.prompt && !opts.workspaceId)
+                throw new Error(t.invalidMode);
+            if (opts.prompt && !opts.clientRequestId)
+                throw new Error(t.requestRequired);
+            const result = opts.input ? await createBatchDraft(opts.input) : await createPromptBatch({
+                clientRequestId: opts.clientRequestId, prompt: opts.prompt,
+                sourceWorkspaceId: opts.workspaceId, sourceDirectoryName: opts.sourceDirectory,
+                ...(opts.teamId ? { teamId: opts.teamId } : {}),
+            });
+            console.log(opts.json ? JSON.stringify(result, null, 2) : `${t.created}: ${result.batchId}\n${result.manifest.autoStart ? t.confirmation : t.review}`);
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    tools.command('get-batch')
+        .description(t.status)
+        .requiredOption('--batch-id <id>', t.id)
+        .action(async (opts) => {
+        try {
+            const client = new AgentApiClient();
+            const result = await client.get('/get-batch', { batchId: opts.batchId });
+            console.log(JSON.stringify(result, null, 2));
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+}

package/dist/commands/tools-generation.js

@@ -1,11 +1,9 @@
-import { Option } from 'commander';
 import { writeFileSync, mkdirSync } from 'fs';
 import { dirname, parse, join } from 'path';
 import sharp from 'sharp';
-import { resolveImageBackgroundRequirement, validateImageDeliveryOptions } from '@playcraft/common/prefab';
-import { assertImageAssetOutputPaths, readImageAssetContext } from '../utils/image-asset-context.js';
+import { captureGeneratedArtifact } from '../workspace-runtime/workspaces/artifact-receipts.js';
 import { AgentApiClient } from '../utils/agent-api-client.js';
-import { MAX_REFERENCE_IMAGES, collectReferenceImagePaths, parseImageTargetFieldPath, collectReferenceImagePayloads, sniffImageExtension, extensionForImageMime, resolveImageOutputPath, handleError, raceWithTimeout, } from './tools-utils.js';
+import { MAX_REFERENCE_IMAGES, collectReferenceImagePaths, collectReferenceImagePayloads, sniffImageExtension, extensionForImageMime, resolveImageOutputPath, handleError, raceWithTimeout, } from './tools-utils.js';
 function isMasterCompositeStripRequest(opts) {
     if (opts.aspectRatio === '45:16')
         return true;
@@ -153,140 +151,86 @@ export function registerGenerationCommands(tools) {
         .requiredOption('--prompt <text>', '图片描述')
         .option('--aspect-ratio <ratio>', '宽高比 (1:1|45:16|16:9|9:16|3:4|4:3|2:3|3:2|21:9)', '1:1')
         .requiredOption('--output <path>', '保存路径（--count>1 时自动追加 _1/_2 等后缀）')
-        .option('--target-asset <path>', 'Existing asset to replace; read its schema references and delivery constraints')
-        .option('--target-field-path <path>', 'Target image field as an array of keys, e.g. ["endUI","playButton"]', parseImageTargetFieldPath)
-        .option('--no-target-reference', 'Generate without the existing asset reference only when explicitly requested')
-        .option('--output-format <format>', 'Final format: png, webp or jpeg')
-        .option('--fit-mode <mode>', 'Canvas fitting: contain, cover or fill')
-        .option('--padding-color <color>', 'Canvas padding color (transparent by default)')
-        .addOption(new Option('--background <mode>', 'Agent background decision from conversation context').choices(['transparent', 'opaque']))
-        .option('--remove-background', 'Require a verified transparent image')
-        .option('--no-remove-background', 'Keep the generated background')
         .option('--image-size <size>', '图片尺寸 (1K|2K|4K)')
         .option('--width <n>', '精确宽度（像素；MC 横排 5×9:16 推荐 3600 或 4096）', (v) => parseInt(v, 10))
         .option('--height <n>', '精确高度（像素；MC 推荐 1280 或 1455）', (v) => parseInt(v, 10))
         .option('--reference-image <path>', '参考图路径（可重复多次，最多 8 张），支持 PNG/JPG/WEBP', collectReferenceImagePaths, [])
         .option('--image-model <model>', '模型名（如 gpt-image-2）或 provider/model（如 mulerouter/gpt-image-2）。传模型名时后端按优先级自动 fallback；传 provider/model 则直连指定 provider')
-        .option('--retry <n>', '额外重试轮数（默认 0；后端统一限制尝试，透明验证失败和超时不重试）', (v) => parseInt(v, 10), 0)
+        .option('--retry <n>', '全部 provider 都失败时的重试轮数（默认 1；超时不计为可重试错误）', (v) => parseInt(v, 10), 1)
         .option('--timeout <seconds>', '请求超时秒数（默认 1800，即 30 分钟；异步生图模型耗时较长，仅在后端明确报错时提前终止）', (v) => parseInt(v, 10), 1800)
         .option('--count <n>', '一次 API 调用生成多少张图片（默认 1，最多 10；仅 gpt-image-2 实际支持批量）', (v) => parseInt(v, 10), 1)
         .action(async (opts) => {
-        try {
-            const explicitBackground = opts.background === undefined ? opts.removeBackground : opts.background === 'transparent';
-            if (opts.background !== undefined && opts.removeBackground !== undefined && opts.removeBackground !== explicitBackground) {
-                throw new Error('Conflicting background options. Use --background transparent or --background opaque; no image request was sent.');
-            }
-            opts = { ...opts, removeBackground: explicitBackground };
-            if (opts.targetFieldPath && !opts.targetAsset) {
-                throw new Error('--target-field-path requires --target-asset; no image request was sent.');
+        const paths = opts.referenceImage ?? [];
+        if (paths.length > MAX_REFERENCE_IMAGES) {
+            console.error(`Error: Too many reference images: ${paths.length} paths given; maximum is ${MAX_REFERENCE_IMAGES}.`);
+            process.exit(1);
+            return;
+        }
+        const hasReferenceImages = paths.length > 0;
+        const attemptGenerate = async (modelRef, attempt) => {
+            const label = modelRef ? `[${modelRef}]` : '[default model]';
+            if (attempt > 0) {
+                console.log(`Retry ${attempt}/${opts.retry} ${label}...`);
             }
-            const explicitOutputFormat = opts.outputFormat;
-            const { dir: outputDir, name: outputName, ext: outputExt } = parse(opts.output);
-            const outputCandidates = [opts.output, ...Array.from({ length: opts.count > 1 ? Math.min(opts.count, 10) : 0 }, (_, i) => join(outputDir, `${outputName}_${i + 1}${outputExt}`))];
-            const assetContext = opts.targetAsset ? await readImageAssetContext(opts.targetAsset, process.cwd(), {
-                referenceImagePaths: opts.referenceImage, useTargetReference: opts.targetReference,
-                ...(opts.targetFieldPath ? { targetFieldPath: opts.targetFieldPath } : {}),
-                outputPaths: outputCandidates,
-                prompt: opts.prompt, removeBackground: opts.removeBackground,
-            }) : undefined;
-            opts = { ...opts,
-                aspectRatio: assetContext?.aspectRatio ?? opts.aspectRatio,
-                width: assetContext?.width ?? opts.width, height: assetContext?.height ?? opts.height,
-                outputFormat: assetContext?.outputFormatFromSchema ? assetContext.outputFormat : opts.outputFormat ?? assetContext?.outputFormat,
-                fitMode: assetContext?.fitMode ?? opts.fitMode,
-                removeBackground: resolveImageBackgroundRequirement({ prompt: opts.prompt,
-                    schemaRemoveBackground: assetContext?.removeBackgroundFromSchema ? assetContext.removeBackground : undefined,
-                    removeBackground: opts.removeBackground, fallbackRemoveBackground: assetContext?.removeBackground }),
-                paddingColor: assetContext?.paddingColor ?? opts.paddingColor,
-                imageModel: opts.imageModel || assetContext?.imageModelRef,
-            };
-            const invalidDelivery = validateImageDeliveryOptions(opts);
-            if (invalidDelivery)
-                throw new Error(invalidDelivery);
-            const paths = opts.referenceImage?.length ? opts.referenceImage : assetContext?.referenceImagePaths ?? [];
-            if (paths.length > MAX_REFERENCE_IMAGES) {
-                console.error(`Error: Too many reference images: ${paths.length} paths given; maximum is ${MAX_REFERENCE_IMAGES}.`);
-                process.exit(1);
-                return;
+            else {
+                console.log(`Generating image ${label}...`);
             }
-            const hasReferenceImages = paths.length > 0;
-            const attemptGenerate = async (modelRef, attempt) => {
-                const label = modelRef ? `[${modelRef}]` : '[default model]';
-                if (attempt > 0) {
-                    console.log(`Retry ${attempt}/${opts.retry} ${label}...`);
-                }
-                else {
-                    console.log(`Generating image ${label}...`);
-                }
-                const referenceImages = await collectReferenceImagePayloads(paths);
-                const client = new AgentApiClient();
-                const imageCount = Math.min(Math.max(1, opts.count ?? 1), 10);
-                const requestPromise = client.post('/generate-image', {
-                    prompt: opts.prompt,
-                    aspectRatio: assetContext?.aspectRatio ?? opts.aspectRatio,
-                    imageSize: opts.imageSize,
-                    width: assetContext?.width ?? opts.width,
-                    height: assetContext?.height ?? opts.height,
-                    outputFormat: opts.outputFormat,
-                    outputFormatSource: assetContext?.outputFormatFromSchema ? 'schema'
-                        : explicitOutputFormat ? 'explicit' : assetContext ? 'inferred' : undefined,
-                    fitMode: assetContext?.fitMode ?? opts.fitMode,
-                    paddingColor: assetContext?.paddingColor ?? opts.paddingColor,
-                    background: opts.background === undefined ? undefined : opts.removeBackground ? 'transparent' : 'opaque',
-                    removeBackground: opts.removeBackground,
-                    backgroundRequirementSource: assetContext?.removeBackgroundFromSchema ? 'schema'
-                        : explicitBackground !== undefined ? 'explicit' : 'inferred',
-                    referenceImages,
-                    ...(modelRef ? { imageModelRef: modelRef } : {}),
-                    ...(imageCount > 1 ? { imageCount } : {}),
-                });
-                return raceWithTimeout(requestPromise, opts.timeout * 1000, `Request timed out after ${opts.timeout}s. The backend task may still be running — check admin panel before re-running.`);
-            };
-            const enrichError = (err, modelRef) => {
-                const msg = err instanceof Error ? err.message : String(err);
-                const lines = [`Error: ${msg}`];
-                if (/source_transparency_invalid|output_transparency_invalid|transparency_unsupported/.test(msg)) {
-                    lines.push('Hint: Transparent output was not delivered. Preserve the requested transparency, references and model; use the request id and stage to investigate.');
-                }
-                else if (/API 500\b|Internal server error/.test(msg)) {
-                    lines.push('');
-                    lines.push('Hint: API 500 error — the model may be temporarily unavailable.');
-                    lines.push('  → Inspect the request id and backend diagnostics before another generation attempt.');
-                    if (modelRef?.includes('/') && opts.removeBackground !== true) {
-                        lines.push('  → Or try without provider prefix to auto-fallback providers: --image-model gpt-image-2');
-                    }
-                }
-                else if (msg.includes('timed out')) {
-                    lines.push('');
-                    lines.push('Hint: Request timed out. The backend task may still be running — retries were skipped to avoid creating duplicate tasks.');
-                    lines.push('  → Check the backend/admin panel for task status before re-running');
-                    lines.push('  → Try --image-size 1K to reduce generation time');
-                    lines.push('  → Or increase timeout with --timeout <seconds> (current default: 1800s)');
-                }
-                else if (hasReferenceImages && (msg.includes('reference') || msg.includes('image input'))) {
-                    lines.push('');
-                    lines.push('Hint: Reference image error — the selected model may not support --reference-image.');
-                    lines.push('  → Run: playcraft tools list-image-models');
-                    lines.push('  → Models with CAPABILITY=text+image support --reference-image');
+            const referenceImages = await collectReferenceImagePayloads(paths);
+            const client = new AgentApiClient();
+            const imageCount = Math.min(Math.max(1, opts.count ?? 1), 10);
+            const requestPromise = client.post('/generate-image', {
+                prompt: opts.prompt,
+                aspectRatio: opts.aspectRatio,
+                imageSize: opts.imageSize,
+                ...(opts.width && opts.height ? { width: opts.width, height: opts.height } : {}),
+                referenceImages,
+                ...(modelRef ? { imageModelRef: modelRef } : {}),
+                ...(imageCount > 1 ? { imageCount } : {}),
+            });
+            return raceWithTimeout(requestPromise, opts.timeout * 1000, `Request timed out after ${opts.timeout}s. The backend task may still be running — check admin panel before re-running.`);
+        };
+        const enrichError = (err, modelRef) => {
+            const msg = err instanceof Error ? err.message : String(err);
+            const lines = [`Error: ${msg}`];
+            if (msg.includes('500') || msg.includes('Internal server error')) {
+                lines.push('');
+                lines.push('Hint: API 500 error — the model may be temporarily unavailable.');
+                lines.push('  → If using a bare model name (e.g. gpt-image-2), all providers failed — try a different model');
+                if (modelRef?.includes('/')) {
+                    lines.push('  → Or try without provider prefix to auto-fallback providers: --image-model gpt-image-2');
                 }
-                return lines.join('\n');
-            };
+            }
+            else if (msg.includes('timed out')) {
+                lines.push('');
+                lines.push('Hint: Request timed out. The backend task may still be running — retries were skipped to avoid creating duplicate tasks.');
+                lines.push('  → Check the backend/admin panel for task status before re-running');
+                lines.push('  → Try --image-size 1K to reduce generation time');
+                lines.push('  → Or increase timeout with --timeout <seconds> (current default: 1800s)');
+            }
+            else if (hasReferenceImages && (msg.includes('reference') || msg.includes('image input'))) {
+                lines.push('');
+                lines.push('Hint: Reference image error — the selected model may not support --reference-image.');
+                lines.push('  → Run: playcraft tools list-image-models');
+                lines.push('  → Models with CAPABILITY=text+image support --reference-image');
+            }
+            return lines.join('\n');
+        };
+        try {
             let result = null;
             let lastError = null;
             // 重试逻辑：超时不重试（后端任务可能仍在运行，重试会导致重复提交）
-            const maxAttempts = 1 + (opts.retry ?? 0);
+            const maxAttempts = 1 + (opts.retry ?? 1);
             for (let attempt = 0; attempt < maxAttempts; attempt++) {
                 try {
-                    result = await attemptGenerate(opts.imageModel || assetContext?.imageModelRef, attempt);
+                    result = await attemptGenerate(opts.imageModel, attempt);
                     break;
                 }
                 catch (e) {
                     lastError = e;
                     const msg = e instanceof Error ? e.message : String(e);
                     const isTimeout = msg.includes('timed out');
-                    const cannotRetry = /source_transparency_invalid|output_transparency_invalid|transparency_unsupported|"retryable"\s*:\s*false/.test(msg);
-                    if (isTimeout || cannotRetry) {
-                        console.error(`Attempt ${attempt + 1} stopped: ${msg}`);
+                    if (isTimeout) {
+                        console.error(`Attempt ${attempt + 1} timed out — not retrying (backend task may still be running).`);
                         break;
                     }
                     if (attempt < maxAttempts - 1) {
@@ -311,18 +255,16 @@ export function registerGenerationCommands(tools) {
             }
             // 收集所有待保存图片（第 1 张 + 批量额外图）
             const allImages = [
-                { imageBase64: result.imageBase64, mimeType: result.mimeType, previewUrl: result.previewUrl },
+                { imageBase64: result.imageBase64, mimeType: result.mimeType },
                 ...(result.additionalImages ?? []),
             ];
             const isBatch = allImages.length > 1;
-            const modelPart = result.model ? `model: ${result.model}` : '';
+            const modelPart = opts.imageModel ? `model: ${opts.imageModel}` : '';
             const providerPart = result.provider ? `provider: ${result.provider}` : '';
             const labelParts = [modelPart, providerPart].filter(Boolean);
             const modelLabel = labelParts.length > 0 ? ` (${labelParts.join(', ')})` : '';
             const savedPaths = [];
-            if (result.transparencySource)
-                console.log(`Transparency source: ${result.transparencySource}`);
-            const stripTarget = opts.targetAsset || result.transparentBackground ? null : resolveStripTargetDimensions({
+            const stripTarget = resolveStripTargetDimensions({
                 aspectRatio: opts.aspectRatio,
                 width: opts.width,
                 height: opts.height,
@@ -351,8 +293,6 @@ export function registerGenerationCommands(tools) {
                         console.log(`↑ Letterbox ${generatedWidth}×${generatedHeight} → ${stripTarget.width}×${stripTarget.height}（等比 + 白边，不拉伸）`);
                     }
                 }
-                if (assetContext)
-                    assertImageAssetOutputPaths(assetContext, [resolvedPath]);
                 mkdirSync(dirname(resolvedPath), { recursive: true });
                 writeFileSync(resolvedPath, imgBuf);
                 let actualWidth = null;
@@ -369,23 +309,11 @@ export function registerGenerationCommands(tools) {
                 }
                 const sizeKB = Math.round(imgBuf.length / 1024);
                 console.log(`[${i + 1}/${allImages.length}] Image saved to ${resolvedPath} (${sizeKB}KB)${modelLabel}`);
-                if (img.previewUrl)
-                    console.log(`Image preview: ${img.previewUrl}`);
                 savedPaths.push(resolvedPath);
                 const sidecar = {
                     prompt: opts.prompt,
-                    model: result.model ?? null,
-                    requestedModel: opts.imageModel ?? null,
+                    model: opts.imageModel ?? 'default',
                     provider: result.provider ?? null,
-                    transparentBackground: result.transparentBackground ?? null,
-                    requestedBackground: opts.background ?? null,
-                    transparencySource: result.transparencySource ?? null,
-                    requestId: result.requestId ?? null,
-                    attempts: result.attempts ?? null,
-                    targetAssetPath: assetContext?.targetAssetPath ?? null,
-                    outputFormat: opts.outputFormat ?? null,
-                    fitMode: opts.fitMode ?? null,
-                    paddingColor: opts.paddingColor ?? null,
                     aspectRatio: opts.aspectRatio,
                     imageSize: opts.imageSize ?? null,
                     requestedWidth: opts.width ?? stripTarget?.width ?? null,
@@ -398,12 +326,14 @@ export function registerGenerationCommands(tools) {
                     count: opts.count ?? 1,
                     batchIndex: isBatch ? i + 1 : null,
                     output: resolvedPath,
-                    previewUrl: img.previewUrl ?? null,
                     referenceImageStatus: result.referenceImageStatus ?? null,
                     generatedAt: new Date().toISOString(),
                 };
                 const sidecarPath = resolvedPath.replace(/\.[^.]+$/, '.json');
                 writeFileSync(sidecarPath, JSON.stringify(sidecar, null, 2));
+                await captureGeneratedArtifact(resolvedPath, 'generate-image', {
+                    ...(actualWidth ? { width: actualWidth } : {}), ...(actualHeight ? { height: actualHeight } : {}),
+                });
                 console.log(`  └─ Generation metadata: ${sidecarPath}`);
             }
             if (!isBatch && opts.output !== savedPaths[0] && savedPaths[0]) {
@@ -451,6 +381,7 @@ export function registerGenerationCommands(tools) {
                 output: opts.output, generatedAt: new Date().toISOString(),
             };
             writeFileSync(opts.output.replace(/\.[^.]+$/, '.json'), JSON.stringify(sfxSidecar, null, 2));
+            await captureGeneratedArtifact(opts.output, 'generate-sfx', { duration: result.duration });
             console.log(`  └─ Generation metadata: ${opts.output.replace(/\.[^.]+$/, '.json')}`);
         }
         catch (e) {
@@ -483,6 +414,7 @@ export function registerGenerationCommands(tools) {
                 output: opts.output, generatedAt: new Date().toISOString(),
             };
             writeFileSync(opts.output.replace(/\.[^.]+$/, '.json'), JSON.stringify(bgmSidecar, null, 2));
+            await captureGeneratedArtifact(opts.output, 'generate-bgm', { duration: result.duration });
             console.log(`  └─ Generation metadata: ${opts.output.replace(/\.[^.]+$/, '.json')}`);
         }
         catch (e) {

package/dist/commands/tools-utils.js

@@ -1,20 +1,8 @@
 import { writeFileSync, mkdirSync, readFileSync } from 'fs';
 import { join, parse } from 'path';
 import { tmpdir } from 'os';
-import { InvalidArgumentError } from 'commander';
 export const TMP_DIR = join(tmpdir(), 'playcraft');
 export const MAX_REFERENCE_IMAGES = 8;
-export function parseImageTargetFieldPath(value) {
-    let parsed;
-    try {
-        parsed = JSON.parse(value);
-    }
-    catch { /* Report the expected shape below. */ }
-    if (!Array.isArray(parsed) || !parsed.length || parsed.some(key => typeof key !== 'string' || !key.length)) {
-        throw new InvalidArgumentError('Expected an array of field names, e.g. ["endUI","playButton"].');
-    }
-    return parsed;
-}
 export function ensureTmpDir() {
     mkdirSync(TMP_DIR, { recursive: true });
 }

package/dist/commands/tools.js

@@ -1,16 +1,16 @@
 import { registerGenerationCommands } from './tools-generation.js';
+import { registerBatchCommands } from './tools-batch.js';
 import { registerProjectCommands } from './tools-project.js';
 import { register3DCommands } from './tools-3d.js';
 import { registerDetectCommand } from './tools-detect.js';
 import { registerVideoReviewCommand } from './tools-video-review.js';
-import { registerImageContextCommand } from './tools-image-context.js';
 export function registerToolsCommands(program) {
     const tools = program
         .command('tools')
         .description('后端 /api/agent/tools；运行 playcraft login 后即可直接使用，也支持 .playcraft.json 或 PLAYCRAFT_SANDBOX_TOKEN 环境变量');
     registerGenerationCommands(tools);
-    registerImageContextCommand(tools);
     registerProjectCommands(tools);
+    registerBatchCommands(tools);
     register3DCommands(tools);
     registerDetectCommand(tools);
     registerVideoReviewCommand(tools);

package/dist/commands/video.js

@@ -0,0 +1,122 @@
+import { videoAnalysisRunSchema, videoModelCatalogSchema } from '@playcraft/common/agent-tools';
+import { AgentApiClient } from '../utils/agent-api-client.js';
+import { executeVideoUnderstanding, readVideoRun, requireVideoId, resolveVideoWorkspace, videoTimeout, } from '../video-replication/client.js';
+import { materializeVideoEvidence } from '../video-replication/evidence.js';
+import { probeVideo } from '../video-replication/media.js';
+import { VideoCliError, videoMessage as t } from '../video-replication/messages.js';
+import { comparisonMessage as c, ComparisonCliError } from '../video-replication/comparison-messages.js';
+import { describeVideoFailure, remoteVideoFailure } from '../video-replication/diagnostics.js';
+import { executeVideoComparison, readComparisonRun, comparisonRunResult } from '../video-replication/comparison.js';
+import { materializeComparisonEvidence } from '../video-replication/comparison-evidence.js';
+/** One final structured stdout record; progress and diagnostics stay on stderr. */
+export async function runVideoCliAction(command, options, action) {
+    const interrupt = new AbortController();
+    const onInterrupt = () => interrupt.abort(new DOMException('Interrupted', 'AbortError'));
+    process.once('SIGINT', onInterrupt);
+    let timer;
+    const deadline = new AbortController();
+    try {
+        timer = setTimeout(() => deadline.abort(new DOMException('Timed out', 'TimeoutError')), videoTimeout(options));
+        const result = await action(AbortSignal.any([interrupt.signal, deadline.signal]));
+        if (result.envelope.error)
+            process.stderr.write(`[video] ${result.envelope.error.message}\n`);
+        process.stdout.write(`${JSON.stringify(result.envelope)}\n`);
+        process.exitCode = result.exitCode;
+    }
+    catch (error) {
+        const known = error instanceof VideoCliError || error instanceof ComparisonCliError;
+        const key = known ? error.code : interrupt.signal.aborted ? 'interrupted' : deadline.signal.aborted ? 'timeoutReached' : 'failed';
+        const summary = error instanceof ComparisonCliError ? c(error.code) : error instanceof VideoCliError ? t(error.code)
+            : interrupt.signal.aborted ? t('interrupted') : deadline.signal.aborted ? t('timeoutReached') : command === 'video compare' ? c('comparisonFailed') : t('failed');
+        const envelope = {
+            schemaVersion: 'playcraft.video-cli.v1', command, state: interrupt.signal.aborted || deadline.signal.aborted ? 'uncertain' : 'failed', ok: false,
+            error: { code: key, ...describeVideoFailure(summary, error, command === 'video models' ? 'models' : command === 'video jobs get' ? 'poll' : command === 'video jobs cancel' ? 'cancel' : 'prepare') },
+        };
+        process.stderr.write(`[video] ${envelope.error.message}\n`);
+        process.stdout.write(`${JSON.stringify(envelope)}\n`);
+        process.exitCode = known ? error.exitCode : interrupt.signal.aborted ? 130 : deadline.signal.aborted ? 75 : 4;
+    }
+    finally {
+        if (timer)
+            clearTimeout(timer);
+        process.removeListener('SIGINT', onInterrupt);
+    }
+}
+function shared(command) {
+    return command.option('--workspace <id>', t('workspace')).option('--timeout <seconds>', t('timeout'));
+}
+export function registerVideoCommands(program) {
+    const video = program.command('video').description(t('topic'));
+    shared(video.command('models').description(t('models')))
+        .option('--json', t('json'))
+        .action((options) => runVideoCliAction('video models', options, async (signal) => {
+        const workspaceId = await resolveVideoWorkspace(options.workspace);
+        const catalog = videoModelCatalogSchema.parse(await new AgentApiClient().get('/video-models', { workspaceId }, { signal }));
+        return { exitCode: 0, envelope: { schemaVersion: 'playcraft.video-cli.v1', command: 'video models', state: 'completed', ok: true, result: catalog } };
+    }));
+    shared(video.command('understand').description(t('understand')))
+        .option('--video <path>', t('video')).option('--question <text>', t('question'))
+        .option('--context <path>', t('context')).option('--processing <mode>', t('processing'))
+        .option('--fps <number>', t('fps')).option('--clip <start:end>', t('clip'))
+        .option('--model-config <id>', t('model')).option('--out <directory>', t('out'))
+        .option('--resume <runId>', t('resume'))
+        .action((options) => runVideoCliAction('video understand', options, signal => executeVideoUnderstanding(options, signal, {
+        client: new AgentApiClient(), probe: probeVideo, materialize: materializeVideoEvidence,
+        progress: key => process.stderr.write(`[video] ${t(key)}\n`),
+    })));
+    shared(video.command('compare').description(c('compare')))
+        .option('--reference <path>', c('reference')).option('--analysis <path>', c('analysis'))
+        .option('--candidate <path>', c('candidate')).option('--recording <path>', c('recording'))
+        .option('--policy <path>', c('policy')).option('--processing <mode>', c('processing'))
+        .option('--fps <number>', t('fps')).option('--model-config <id>', t('model'))
+        .option('--out <directory>', t('out')).option('--resume <runId>', t('resume'))
+        .action((options) => runVideoCliAction('video compare', options, signal => executeVideoComparison(options, signal, {
+        client: new AgentApiClient(), probe: probeVideo, materialize: materializeComparisonEvidence,
+        progress: key => process.stderr.write(`[video] ${t(key)}\n`),
+    })));
+    const jobs = video.command('jobs').description(t('jobs'));
+    shared(jobs.command('get <runId>').description(t('get')))
+        .option('--kind <kind>', c('kind'))
+        .action((runId, options) => runVideoCliAction('video jobs get', options, async (signal) => {
+        const workspaceId = await resolveVideoWorkspace(options.workspace);
+        if (options.kind !== undefined && !['understanding', 'comparison'].includes(options.kind))
+            throw new VideoCliError('invalidArguments', 64);
+        if (options.kind === 'comparison') {
+            const run = await readComparisonRun(new AgentApiClient(), requireVideoId(runId), workspaceId, signal);
+            return comparisonRunResult('video jobs get', run);
+        }
+        const run = await readVideoRun(new AgentApiClient(), requireVideoId(runId), workspaceId, signal);
+        const error = remoteVideoFailure(run.state, run.error);
+        return { exitCode: run.state === 'uncertain' ? 75 : run.state === 'failed' || run.state === 'cancelled' ? 4 : 0, envelope: {
+                schemaVersion: 'playcraft.video-cli.v1', command: 'video jobs get', runId: run.runId, state: run.state,
+                ok: !['failed', 'uncertain', 'cancelled'].includes(run.state), result: run,
+                ...(error && { error }),
+            } };
+    }));
+    shared(jobs.command('cancel <runId>').description(t('cancel')))
+        .option('--kind <kind>', c('kind'))
+        .action((identifier, options) => runVideoCliAction('video jobs cancel', options, async (signal) => {
+        const workspaceId = await resolveVideoWorkspace(options.workspace);
+        const runId = requireVideoId(identifier);
+        if (options.kind !== undefined && !['understanding', 'comparison'].includes(options.kind))
+            throw new VideoCliError('invalidArguments', 64);
+        if (options.kind === 'comparison') {
+            const run = await readComparisonRun(new AgentApiClient(), runId, workspaceId, signal, true);
+            const confirmed = run.state === 'cancelled';
+            return { exitCode: confirmed ? 0 : 75, envelope: {
+                    schemaVersion: 'playcraft.video-cli.v1', command: 'video jobs cancel', runId, state: run.state,
+                    ok: confirmed, result: { ...run, cancellationConfirmed: confirmed },
+                    ...(!confirmed && { error: { code: 'uncertain', ...describeVideoFailure(t('uncertain'), run.error?.code, 'cancel') } }),
+                } };
+        }
+        const run = videoAnalysisRunSchema.parse(await new AgentApiClient().post(`/video-analysis/${runId}/cancel`, { workspaceId, runId }, { signal }));
+        if (run.runId !== runId || run.workspaceId !== workspaceId)
+            throw new VideoCliError('invalidResult');
+        const confirmed = run.state === 'cancelled';
+        return { exitCode: confirmed ? 0 : 75, envelope: {
+                schemaVersion: 'playcraft.video-cli.v1', command: 'video jobs cancel', runId, state: run.state,
+                ok: confirmed, result: { ...run, cancellationConfirmed: confirmed },
+                ...(!confirmed && { error: { code: 'uncertain', ...describeVideoFailure(t('uncertain'), run.error?.code, 'cancel') } }),
+            } };
+    }));
+}

package/dist/commands/workspace-runtime.js

@@ -0,0 +1,54 @@
+import { readFile } from 'node:fs/promises';
+import { INCOMPATIBLE_EXIT_CODE, parseSandboxRuntimeConfig, } from '@playcraft/common/cloud-workspace/runtime';
+import { startWorkspaceRuntime } from '../workspace-runtime/serve.js';
+export async function runWorkspaceRuntimeServe(configPath) {
+    process.env.PLAYCRAFT_SKIP_UPDATE_CHECK = '1';
+    let config;
+    try {
+        config = parseSandboxRuntimeConfig(JSON.parse(await readFile(configPath, 'utf8')));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`workspace-runtime config invalid: ${message}`);
+        process.exitCode = INCOMPATIBLE_EXIT_CODE;
+        return;
+    }
+    try {
+        const runtime = await startWorkspaceRuntime(config, { configPath });
+        console.log(JSON.stringify({
+            status: 'listening',
+            url: runtime.url,
+            phase: 'awaiting_native',
+            protocolMajor: runtime.config.protocolMajor,
+            protocolMinor: runtime.config.protocolMinor,
+        }));
+        await new Promise((resolve) => {
+            const stop = () => {
+                void runtime.close().finally(resolve);
+            };
+            process.once('SIGINT', stop);
+            process.once('SIGTERM', stop);
+        });
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === 'protocol_incompatible' || code === 'duplicate_instance') {
+            console.error(error instanceof Error ? error.message : code);
+            process.exitCode = INCOMPATIBLE_EXIT_CODE;
+            return;
+        }
+        throw error;
+    }
+}
+export function registerWorkspaceRuntimeCommands(program) {
+    const workspaceRuntime = program
+        .command('workspace-runtime')
+        .description('沙箱内 Sandbox Agent Server（Cloud Workspace 常驻运行入口）');
+    workspaceRuntime
+        .command('serve')
+        .description('前台常驻：读取 Runtime Server 下发的配置，不启动本地 backend 或旧同步')
+        .requiredOption('--config <path>', 'Runtime 引导配置 JSON')
+        .action(async (options) => {
+        await runWorkspaceRuntimeServe(options.config);
+    });
+}