@playcraft/cli 0.1.54 → 0.1.55-beta

package/dist/commands/image-layer-messages.js

@@ -0,0 +1,37 @@
+const messages = {
+    en: {
+        decompose: 'Separate an image into a base and editable layers using the cloud workspace pipeline',
+        input: 'Input image path or image address', outputDir: 'Output directory',
+        engine: 'Layer engine: seedream (workspace) or qwen (legacy)', imageModel: 'Image model reference for workspace layer separation',
+        size: 'Workspace layer size: auto, 1K, 1.5K, 2K', prompt: 'Optional layer guidance', team: 'Team used for model configuration',
+        numLayers: 'Legacy Qwen layer count, 2–10', safety: 'Disable the legacy Qwen safety checker', format: 'Legacy Qwen output format',
+        ninePatch: 'Analyze stretchable nine-patch borders with the cloud workspace vision model',
+        output: 'Save the analysis as a file', visionModel: 'Vision model reference',
+        invalidFile: 'Input must be a regular image file of at most {maxBytes} bytes', downloadFailed: 'Image download failed ({status})',
+        tooLarge: 'Input image exceeds {maxBytes} bytes', unsupportedInput: 'Input must be a single image in a supported format',
+        unsupportedOutput: 'Unsupported output image type: {mimeType}', invalidEngine: '--engine must be seedream or qwen',
+        legacyOnly: '--num-layers, --no-safety-checker and --output-format require --engine qwen',
+        workspaceOnly: '--image-model, --size and --team-id require --engine seedream',
+        invalidSize: '--size must be auto, 1K, 1.5K or 2K', invalidCount: '--num-layers must be an integer between 2 and 10',
+        saved: 'Saved separated layers and decompose-layers-meta.json to {outputDir}', failed: 'Image command failed: {message}',
+    },
+    zh: {
+        decompose: '使用云工作区同款管线，将图片分解为底图和可编辑图层',
+        input: '输入图片路径或图片地址', outputDir: '输出目录',
+        engine: '分层引擎：seedream（云工作区）或 qwen（旧版）', imageModel: '云工作区图层分离的图像模型引用',
+        size: '云工作区分层尺寸：auto、1K、1.5K、2K', prompt: '可选图层分离提示词', team: '模型配置所属团队',
+        numLayers: '旧版 Qwen 图层数量，2–10', safety: '关闭旧版 Qwen 安全检测', format: '旧版 Qwen 输出格式',
+        ninePatch: '使用云工作区视觉模型分析点九图可拉伸边界', output: '将分析结果保存到文件', visionModel: '视觉模型引用',
+        invalidFile: '输入必须是大小不超过 {maxBytes} 字节的普通图片文件', downloadFailed: '图片下载失败（{status}）',
+        tooLarge: '输入图片超过 {maxBytes} 字节', unsupportedInput: '输入必须是支持格式的单张图片',
+        unsupportedOutput: '不支持的输出图片类型：{mimeType}', invalidEngine: '--engine 必须为 seedream 或 qwen',
+        legacyOnly: '--num-layers、--no-safety-checker 和 --output-format 需要使用 --engine qwen',
+        workspaceOnly: '--image-model、--size 和 --team-id 需要使用 --engine seedream',
+        invalidSize: '--size 必须为 auto、1K、1.5K 或 2K', invalidCount: '--num-layers 必须为 2 到 10 之间的整数',
+        saved: '已将分离图层与 decompose-layers-meta.json 保存到 {outputDir}', failed: '图片命令执行失败：{message}',
+    },
+};
+export function imageLayerMessage(key, values = {}) {
+    const language = (process.env.PLAYCRAFT_LANGUAGE || process.env.LANG || 'en').startsWith('zh') ? 'zh' : 'en';
+    return messages[language][key].replace(/\{(\w+)\}/g, (match, name) => String(values[name] ?? match));
+}

package/dist/commands/image-layer-tools.js

@@ -0,0 +1,185 @@
+import { mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import sharp from 'sharp';
+import { AgentApiClient } from '../utils/agent-api-client.js';
+import { resolveSandboxPath } from '../utils/sandbox-path.js';
+import { imageLayerMessage as t } from './image-layer-messages.js';
+import { captureGeneratedArtifact } from '../workspace-runtime/workspaces/artifact-receipts.js';
+const MAX_IMAGE_BYTES = 30_000_000;
+const isRemote = (input) => /^https?:\/\//i.test(input);
+function localImageBytes(input, maxBytes) {
+    const filename = resolveSandboxPath(input);
+    const info = statSync(filename);
+    if (!info.isFile() || info.size > maxBytes) {
+        throw new Error(t('invalidFile', { maxBytes }));
+    }
+    return readFileSync(filename);
+}
+async function inputImage(input) {
+    let bytes;
+    if (isRemote(input)) {
+        const response = await fetch(input, { signal: AbortSignal.timeout(60_000) });
+        if (!response.ok || !response.body)
+            throw new Error(t('downloadFailed', { status: response.status }));
+        if (Number(response.headers.get('content-length')) > MAX_IMAGE_BYTES) {
+            await response.body.cancel();
+            throw new Error(t('tooLarge', { maxBytes: MAX_IMAGE_BYTES }));
+        }
+        const reader = response.body.getReader();
+        const chunks = [];
+        let total = 0;
+        try {
+            while (true) {
+                const chunk = await reader.read();
+                if (chunk.done)
+                    break;
+                total += chunk.value.byteLength;
+                if (total > MAX_IMAGE_BYTES)
+                    throw new Error(t('tooLarge', { maxBytes: MAX_IMAGE_BYTES }));
+                chunks.push(chunk.value);
+            }
+        }
+        finally {
+            await reader.cancel();
+        }
+        bytes = Buffer.concat(chunks);
+    }
+    else {
+        bytes = localImageBytes(input, MAX_IMAGE_BYTES);
+    }
+    const metadata = await sharp(bytes).metadata();
+    const inputMimeTypes = { png: 'image/png', jpeg: 'image/jpeg', webp: 'image/webp' };
+    const mimeType = inputMimeTypes[metadata.format ?? ''];
+    if (!mimeType || (metadata.pages ?? 1) > 1)
+        throw new Error(t('unsupportedInput'));
+    return { imageBase64: bytes.toString('base64'), mimeType };
+}
+function imageExtension(mimeType) {
+    const formats = { 'image/png': 'png', 'image/jpeg': 'jpg', 'image/webp': 'webp' };
+    const extension = formats[mimeType];
+    if (!extension)
+        throw new Error(t('unsupportedOutput', { mimeType }));
+    return extension;
+}
+function saveLayer(outputDir, stem, layer) {
+    const file = `${stem}.${imageExtension(layer.mimeType)}`;
+    writeFileSync(join(outputDir, file), Buffer.from(layer.imageBase64, 'base64'));
+    const { imageBase64: _bytes, ...metadata } = layer;
+    return { ...metadata, file };
+}
+function fail(error) {
+    console.error(t('failed', { message: error instanceof Error ? error.message : String(error) }));
+    process.exit(1);
+}
+export function registerImageLayerTools(image) {
+    image.command('decompose-layers')
+        .description(t('decompose'))
+        .requiredOption('--input <path>', t('input'))
+        .option('--output-dir <dir>', t('outputDir'), './decompose-layers-output')
+        .option('--engine <name>', t('engine'), 'seedream')
+        .option('--image-model <ref>', t('imageModel'))
+        .option('--size <size>', t('size'))
+        .option('--prompt <text>', t('prompt'), '')
+        .option('--team-id <id>', t('team'))
+        .option('--num-layers <n>', t('numLayers'), (value) => Number(value), 4)
+        .option('--no-safety-checker', t('safety'))
+        .option('--output-format <format>', t('format'), 'png')
+        .action(async (opts, command) => {
+        try {
+            const legacyFlags = ['numLayers', 'safetyChecker', 'outputFormat'].some(name => command.getOptionValueSource(name) === 'cli');
+            const explicitEngine = command.getOptionValueSource('engine') === 'cli';
+            const engine = legacyFlags && !explicitEngine ? 'qwen' : opts.engine;
+            if (!['seedream', 'qwen'].includes(engine))
+                throw new Error(t('invalidEngine'));
+            if (engine === 'seedream' && legacyFlags) {
+                throw new Error(t('legacyOnly'));
+            }
+            if (engine === 'qwen' && (opts.imageModel || opts.size || opts.teamId)) {
+                throw new Error(t('workspaceOnly'));
+            }
+            if (opts.size && !['auto', '1K', '1.5K', '2K'].includes(opts.size)) {
+                throw new Error(t('invalidSize'));
+            }
+            if (engine === 'qwen' && (!Number.isInteger(opts.numLayers) || opts.numLayers < 2 || opts.numLayers > 10)) {
+                throw new Error(t('invalidCount'));
+            }
+            const outputDir = resolveSandboxPath(opts.outputDir);
+            const input = opts.input;
+            const startedAt = Date.now();
+            const client = new AgentApiClient();
+            let metadata;
+            const savedImages = [];
+            if (engine === 'seedream') {
+                const result = await client.post('/image/layer-decomposition', {
+                    ...await inputImage(input),
+                    prompt: opts.prompt || undefined,
+                    size: opts.size || 'auto',
+                    imageModelRef: opts.imageModel,
+                    teamId: opts.teamId,
+                });
+                mkdirSync(outputDir, { recursive: true });
+                const base = saveLayer(outputDir, 'base', result.base);
+                const layers = result.layers.map((layer, index) => saveLayer(outputDir, `layer_${String(index).padStart(2, '0')}`, layer));
+                savedImages.push(...[base, ...layers].map(layer => join(outputDir, layer.file)));
+                metadata = { source: input, engine, base, layers, usage: result.usage };
+            }
+            else {
+                const maxBytes = Number.parseInt(process.env.PLAYCRAFT_IMAGE_MAX_INPUT_BYTES || '', 10);
+                const payload = {
+                    ...(isRemote(input) ? { imageUrl: input } : {
+                        imageBase64: localImageBytes(input, maxBytes > 0 ? maxBytes : 512 * 1024 * 1024).toString('base64'),
+                    }),
+                    numLayers: opts.numLayers,
+                    prompt: opts.prompt,
+                    enableSafetyChecker: opts.safetyChecker !== false,
+                    outputFormat: opts.outputFormat,
+                };
+                const result = await client.post('/image-layered/decompose', payload);
+                mkdirSync(outputDir, { recursive: true });
+                const layers = result.layers.map((layer) => {
+                    const file = `layer_${String(layer.index).padStart(2, '0')}.${imageExtension(layer.mimeType)}`;
+                    writeFileSync(join(outputDir, file), Buffer.from(layer.imageBase64, 'base64'));
+                    savedImages.push(join(outputDir, file));
+                    const { imageBase64: _bytes, ...details } = layer;
+                    return { ...details, file };
+                });
+                metadata = { source: input, engine, requestId: result.requestId, numLayers: result.numLayers,
+                    hasNsfwConcepts: result.hasNsfwConcepts, layers };
+            }
+            const elapsed = `${((Date.now() - startedAt) / 1000).toFixed(1)}s`;
+            writeFileSync(join(outputDir, 'decompose-layers-meta.json'), JSON.stringify({ ...metadata, elapsed }, null, 2));
+            for (const imagePath of savedImages)
+                await captureGeneratedArtifact(imagePath, 'decompose-layers');
+            console.log(t('saved', { outputDir }));
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+    image.command('analyze-nine-patch')
+        .description(t('ninePatch'))
+        .requiredOption('--input <path>', t('input'))
+        .option('--output <path>', t('output'))
+        .option('--vision-model <ref>', t('visionModel'))
+        .option('--team-id <id>', t('team'))
+        .action(async (opts) => {
+        try {
+            const input = await inputImage(opts.input);
+            const result = await new AgentApiClient().post('/image/analyze-nine-patch', {
+                imageBase64: input.imageBase64,
+                visionModelRef: opts.visionModel,
+                teamId: opts.teamId,
+            });
+            const json = JSON.stringify(result, null, 2);
+            if (opts.output) {
+                const output = resolveSandboxPath(opts.output);
+                mkdirSync(dirname(output), { recursive: true });
+                writeFileSync(output, json);
+            }
+            console.log(json);
+        }
+        catch (error) {
+            fail(error);
+        }
+    });
+}

package/dist/commands/image.js

@@ -4,6 +4,7 @@ import { fileURLToPath } from 'url';
 import sharp from 'sharp';
 import yaml from 'js-yaml';
 import { AgentApiClient } from '../utils/agent-api-client.js';
+import { registerImageLayerTools } from './image-layer-tools.js';
 import { resolveSandboxPath } from '../utils/sandbox-path.js';
 /** 单文件输入上限（字节），防止误处理巨型文件导致 OOM */
 const DEFAULT_MAX_INPUT_BYTES = 512 * 1024 * 1024;
@@ -1853,79 +1854,7 @@ export function registerImageCommands(program) {
             handleError(e);
         }
     });
-    // ─── decompose-layers ──────────────────────────────────────────────────────
-    img
-        .command('decompose-layers')
-        .description([
-        '302 Qwen-Image-Layered 整图语义分层：将合成图拆成 N 个 RGBA 图层',
-        '',
-        '  示例:',
-        '    playcraft image decompose-layers --input composite.png --output-dir ./layers',
-        '    playcraft image decompose-layers --input https://example.com/a.png --num-layers 4',
-        '',
-        '  需 Admin 配置 provider=302、modelKind=image 的 API Key；耗时约 1–2 分钟。',
-        '  本地文件需 storage 公网 URL，或 --input 使用 HTTPS 直链。',
-    ].join('\n'))
-        .requiredOption('--input <path>', '输入图片路径或 HTTPS URL')
-        .option('--output-dir <dir>', '输出目录', './decompose-layers-output')
-        .option('--num-layers <n>', '分层数量 2–10', cliParseInt, 4)
-        .option('--prompt <text>', '可选分层语义引导', '')
-        .option('--no-safety-checker', '关闭安全检测')
-        .option('--output-format <fmt>', '输出格式', 'png')
-        .action(async (opts) => {
-        try {
-            const payload = {
-                numLayers: opts.numLayers,
-                prompt: opts.prompt || '',
-                enableSafetyChecker: opts.safetyChecker !== false,
-                outputFormat: opts.outputFormat,
-            };
-            const input = opts.input;
-            const isUrl = input.startsWith('http://') || input.startsWith('https://');
-            if (isUrl) {
-                payload.imageUrl = input;
-                console.log(`Using image URL: ${input}`);
-            }
-            else {
-                const resolvedDecomposeInput = assertInputWithinLimit(input);
-                payload.imageBase64 = readFileSync(resolvedDecomposeInput).toString('base64');
-                console.log(`Uploading local image: ${input}`);
-            }
-            console.log(`Decomposing into ${payload.numLayers} layer(s) via 302 Qwen-Image-Layered (may take 1–2 min)…`);
-            const t0 = Date.now();
-            const client = new AgentApiClient();
-            const result = await client.post('/image-layered/decompose', payload);
-            const elapsed = ((Date.now() - t0) / 1000).toFixed(1);
-            const outputDir = opts.outputDir;
-            mkdirSync(outputDir, { recursive: true });
-            for (const layer of result.layers) {
-                const ext = layer.mimeType.includes('png') ? 'png' : 'png';
-                const filename = `layer_${String(layer.index).padStart(2, '0')}.${ext}`;
-                writeFileSync(join(outputDir, filename), Buffer.from(layer.imageBase64, 'base64'));
-                const dim = layer.width && layer.height ? ` ${layer.width}×${layer.height}` : '';
-                console.log(`  ${filename}${dim}`);
-            }
-            const meta = {
-                source: input,
-                requestId: result.requestId,
-                numLayers: result.numLayers,
-                elapsed: `${elapsed}s`,
-                hasNsfwConcepts: result.hasNsfwConcepts,
-                layers: result.layers.map((l) => ({
-                    index: l.index,
-                    url: l.url,
-                    width: l.width,
-                    height: l.height,
-                    seed: l.seed,
-                })),
-            };
-            writeFileSync(join(outputDir, 'decompose-layers-meta.json'), JSON.stringify(meta, null, 2), 'utf-8');
-            console.log(`\nDone in ${elapsed}s — ${result.layers.length} layer(s) → ${outputDir}/`);
-        }
-        catch (e) {
-            handleError(e);
-        }
-    });
+    registerImageLayerTools(img);
     // ─── segment ─────────────────────────────────────────────────────────────
     img
         .command('segment')

package/dist/commands/library-messages.js

@@ -0,0 +1,46 @@
+const messages = {
+    en: {
+        topic: 'Find and download authorized shared asset library content',
+        list: 'List library assets with filters and pagination', search: 'Search library names and content metadata',
+        get: 'Read asset metadata', files: 'List every file in an asset or bundle', facets: 'Inspect available categories and tags',
+        download: 'Download an asset or a complete bundle with relative dependencies',
+        query: 'Search text', id: 'Library asset identifier', type: 'Asset type', path: 'Library path prefix',
+        category: 'Category', subcategory: 'Subcategory', tags: 'Comma-separated tags',
+        visibility: 'public | team', team: 'Authorized team identifier', page: 'Page number, starting at 1',
+        limit: 'Results per page (1–100)', sort: 'modifiedAt | createdAt | name | referenceCount | size', order: 'asc | desc',
+        expand: 'Return individual files instead of collapsed bundles',
+        output: 'New file path, or a new directory for a bundle', outputDir: 'New directory for the downloaded content',
+        json: 'Print machine-readable JSON (JavaScript Object Notation, 数据交换格式; always enabled)',
+        invalidNumber: 'Expected a positive integer.', invalidId: 'Invalid library asset identifier.',
+        invalidManifest: 'The library returned an invalid or unsafe file manifest.',
+        outputRequired: 'Specify exactly one of --output or --output-dir.',
+        outputExists: 'The output already exists. Choose a new path to preserve existing files.',
+        failed: 'Asset library command failed.',
+    },
+    zh: {
+        topic: '检索和下载有权访问的共享素材库内容',
+        list: '按条件分页列出素材库内容', search: '检索素材名称和内容元数据',
+        get: '读取素材详情', files: '列出素材或素材包内的全部文件', facets: '查看可用分类与标签',
+        download: '下载素材或完整素材包，保留依赖文件的相对路径',
+        query: '检索文本', id: '素材库中的素材编号', type: '素材类型', path: '素材库路径前缀',
+        category: '分类', subcategory: '子分类', tags: '标签，逗号分隔',
+        visibility: 'public（公共）或 team（团队）', team: '有权访问的团队编号', page: '页码，从 1 开始',
+        limit: '每页数量（1–100）', sort: 'modifiedAt | createdAt | name | referenceCount | size', order: 'asc | desc',
+        expand: '返回单独文件，不折叠素材包', output: '新的文件路径；素材包则为新的目录', outputDir: '下载内容的新目录',
+        json: '输出机器可读的 JSON (JavaScript Object Notation, 数据交换格式)，始终启用',
+        invalidNumber: '请输入正整数。', invalidId: '素材库编号无效。',
+        invalidManifest: '素材库返回的文件清单无效或包含不安全路径。',
+        outputRequired: '请指定 --output 或 --output-dir，且只指定一项。',
+        outputExists: '输出路径已存在，请选择新路径以保留已有文件。', failed: '素材库命令执行失败。',
+    },
+};
+export function libraryMessage(key) {
+    return messages[(process.env.PLAYCRAFT_LANGUAGE || process.env.LANG || 'en').startsWith('zh') ? 'zh' : 'en'][key];
+}
+export class LibraryError extends Error {
+    code;
+    constructor(code) {
+        super(libraryMessage(code));
+        this.code = code;
+    }
+}

package/dist/commands/library.js

@@ -0,0 +1,130 @@
+import { InvalidArgumentError, Option } from 'commander';
+import { link, lstat, mkdir, mkdtemp, rename, rm } from 'node:fs/promises';
+import { dirname, join, posix, resolve } from 'node:path';
+import { AgentApiClient } from '../utils/agent-api-client.js';
+import { resolveSandboxPath } from '../utils/sandbox-path.js';
+import { libraryMessage as t, LibraryError } from './library-messages.js';
+function assetId(value) {
+    if (!/^(?:\d{1,20}|[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})$/i.test(value))
+        throw new InvalidArgumentError(t('invalidId'));
+    return value;
+}
+function positiveInteger(value) {
+    if (!/^[1-9]\d*$/.test(value) || !Number.isSafeInteger(Number(value)))
+        throw new InvalidArgumentError(t('invalidNumber'));
+    return value;
+}
+function filters(command) {
+    return command.option('--search <text>', t('query')).option('--type <type>', t('type'))
+        .option('--path <path>', t('path')).option('--category <category>', t('category'))
+        .option('--subcategory <category>', t('subcategory')).option('--tags <tags>', t('tags'))
+        .addOption(new Option('--visibility <scope>', t('visibility')).choices(['public', 'team']))
+        .option('--team-id <id>', t('team')).option('--page <number>', t('page'), positiveInteger, '1')
+        .option('--limit <number>', t('limit'), value => {
+        positiveInteger(value);
+        if (Number(value) > 100)
+            throw new InvalidArgumentError(t('limit'));
+        return value;
+    }, '30')
+        .addOption(new Option('--sort-by <field>', t('sort')).choices(['modifiedAt', 'createdAt', 'name', 'referenceCount', 'size']))
+        .addOption(new Option('--sort-order <order>', t('order')).choices(['asc', 'desc']))
+        .option('--expand-prefabs', t('expand')).option('--json', t('json'));
+}
+function query(options) {
+    return Object.fromEntries(Object.entries(options)
+        .filter(([key, value]) => key !== 'json' && value !== undefined && value !== false)
+        .map(([key, value]) => [key, String(value)]));
+}
+async function action(run) {
+    try {
+        console.log(JSON.stringify({ ok: true, result: await run() }, null, 2));
+    }
+    catch (error) {
+        const code = error instanceof LibraryError ? error.code : 'failed';
+        console.error(`${t('failed')} ${error instanceof Error ? error.message : String(error)}`);
+        console.log(JSON.stringify({ ok: false, error: { code, message: error instanceof Error ? error.message : String(error) } }));
+        process.exitCode = 1;
+    }
+}
+function validatedFiles(manifest) {
+    if (!manifest || !['file', 'bundle'].includes(manifest.kind) || !Array.isArray(manifest.files) ||
+        !manifest.files.length || (manifest.kind === 'file' && manifest.files.length !== 1))
+        throw new LibraryError('invalidManifest');
+    const seen = new Set();
+    for (const file of manifest.files) {
+        try {
+            assetId(file.id);
+        }
+        catch {
+            throw new LibraryError('invalidManifest');
+        }
+        const path = file.path;
+        if (typeof path !== 'string' || !path || path.startsWith('/') || /[\\:\x00-\x1f]/.test(path) ||
+            path.split('/').some(part => !part || part === '.' || part === '..') || posix.normalize(path) !== path)
+            throw new LibraryError('invalidManifest');
+        const key = path.toLowerCase();
+        if (seen.has(key))
+            throw new LibraryError('invalidManifest');
+        seen.add(key);
+    }
+    for (const key of seen) {
+        for (let parent = posix.dirname(key); parent !== '.'; parent = posix.dirname(parent)) {
+            if (seen.has(parent))
+                throw new LibraryError('invalidManifest');
+        }
+    }
+    return manifest.files;
+}
+export async function downloadLibraryAsset(client, id, options) {
+    if (Boolean(options.output) === Boolean(options.outputDir))
+        throw new LibraryError('outputRequired');
+    assetId(id);
+    const manifest = await client.get(`/asset-library/${encodeURIComponent(id)}/files`);
+    const files = validatedFiles(manifest);
+    const destination = resolve(resolveSandboxPath(options.output ?? options.outputDir));
+    const existing = await lstat(destination).catch(error => { if (error.code === 'ENOENT')
+        return undefined; throw error; });
+    if (existing)
+        throw new LibraryError('outputExists');
+    await mkdir(dirname(destination), { recursive: true });
+    const staging = await mkdtemp(join(dirname(destination), '.playcraft-library-'));
+    const directory = manifest.kind === 'bundle' || Boolean(options.outputDir);
+    const downloaded = [];
+    try {
+        for (const file of files) {
+            const target = directory ? join(staging, file.path) : join(staging, 'content');
+            const { bytes } = await client.download(`/asset-library/${encodeURIComponent(file.id)}/file`, target);
+            downloaded.push({ id: file.id, path: directory ? join(destination, file.path) : destination, bytes });
+        }
+        // Recheck before publishing the complete bundle; failures never expose a partial download.
+        if (await lstat(destination).catch(error => { if (error.code === 'ENOENT')
+            return undefined; throw error; }))
+            throw new LibraryError('outputExists');
+        if (directory)
+            await rename(staging, destination);
+        else
+            await link(join(staging, 'content'), destination);
+        return { assetId: manifest.assetId, kind: manifest.kind, output: destination, files: downloaded };
+    }
+    finally {
+        await rm(staging, { recursive: true, force: true });
+    }
+}
+export function registerLibraryCommands(program) {
+    const library = program.command('library').description(t('topic'));
+    filters(library.command('list').description(t('list')))
+        .action((options) => action(() => new AgentApiClient().get('/asset-library', query(options))));
+    filters(library.command('search').description(t('search')).argument('<query>', t('query')))
+        .action((search, options) => action(() => new AgentApiClient().get('/asset-library', query({ ...options, search }))));
+    library.command('facets').description(t('facets')).option('--path <path>', t('path'))
+        .addOption(new Option('--visibility <scope>', t('visibility')).choices(['public', 'team']))
+        .option('--team-id <id>', t('team')).option('--json', t('json'))
+        .action((options) => action(() => new AgentApiClient().get('/asset-library/facets', query(options))));
+    for (const command of ['get', 'files']) {
+        library.command(command).description(t(command)).argument('<assetId>', t('id'), assetId).option('--json', t('json'))
+            .action((id) => action(() => new AgentApiClient().get(`/asset-library/${encodeURIComponent(id)}${command === 'files' ? '/files' : ''}`)));
+    }
+    library.command('download').description(t('download')).argument('<assetId>', t('id'), assetId)
+        .option('--output <path>', t('output')).option('--output-dir <directory>', t('outputDir')).option('--json', t('json'))
+        .action((id, options) => action(() => downloadLibraryAsset(new AgentApiClient(), id, options)));
+}