@lingjingai/anime-cli-pre 0.1.5

package/bin/anime-cli.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+
+const cli = require('../src/anime-cli');
+
+cli.main(process.argv.slice(2)).then((exitCode) => {
+  process.exitCode = exitCode;
+});

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@lingjingai/anime-cli-pre",
+  "version": "0.1.5",
+  "description": "Standard CLI for Anime Workbench script, asset, and video output controllers.",
+  "bin": {
+    "anime-cli": "./bin/anime-cli.js"
+  },
+  "files": [
+    "bin",
+    "src"
+  ],
+  "scripts": {
+    "test": "node --test",
+    "prepack": "node -e \"const p=require('./package.json'); require('./src/anime-cli').preparePackageEnv((p.config && p.config.animeCliEnv) || 'pre')\"",
+    "postpack": "node -e \"require('./src/anime-cli').preparePackageEnv('pre')\"",
+    "pack:dev": "node -e \"require('./src/anime-cli').packForEnv('dev', 'dist/dev')\"",
+    "pack:pre": "node -e \"require('./src/anime-cli').packForEnv('pre', 'dist/pre')\"",
+    "pack:prod": "node -e \"require('./src/anime-cli').packForEnv('prod', 'dist/prod')\""
+  },
+  "config": {
+    "animeCliEnv": "pre",
+    "animeCliBaseUrls": {
+      "dev": "https://animeworkbench-dev.lingjingai.cn/api/anime/workbench",
+      "pre": "https://animeworkbench-pre.lingjingai.cn/api/anime/workbench",
+      "prod": "https://animeworkbench.lingjingai.cn/api/anime/workbench"
+    },
+    "animeCliPackageNames": {
+      "dev": "@lingjingai/anime-cli-dev",
+      "pre": "@lingjingai/anime-cli-pre",
+      "prod": "@lingjingai/anime-cli"
+    }
+  },
+  "license": "MIT",
+  "private": false,
+  "engines": {
+    "node": ">=18"
+  }
+}

package/src/anime-cli.js

@@ -0,0 +1,785 @@
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const pkg = require('../package.json');
+const scriptCommands = require('./commands/script').commands;
+const assetCommands = require('./commands/asset').commands;
+const videoCommands = require('./commands/video').commands;
+
+const VERSION = pkg.version;
+const WORKBENCH_CONTEXT_PATH = '/api/anime/workbench';
+const DEFAULT_PACK_ENV = 'pre';
+const DEFAULT_BASE_URL_BY_ENV = {
+  dev: 'https://animeworkbench-dev.lingjingai.cn/api/anime/workbench',
+  pre: 'https://animeworkbench-pre.lingjingai.cn/api/anime/workbench',
+  prod: 'https://animeworkbench.lingjingai.cn/api/anime/workbench',
+};
+const DEFAULT_PACKAGE_NAME_BY_ENV = {
+  dev: '@lingjingai/anime-cli-dev',
+  pre: '@lingjingai/anime-cli-pre',
+  prod: '@lingjingai/anime-cli',
+};
+const BASE_URL_BY_ENV = Object.assign({}, DEFAULT_BASE_URL_BY_ENV, (pkg.config && pkg.config.animeCliBaseUrls) || {});
+const PACKAGE_NAME_BY_ENV = Object.assign({}, DEFAULT_PACKAGE_NAME_BY_ENV, (pkg.config && pkg.config.animeCliPackageNames) || {});
+const PACKAGE_DEFAULT_CLI_ENV = normalizeCliEnv((pkg.config && pkg.config.animeCliEnv) || DEFAULT_PACK_ENV);
+const DEFAULT_BASE_URL = baseUrlForEnv(PACKAGE_DEFAULT_CLI_ENV);
+const SUCCESS_CODE = 200;
+const DOMAINS = ['system', 'script', 'asset', 'video'];
+const OUTPUT_FORMATS = new Set(['json', 'text', 'compact']);
+
+const COMMANDS = [
+  cmd('system', 'doctor', '环境体检', [], () => null),
+  cmd('system', 'schema', '输出机器可读命令 schema', ['-f json'], () => null),
+  ...scriptCommands,
+  ...assetCommands,
+  ...videoCommands,
+];
+
+const COMMAND_BY_KEY = new Map(COMMANDS.map((item) => [`${item.domain}:${item.name}`, item]));
+
+function parseArgs(argv = process.argv.slice(2), env = process.env) {
+  const cliEnv = resolveCliEnv(env);
+  const args = {
+    cliEnv,
+    packagedCliEnv: PACKAGE_DEFAULT_CLI_ENV,
+    baseUrl: env.ANIME_CLI_BASE_URL || env.ASSET_OUTPUT_BASE_URL || env.AWB_BASE_URL || baseUrlForEnv(cliEnv),
+    projectGroupNo: env.ANIME_PROJECT_GROUP_NO || env.ASSET_PROJECT_GROUP_NO || env.PROJECT_GROUP_NO,
+    projectId: env.ANIME_PROJECT_ID || env.PROJECT_ID,
+    accessKey: env.ANIME_CLI_ACCESS_KEY || env.LINGJING_AWB_ACCESS_KEY || env.AWB_ACCESS_KEY || env.AWB_CODE || env.ANIME_ACCESS_KEY,
+    authPath: env.ANIME_CLI_AUTH_PATH || defaultAuthPath(env),
+    legacyAuthPath: env.ANIME_CLI_LEGACY_AUTH_PATH || legacyAuthPath(env),
+    headers: [],
+    format: 'text',
+    timeout: 30000,
+    retry: 0,
+  };
+  const tokens = [...argv];
+  parseGlobalOptions(args, tokens);
+  if (tokens.length === 0) return Object.assign(args, { help: 'root' });
+
+  const first = tokens.shift();
+  if (first === 'doctor' || first === 'schema') {
+    Object.assign(args, { domain: 'system', command: first });
+    parseCommandOptions(args, tokens);
+    return args;
+  }
+  args.domain = first;
+
+  if (args.domain === 'system') {
+    if (tokens.length === 0 || isHelp(tokens[0])) return Object.assign(args, { help: 'domain' });
+    args.command = tokens.shift();
+    parseCommandOptions(args, tokens);
+    return args;
+  }
+  if (!DOMAINS.includes(args.domain)) return parseLegacyCommand(args, tokens);
+  if (tokens.length === 0 || isHelp(tokens[0])) return Object.assign(args, { help: 'domain' });
+
+  args.command = tokens.shift();
+  parseCommandOptions(args, tokens);
+  return args;
+}
+
+function parseGlobalOptions(args, tokens) {
+  while (tokens.length > 0 && tokens[0].startsWith('-')) {
+    const token = tokens.shift();
+    if (isHelp(token)) {
+      args.help = 'root';
+      tokens.length = 0;
+    } else if (token === '-v' || token === '--version') {
+      args.version = true;
+      tokens.length = 0;
+    } else if (token === '-f' || token === '--format') {
+      args.format = parseOutputFormat(takeValue(tokens, token));
+    } else if (token === '--json') {
+      args.format = 'json';
+    } else if (token === '--raw') {
+      args.raw = true;
+    } else if (token === '--dry-run') {
+      args.dryRun = true;
+    } else if (token === '--base-url') {
+      args.baseUrl = takeValue(tokens, token);
+    } else if (token === '-g' || token === '--project-group-no') {
+      args.projectGroupNo = takeValue(tokens, token);
+    } else if (token === '--project-id') {
+      args.projectId = takeValue(tokens, token);
+    } else if (token === '--cookie') {
+      args.cookie = takeValue(tokens, token);
+    } else if (token === '--access-key') {
+      args.accessKey = takeValue(tokens, token);
+    } else if (token === '--no-access-key') {
+      args.noAccessKey = true;
+    } else if (token === '--header') {
+      args.headers.push(takeValue(tokens, token));
+    } else if (token === '--timeout') {
+      args.timeout = Number(takeValue(tokens, token)) * 1000;
+    } else if (token === '--retry') {
+      args.retry = Number(takeValue(tokens, token));
+    } else if (token === '--output-file') {
+      args.outputFile = takeValue(tokens, token);
+    } else {
+      throw usageError(`unknown option: ${token}`);
+    }
+  }
+}
+
+function parseCommandOptions(args, tokens) {
+  while (tokens.length > 0) {
+    const token = tokens.shift();
+    if (isHelp(token)) {
+      args.help = 'command';
+      continue;
+    }
+    if (token === '-f' || token === '--format') {
+      const value = takeValue(tokens, token);
+      if (isOutputFormat(value)) args.format = value;
+      else args.inputFile = value;
+    } else if (token === '--json') args.format = 'json';
+    else if (token === '--raw') args.raw = true;
+    else if (token === '--dry-run') args.dryRun = true;
+    else if (token === '--base-url') args.baseUrl = takeValue(tokens, token);
+    else if (token === '-g' || token === '--project-group-no') args.projectGroupNo = takeValue(tokens, token);
+    else if (token === '--project-id') args.projectId = takeValue(tokens, token);
+    else if (token === '--input-file' || token === '--json-file' || token === '-i') args.inputFile = takeValue(tokens, token);
+    else if (token === '--output-file') args.outputFile = takeValue(tokens, token);
+    else if (token === '--cookie') args.cookie = takeValue(tokens, token);
+    else if (token === '--access-key') args.accessKey = takeValue(tokens, token);
+    else if (token === '--no-access-key') args.noAccessKey = true;
+    else if (token === '--header') args.headers.push(takeValue(tokens, token));
+    else if (token === '--timeout') args.timeout = Number(takeValue(tokens, token)) * 1000;
+    else if (token === '--retry') args.retry = Number(takeValue(tokens, token));
+    else if (token === '--include-states') args.includeStates = parseOptionalBool(tokens, true);
+    else if (token === '--no-include-states') args.includeStates = false;
+    else if (token.startsWith('--')) args[kebabToCamel(token.slice(2))] = takeValue(tokens, token);
+    else throw usageError(`unexpected argument: ${token}`);
+  }
+}
+
+function parseLegacyCommand(args, tokens) {
+  const resource = args.domain;
+  args.domain = 'asset';
+  if (resource === 'project') {
+    const action = takeLegacyAction(tokens, 'project action');
+    args.command = action === 'detail' ? 'get' : action;
+  } else if (resource === 'style') {
+    const action = takeLegacyAction(tokens, 'style action');
+    args.command = action === 'get' ? 'style' : `${action}-style`;
+  } else if (['actors', 'props', 'locations'].includes(resource)) {
+    parseLegacyAssetResource(args, tokens, resource);
+  } else if (resource === 'resources') {
+    parseLegacySimpleResource(args, tokens, resource, 'resource');
+  } else if (resource === 'resource-tasks') {
+    parseLegacyTask(args, tokens, 'resource-task', 'resource-tasks');
+  } else if (resource === 'material-tasks') {
+    parseLegacyTask(args, tokens, 'material-task', 'material-tasks');
+  } else if (resource === 'resource-whitelists') {
+    parseLegacySimpleResource(args, tokens, resource, 'resource-whitelist');
+  } else {
+    throw usageError(`unknown domain: ${resource}`);
+  }
+  parseCommandOptions(args, tokens);
+  return args;
+}
+
+function parseLegacyAssetResource(args, tokens, resource) {
+  const singularByResource = { actors: 'actor', props: 'prop', locations: 'location' };
+  const keyByResource = { actors: 'actorKey', props: 'propKey', locations: 'locationKey' };
+  const action = takeLegacyAction(tokens, `${resource} action`);
+  const singular = singularByResource[resource];
+  const keyName = keyByResource[resource];
+  if (action === 'list') args.command = resource;
+  else if (action === 'get') {
+    args.command = singular;
+    args[keyName] = takeLegacyAction(tokens, keyName);
+  } else if (action === 'upsert') args.command = `upsert-${singular}`;
+  else if (action === 'batch') args.command = `batch-${resource}`;
+  else if (action === 'delete') {
+    args.command = `delete-${singular}`;
+    args[keyName] = takeLegacyAction(tokens, keyName);
+  } else if (action === 'states') {
+    args[keyName] = takeLegacyAction(tokens, keyName);
+    const stateAction = takeLegacyAction(tokens, 'state action');
+    if (stateAction === 'list') args.command = `${singular}-states`;
+    else if (stateAction === 'get') {
+      args.command = `${singular}-state`;
+      args.stateKey = takeLegacyAction(tokens, 'stateKey');
+    } else if (stateAction === 'upsert') args.command = `upsert-${singular}-state`;
+    else if (stateAction === 'delete') {
+      args.command = `delete-${singular}-state`;
+      args.stateKey = takeLegacyAction(tokens, 'stateKey');
+    } else throw usageError(`unknown state action: ${stateAction}`);
+  } else throw usageError(`unknown ${resource} action: ${action}`);
+}
+
+function parseLegacySimpleResource(args, tokens, resource, singular) {
+  const action = takeLegacyAction(tokens, `${resource} action`);
+  if (action === 'list') args.command = resource;
+  else if (action === 'upsert') args.command = `upsert-${singular}`;
+  else if (action === 'delete') {
+    args.command = `delete-${singular}`;
+    args[`${singular.replace(/-/g, '')}Id`] = takeLegacyAction(tokens, `${singular}Id`);
+    if (singular === 'resource') args.resourceId = args.resourceId || args.resourceId;
+    if (singular === 'resource-whitelist') args.whitelistId = args.resourcewhitelistId;
+  } else throw usageError(`unknown ${resource} action: ${action}`);
+}
+
+function parseLegacyTask(args, tokens, command, name) {
+  const action = takeLegacyAction(tokens, `${name} action`);
+  if (action === 'list') {
+    args.command = 'resource-tasks';
+  } else if (action === 'create') {
+    args.command = command;
+    args.businessType = takeLegacyAction(tokens, 'businessType');
+  } else {
+    throw usageError(`unknown ${name} action: ${action}`);
+  }
+}
+
+function buildRequest(args) {
+  const command = getCommand(args);
+  const headers = buildHeaders(args);
+  const route = command.build(args);
+  if (route.body !== undefined) headers['content-type'] = headers['content-type'] || 'application/json';
+  headers.accept = headers.accept || 'application/json';
+  return {
+    method: route.method,
+    url: buildUrl(args.baseUrl, route.pathParts, route.query),
+    headers,
+    body: route.body,
+  };
+}
+
+async function run(args, options = {}) {
+  const stdout = options.stdout || process.stdout;
+  const stderr = options.stderr || process.stderr;
+  if (args.version) return writeAndReturn(stdout, `anime-cli v${VERSION}\n`, 0);
+  if (args.help) return writeAndReturn(stdout, helpText(args), 0);
+  if (args.domain === 'system' && args.command === 'doctor') return runDoctor(args, stdout);
+  if (args.domain === 'system' && args.command === 'schema') return runSchema(args, stdout);
+
+  let request;
+  try {
+    request = buildRequest(args);
+  } catch (error) {
+    stderr.write(`${error.message}\n`);
+    return 2;
+  }
+  if (args.dryRun) {
+    writeDryRun(stdout, request, args);
+    return 0;
+  }
+
+  const fetchImpl = options.fetchImpl || globalThis.fetch;
+  if (!fetchImpl) {
+    stderr.write('global fetch is unavailable; use Node.js 18 or newer\n');
+    return 2;
+  }
+
+  let response;
+  try {
+    response = await fetchWithRetry(fetchImpl, request, args);
+  } catch (error) {
+    stderr.write(`request failed: ${error.message}\n`);
+    return 1;
+  }
+
+  const content = await decodeResponse(response);
+  if (!response.ok) {
+    stderr.write(`HTTP failed: ${response.status}\n`);
+    writeOutput(stderr, content, args);
+    return 1;
+  }
+  if (isApiResult(content)) {
+    if (content.code !== SUCCESS_CODE) {
+      stderr.write(`API failed: ${content.code} ${content.msg}\n`);
+      if (args.raw) writeOutput(stdout, content, args);
+      return 1;
+    }
+    writeOutput(stdout, args.raw ? content : content.data, args);
+    return 0;
+  }
+  writeOutput(stdout, content, args);
+  return 0;
+}
+
+function runDoctor(args, stdout) {
+  const auth = resolveAccessKey(args);
+  const data = {
+    version: VERSION,
+    env: args.cliEnv,
+    packagedEnv: args.packagedCliEnv,
+    baseUrl: args.baseUrl,
+    node: process.version,
+    auth: {
+      configured: Boolean(auth.value),
+      source: auth.source,
+      accessKey: mask(auth.value),
+      path: auth.path,
+    },
+  };
+  if (args.format === 'json') {
+    writeOutput(stdout, data, args);
+  } else {
+    stdout.write(`anime-cli v${VERSION}\nenv: ${args.cliEnv}\npackagedEnv: ${args.packagedCliEnv}\nbaseUrl: ${args.baseUrl}\nnode: ${process.version}\nauth: ${data.auth.configured ? `configured (${data.auth.source})` : 'not configured'}\n`);
+  }
+  return 0;
+}
+
+function runSchema(args, stdout) {
+  const schema = {
+    version: VERSION,
+    domains: Object.fromEntries(DOMAINS.map((domain) => [
+      domain,
+      COMMANDS.filter((item) => item.domain === domain).map(({ name, summary, options }) => ({ name, summary, options })),
+    ])),
+  };
+  writeOutput(stdout, schema, Object.assign({}, args, { format: 'json' }));
+  return 0;
+}
+
+async function fetchWithRetry(fetchImpl, request, args) {
+  let lastError;
+  const attempts = Math.max(0, Number(args.retry) || 0) + 1;
+  for (let i = 0; i < attempts; i += 1) {
+    try {
+      const response = await fetchImpl(request.url, {
+        method: request.method,
+        headers: request.headers,
+        body: request.body,
+        signal: abortSignal(args.timeout),
+      });
+      if (response.status < 500 || i === attempts - 1) return response;
+    } catch (error) {
+      lastError = error;
+      if (i === attempts - 1) throw error;
+    }
+  }
+  throw lastError;
+}
+
+function getCommand(args) {
+  const command = COMMAND_BY_KEY.get(`${args.domain}:${args.command}`);
+  if (!command) throw usageError(`unknown command: ${args.domain} ${args.command || ''}`.trim());
+  return command;
+}
+
+function helpText(args = {}) {
+  if (!args.domain || args.help === 'root') return rootHelp();
+  if (args.help === 'domain') return domainHelp(args.domain);
+  return commandHelp(args.domain, args.command);
+}
+
+function rootHelp() {
+  return `anime-cli v${VERSION}
+
+灵境 Anime Workbench 最终产物命令行工具。默认输出精简文本；需要 JSON 时传 -f json。
+
+Usage:
+  anime-cli <domain> <command> [options]
+  anime-cli <command> [options]
+  anime-cli <domain> -h
+  anime-cli <domain> <command> -h
+
+Quick start:
+  anime-cli doctor
+  anime-cli schema -f json
+  anime-cli script get --project-group-no <projectGroupNo>
+  anime-cli asset get --project-group-no <projectGroupNo>
+  anime-cli video get --project-group-no <projectGroupNo>
+
+Command groups:
+  system       系统：环境体检和机器可读命令 schema
+  script       剧本最终产物：完整剧本、版本、资产、场景、动作和校验结果
+  asset        资产最终产物：角色、道具、场景、资源、任务和加白记录
+  video        视频最终产物：集、场、clip 三级产物与视频链接回写
+
+More help:
+  anime-cli <domain> -h
+  anime-cli <domain> <command> -h
+  anime-cli schema -f json
+  anime-cli doctor -h
+
+Global options:
+  -f, --format json|text|compact
+                          输出格式；默认 text，compact 为单行 JSON
+  --json                   等同于 -f json
+  --base-url <url>         服务地址，默认按 ANIME_CLI_ENV 或打包环境选择；当前默认 ${DEFAULT_BASE_URL}
+  --access-key <key>       Access key；默认读取 ANIME_CLI_ACCESS_KEY 或 lj-awb 本地认证
+  --no-access-key          不自动发送 access-key
+  --cookie <value>         Cookie header
+  --header <name:value>    额外 HTTP header，可重复
+  --dry-run                只打印请求，不发送
+  --retry <n>              网络失败或 5xx 重试次数
+  --timeout <seconds>      HTTP 超时，默认 30
+  --raw                    输出完整 ApiResult
+  -h, --help               查看帮助
+  -v, --version            查看版本
+`;
+}
+
+function domainHelp(domain) {
+  if (domain === 'system') {
+    return `anime-cli v${VERSION}
+
+系统：环境体检和机器可读命令 schema
+
+Usage:
+  anime-cli system <command> [options]
+  anime-cli <command> [options]
+
+Commands:
+  doctor                       环境体检
+  schema                       输出机器可读命令 schema
+`;
+  }
+  const title = {
+    script: '剧本最终产物：完整剧本、版本、资产、场景、动作和校验结果',
+    asset: '资产最终产物：角色、道具、场景、资源、任务和加白记录',
+    video: '视频最终产物：集、场、clip 三级产物与视频链接回写',
+  }[domain];
+  const lines = COMMANDS.filter((item) => item.domain === domain)
+    .map((item) => `  ${item.name.padEnd(28)} ${item.summary}`)
+    .join('\n');
+  return `anime-cli v${VERSION}
+
+${title}
+
+Usage:
+  anime-cli ${domain} <command> [options]
+
+Commands:
+${lines}
+
+More help:
+  anime-cli ${domain} <command> -h
+`;
+}
+
+function commandHelp(domain, commandName) {
+  const command = COMMAND_BY_KEY.get(`${domain}:${commandName}`);
+  if (!command) return domainHelp(domain);
+  return `anime-cli v${VERSION}
+
+${command.summary}
+
+Usage:
+  anime-cli ${domain} ${command.name} [options]
+
+Options:
+${command.options.map((line) => `  ${line}`).join('\n') || '  (none)'}
+  -f, --format json|text|compact
+  --dry-run
+  -h, --help
+
+Examples:
+  ${exampleFor(command)}
+`;
+}
+
+function exampleFor(command) {
+  const d = command.domain;
+  const c = command.name;
+  if (d === 'script' && c === 'get') return 'anime-cli script get --project-group-no pg_001';
+  if (d === 'script' && c === 'replace') return 'anime-cli script replace --project-group-no pg_001 --input-file script.json';
+  if (d === 'asset' && c === 'material-task') return 'anime-cli asset material-task --project-group-no pg_001 --business-type image_generate --input-file task.json';
+  if (d === 'video' && c === 'update-clip-video-urls') return 'anime-cli video update-clip-video-urls --project-group-no pg_001 --episode-id ep_001 --scene-id scn_001 --clip-id clip_001 --input-file video-urls.json';
+  return `anime-cli ${d} ${c} ${command.options.join(' ')}`;
+}
+
+function writeOutput(stream, value, args) {
+  const text = formatOutput(value, args.format);
+  if (args.outputFile) fs.writeFileSync(args.outputFile, text);
+  else stream.write(text);
+}
+
+function formatOutput(value, format = 'text') {
+  if (format === 'json') return `${JSON.stringify(value, null, 2)}\n`;
+  if (format === 'compact') return `${JSON.stringify(value)}\n`;
+  return textSummary(value);
+}
+
+function textSummary(value) {
+  if (value === undefined || value === null) return 'OK\n';
+  if (Array.isArray(value)) return `${value.length} items\n`;
+  if (typeof value === 'object') {
+    if ('id' in value) return `id: ${value.id}\n`;
+    return `${JSON.stringify(value, null, 2)}\n`;
+  }
+  return `${String(value)}\n`;
+}
+
+function writeDryRun(stream, request, args) {
+  const payload = {
+    method: request.method,
+    url: request.url,
+    headers: maskSensitiveHeaders(request.headers),
+    body: request.body ? JSON.parse(request.body) : undefined,
+  };
+  if (args.format === 'json' || args.format === 'compact') stream.write(formatOutput(payload, args.format));
+  else {
+    stream.write(`${request.method} ${request.url}\n`);
+    if (request.body) stream.write(`${request.body}\n`);
+  }
+}
+
+function maskSensitiveHeaders(headers) {
+  return Object.fromEntries(Object.entries(headers || {}).map(([key, value]) => {
+    if (['access-key', 'x-access-key', 'authorization', 'cookie'].includes(key.toLowerCase())) {
+      return [key, mask(String(value))];
+    }
+    return [key, value];
+  }));
+}
+
+function buildHeaders(args) {
+  const headers = {};
+  if (args.cookie) headers.cookie = args.cookie;
+  if (args.userId) headers.userid = args.userId;
+  const accessKey = resolveAccessKey(args).value;
+  if (accessKey) headers['X-Access-Key'] = accessKey;
+  for (const value of args.headers || []) {
+    const index = value.indexOf(':');
+    if (index < 1) throw usageError(`invalid --header value: ${value}`);
+    headers[value.slice(0, index).trim().toLowerCase()] = value.slice(index + 1).trim();
+  }
+  return headers;
+}
+
+function resolveAccessKey(args) {
+  if (args.noAccessKey) return { value: null, source: 'disabled' };
+  if (args.accessKey) return { value: args.accessKey, source: 'option/env' };
+  for (const authPath of [args.authPath, args.legacyAuthPath]) {
+    const value = readAccessKeyFromFile(authPath);
+    if (value) return { value, source: 'saved/auth', path: authPath };
+  }
+  return { value: null, source: 'none' };
+}
+
+function readAccessKeyFromFile(authPath) {
+  if (!authPath || !fs.existsSync(authPath)) return null;
+  try {
+    const auth = JSON.parse(fs.readFileSync(authPath, 'utf8'));
+    return auth.accessKey || auth.awbCode || auth.awb_code || auth.access_key || null;
+  } catch {
+    return null;
+  }
+}
+
+function defaultAuthPath(env = process.env) {
+  return path.join(homeDir(env), '.lingjingai', 'awb', 'auth.json');
+}
+
+function legacyAuthPath(env = process.env) {
+  return path.join(homeDir(env), '.opencli', 'awb-auth.json');
+}
+
+function homeDir(env = process.env) {
+  return env.HOME || os.homedir();
+}
+
+function mask(value) {
+  if (!value) return null;
+  if (value.length <= 8) return '****';
+  return `${value.slice(0, 4)}...${value.slice(-4)}`;
+}
+
+async function decodeResponse(response) {
+  const text = await response.text();
+  if (!text) return null;
+  const contentType = getHeader(response.headers, 'content-type');
+  if (contentType.includes('json') || looksLikeJson(text)) return JSON.parse(text);
+  return text;
+}
+
+function getHeader(headers, name) {
+  if (!headers) return '';
+  if (typeof headers.get === 'function') return headers.get(name) || '';
+  if (headers instanceof Map) return headers.get(name) || '';
+  return headers[name] || headers[name.toLowerCase()] || '';
+}
+
+function buildUrl(baseUrl, pathParts, query = {}) {
+  const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+  const url = new URL(`${normalizedBaseUrl.replace(/\/+$/, '')}/${pathParts.map((part) => encodeURIComponent(String(part))).join('/')}`);
+  for (const [key, value] of Object.entries(query || {})) {
+    if (value !== undefined && value !== null) url.searchParams.set(key, value);
+  }
+  return url.toString();
+}
+
+function normalizeBaseUrl(baseUrl) {
+  const url = new URL(baseUrl);
+  const path = url.pathname.replace(/\/+$/, '');
+  if (path === '' || path === '/') {
+    url.pathname = WORKBENCH_CONTEXT_PATH;
+  } else if (path === '/api/anime') {
+    url.pathname = WORKBENCH_CONTEXT_PATH;
+  } else if (!path.endsWith(WORKBENCH_CONTEXT_PATH)) {
+    url.pathname = `${path}${WORKBENCH_CONTEXT_PATH}`;
+  } else {
+    url.pathname = path;
+  }
+  return url.toString().replace(/\/+$/, '');
+}
+
+function resolveCliEnv(env = process.env) {
+  return normalizeCliEnv(env.ANIME_CLI_ENV || PACKAGE_DEFAULT_CLI_ENV);
+}
+
+function normalizeCliEnv(value) {
+  const cliEnv = String(value || DEFAULT_PACK_ENV).trim().toLowerCase();
+  return Object.prototype.hasOwnProperty.call(BASE_URL_BY_ENV, cliEnv) ? cliEnv : DEFAULT_PACK_ENV;
+}
+
+function assertCliEnv(value) {
+  const cliEnv = String(value || DEFAULT_PACK_ENV).trim().toLowerCase();
+  if (!Object.prototype.hasOwnProperty.call(BASE_URL_BY_ENV, cliEnv)) {
+    throw new Error(`unsupported ANIME_CLI_PACK_ENV: ${value}. expected one of ${Object.keys(BASE_URL_BY_ENV).join(', ')}`);
+  }
+  return cliEnv;
+}
+
+function baseUrlForEnv(cliEnv) {
+  return BASE_URL_BY_ENV[normalizeCliEnv(cliEnv)];
+}
+
+function packageNameForEnv(cliEnv) {
+  return PACKAGE_NAME_BY_ENV[normalizeCliEnv(cliEnv)];
+}
+
+function preparePackageEnv(value = DEFAULT_PACK_ENV) {
+  const cliEnv = assertCliEnv(value);
+  const packagePath = path.join(__dirname, '..', 'package.json');
+  const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+  packageJson.name = packageNameForEnv(cliEnv);
+  packageJson.config = packageJson.config || {};
+  packageJson.config.animeCliEnv = cliEnv;
+  packageJson.config.animeCliBaseUrls = Object.assign(
+    {},
+    DEFAULT_BASE_URL_BY_ENV,
+    packageJson.config.animeCliBaseUrls || {},
+  );
+  packageJson.config.animeCliPackageNames = Object.assign(
+    {},
+    DEFAULT_PACKAGE_NAME_BY_ENV,
+    packageJson.config.animeCliPackageNames || {},
+  );
+  fs.writeFileSync(packagePath, `${JSON.stringify(packageJson, null, 2)}\n`);
+}
+
+function packForEnv(value, packDestination) {
+  const cliEnv = assertCliEnv(value);
+  const npmCommand = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  const { spawnSync } = require('node:child_process');
+  const npmArgs = ['pack'];
+  if (packDestination) {
+    fs.mkdirSync(packDestination, { recursive: true });
+    npmArgs.push('--pack-destination', packDestination);
+  }
+  try {
+    preparePackageEnv(cliEnv);
+    const result = spawnSync(npmCommand, npmArgs, {
+      stdio: 'inherit',
+      env: Object.assign({}, process.env, { ANIME_CLI_PACK_ENV: cliEnv }),
+    });
+    if (result.error) throw result.error;
+    process.exit(result.status === null ? 1 : result.status);
+  } finally {
+    preparePackageEnv(DEFAULT_PACK_ENV);
+  }
+}
+
+function cmd(domain, name, summary, options, build) {
+  return { domain, name, summary, options, build };
+}
+
+function parseOptionalBool(tokens, defaultValue) {
+  if (tokens.length === 0 || tokens[0].startsWith('-')) return defaultValue;
+  const value = tokens.shift();
+  return value !== 'false';
+}
+
+function abortSignal(timeout) {
+  if (!timeout || !Number.isFinite(timeout)) return undefined;
+  return AbortSignal.timeout(timeout);
+}
+
+function takeValue(tokens, option) {
+  if (tokens.length === 0 || tokens[0].startsWith('-')) throw usageError(`missing value for ${option}`);
+  return tokens.shift();
+}
+
+function takeLegacyAction(tokens, name) {
+  if (tokens.length === 0 || isHelp(tokens[0])) throw usageError(`missing ${name}`);
+  return tokens.shift();
+}
+
+function parseOutputFormat(value) {
+  if (!isOutputFormat(value)) throw usageError(`unsupported format: ${value}. expected json, text or compact`);
+  return value;
+}
+
+function isOutputFormat(value) {
+  return OUTPUT_FORMATS.has(value);
+}
+
+function isHelp(value) {
+  return value === '-h' || value === '--help';
+}
+
+function camelToKebab(value) {
+  return value.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}
+
+function kebabToCamel(value) {
+  return value.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+
+function looksLikeJson(text) {
+  const trimmed = text.trimStart();
+  return trimmed.startsWith('{') || trimmed.startsWith('[');
+}
+
+function isApiResult(value) {
+  return value && typeof value === 'object' && 'code' in value && 'msg' in value && 'data' in value;
+}
+
+function usageError(message) {
+  const error = new Error(message);
+  error.isUsageError = true;
+  return error;
+}
+
+function writeAndReturn(stream, value, exitCode) {
+  stream.write(value);
+  return exitCode;
+}
+
+function main(argv) {
+  let args;
+  try {
+    args = parseArgs(argv);
+  } catch (error) {
+    process.stderr.write(`${error.message}\n\n${rootHelp()}`);
+    return Promise.resolve(2);
+  }
+  return run(args);
+}
+
+module.exports = {
+  DEFAULT_BASE_URL_BY_ENV,
+  DEFAULT_PACKAGE_NAME_BY_ENV,
+  DEFAULT_BASE_URL,
+  DEFAULT_PACK_ENV,
+  PACKAGE_DEFAULT_CLI_ENV,
+  VERSION,
+  COMMANDS,
+  parseArgs,
+  buildRequest,
+  normalizeBaseUrl,
+  packageNameForEnv,
+  preparePackageEnv,
+  packForEnv,
+  run,
+  main,
+  helpText,
+};

package/src/command-helpers.js

@@ -0,0 +1,187 @@
+const fs = require('node:fs');
+
+function cmd(domain, name, summary, options, build) {
+  return { domain, name, summary, options, build };
+}
+
+function get(pathParts, query) {
+  return { method: 'GET', pathParts, query };
+}
+
+function post(pathParts, args, fields, options = {}) {
+  return { method: 'POST', pathParts, body: buildRequestBody(args, fields, options) };
+}
+
+function put(pathParts, args) {
+  return { method: 'PUT', pathParts, body: readJsonBody(args) };
+}
+
+function scriptRoot(args) {
+  return ['script-output', 'project-groups', req(args, 'projectGroupNo')];
+}
+
+function assetRoot(args) {
+  return ['asset', 'project-groups', req(args, 'projectGroupNo')];
+}
+
+function videoRoot(args) {
+  return ['video-output', 'project-groups', req(args, 'projectGroupNo')];
+}
+
+function buildRequestBody(args, fields, options = {}) {
+  if (!fields) return args && args.inputFile ? readJsonBody(args) : undefined;
+  const cliBody = bodyFromArgs(args, fields);
+  const hasCliBody = Object.keys(cliBody).length > 0;
+  if (!args.inputFile && !hasCliBody) return undefined;
+  const fileBody = args.inputFile ? readJsonValue(args) : undefined;
+  const merged = mergeBody(fileBody, cliBody, hasCliBody);
+  const body = options.array && !Array.isArray(merged) ? [merged] : merged;
+  return JSON.stringify(body);
+}
+
+function mergeBody(fileBody, cliBody, hasCliBody) {
+  if (fileBody === undefined) return cliBody;
+  if (!hasCliBody) return fileBody;
+  if (Array.isArray(fileBody)) {
+    return fileBody.map((item) => {
+      if (!item || typeof item !== 'object' || Array.isArray(item)) {
+        throw usageError('cannot merge body options into non-object array items');
+      }
+      return Object.assign({}, item, cliBody);
+    });
+  }
+  if (!fileBody || typeof fileBody !== 'object') {
+    throw usageError('cannot merge body options into non-object input file');
+  }
+  return Object.assign({}, fileBody, cliBody);
+}
+
+function bodyFromArgs(args, fields) {
+  return Object.fromEntries(fields
+    .filter((field) => args[field.name] !== undefined)
+    .map((field) => [field.name, parseBodyFieldValue(args[field.name], field)]));
+}
+
+function parseBodyFieldValue(value, field) {
+  if (field.type === 'string') return value;
+  if (field.type === 'number') return parseNumber(value, field.name);
+  if (field.type === 'boolean') return parseBoolean(value, field.name);
+  if (field.type === 'json') return parseJsonOption(value, field.name);
+  if (field.type === 'numberList') return parseList(value, field.name, (item) => parseNumber(item, field.name));
+  if (field.type === 'stringList') return parseList(value, field.name, String);
+  throw usageError(`unsupported body field type: ${field.type}`);
+}
+
+function parseNumber(value, name) {
+  const number = Number(value);
+  if (!Number.isFinite(number)) throw usageError(`--${camelToKebab(name)} must be a number`);
+  return number;
+}
+
+function parseBoolean(value, name) {
+  if (value === true || value === false) return value;
+  if (value === 'true' || value === '1') return true;
+  if (value === 'false' || value === '0') return false;
+  throw usageError(`--${camelToKebab(name)} must be true or false`);
+}
+
+function parseJsonOption(value, name) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw usageError(`--${camelToKebab(name)} must be valid JSON`);
+  }
+}
+
+function parseList(value, name, mapItem) {
+  const items = String(value).trimStart().startsWith('[')
+    ? parseJsonOption(value, name)
+    : String(value).split(',').map((item) => item.trim()).filter(Boolean);
+  if (!Array.isArray(items)) throw usageError(`--${camelToKebab(name)} must be a comma-separated list or JSON array`);
+  return items.map(mapItem);
+}
+
+function readJsonBody(args) {
+  return JSON.stringify(readJsonValue(args));
+}
+
+function readJsonValue(args) {
+  if (!args.inputFile) throw usageError('missing --input-file <file|->');
+  const raw = args.inputFile === '-' ? fs.readFileSync(0, 'utf8') : fs.readFileSync(args.inputFile, 'utf8');
+  return JSON.parse(raw);
+}
+
+function bodyCommandOptions(fields, pathOptions = []) {
+  return ['--project-group-no <no>', ...pathOptions, '--input-file <file|->', ...bodyOptions(fields)];
+}
+
+function bodyOptions(fields) {
+  return fields.map((field) => `--${camelToKebab(field.name)} <${bodyOptionValueLabel(field.type)}>`);
+}
+
+function bodyOptionValueLabel(type) {
+  if (type === 'boolean') return 'true|false';
+  if (type === 'json') return 'json';
+  if (type === 'numberList' || type === 'stringList') return 'csv|json';
+  return 'value';
+}
+
+function bodyFields(fields) {
+  return fields.map((field) => {
+    if (Array.isArray(field)) return { name: field[0], type: field[1] };
+    return { name: field, type: inferBodyFieldType(field) };
+  });
+}
+
+function inferBodyFieldType(name) {
+  if (['id', 'actorId', 'locationId', 'propId', 'stateId', 'assetId', 'parentResourceId', 'assetResourceTaskId'].includes(name)) {
+    return 'number';
+  }
+  return 'string';
+}
+
+function pick(args, fields) {
+  return Object.fromEntries(fields.filter((field) => args[field] !== undefined).map((field) => [field, args[field]]));
+}
+
+function req(args, field) {
+  if (args[field] === undefined || args[field] === '') throw usageError(`missing --${camelToKebab(field)}`);
+  return args[field];
+}
+
+function businessType(args) {
+  const value = req(args, 'businessType');
+  if (!['image_edit', 'image_generate'].includes(value)) throw usageError('businessType must be image_edit or image_generate');
+  return value;
+}
+
+function boolText(value, defaultValue) {
+  return String(value === undefined ? defaultValue : value);
+}
+
+function camelToKebab(value) {
+  return value.replace(/[A-Z]/g, (match) => `-${match.toLowerCase()}`);
+}
+
+function usageError(message) {
+  const error = new Error(message);
+  error.isUsageError = true;
+  return error;
+}
+
+module.exports = {
+  assetRoot,
+  bodyCommandOptions,
+  bodyFields,
+  boolText,
+  businessType,
+  camelToKebab,
+  cmd,
+  get,
+  pick,
+  post,
+  put,
+  req,
+  scriptRoot,
+  videoRoot,
+};

package/src/commands/asset.js

@@ -0,0 +1,218 @@
+const {
+  assetRoot,
+  bodyCommandOptions,
+  bodyFields,
+  boolText,
+  businessType,
+  camelToKebab,
+  cmd,
+  get,
+  pick,
+  post,
+  req,
+} = require('../command-helpers');
+
+const ASSET_FILTER_FIELDS = ['assetType', 'assetId', 'stateId', 'resourceType', 'resourceSlot'];
+const WHITELIST_FILTER_FIELDS = ['assetType', 'assetId', 'stateId', 'resourceId', 'platform'];
+const PROJECT_STYLE_BODY_FIELDS = bodyFields([
+  'id',
+  'projectName',
+  'projectDisplay',
+  'worldviewType',
+  'assetsWorldviewType',
+  'worldviewSubtype',
+  'era',
+  'visualMode',
+  'appearanceRegion',
+  'appearanceSubtype',
+  ['appearanceRegionTraits', 'json'],
+  'nativeLanguage',
+  ['sceneStyle', 'json'],
+  ['characterStyle', 'json'],
+  ['propStyle', 'json'],
+  'antiContamination',
+  ['lab', 'json'],
+]);
+const ACTOR_BODY_FIELDS = bodyFields([
+  'id',
+  'actorKey',
+  'actorName',
+  'roleType',
+  ['lab', 'json'],
+  'name',
+  'voiceText',
+  'voiceDesc',
+  'voiceUrl',
+  'voiceStatus',
+  ['voiceCandidates', 'json'],
+  'selectedVoiceCandidateId',
+  'voiceBackend',
+  'voiceReferenceImageUrl',
+  ['states', 'json'],
+]);
+const ACTOR_STATE_BODY_FIELDS = bodyFields([
+  'id',
+  'actorId',
+  'stateKey',
+  'stateName',
+  'gender',
+  'age',
+  'assetsWorldviewType',
+  'description',
+  ['episodes', 'json'],
+  'genPrompt',
+  'promptHead',
+  'promptBody',
+  ['matchedHeadAsset', 'json'],
+  ['matchedBodyAsset', 'json'],
+  ['lab', 'json'],
+  'roleType',
+  'subjectId',
+  'threeViewId',
+  'status',
+  'faceView',
+  'faceViewUrl',
+  'sideView',
+  'sideViewUrl',
+  'backView',
+  'backViewUrl',
+  'threeView',
+  'threeViewUrl',
+  'headCloseup',
+  'headCloseupUrl',
+  'frontFullBodyPrompt',
+  'threeViewPrompt',
+  ['resources', 'json'],
+]);
+const PROP_BODY_FIELDS = bodyFields([
+  'id',
+  'propKey',
+  'propName',
+  'groupName',
+  ['groupDefault', 'boolean'],
+  ['imagePrompts', 'json'],
+  ['episodes', 'json'],
+  ['lab', 'json'],
+  ['states', 'json'],
+]);
+const LOCATION_BODY_FIELDS = bodyFields([
+  'id',
+  'locationKey',
+  'locationName',
+  'groupSheetUrl',
+  'groupName',
+  ['groupDefault', 'boolean'],
+  ['imagePrompts', 'json'],
+  ['episodes', 'json'],
+  ['lab', 'json'],
+  ['states', 'json'],
+]);
+const SIMPLE_STATE_BODY_FIELDS = bodyFields([
+  'id',
+  'stateKey',
+  'stateName',
+  'description',
+  'genPrompt',
+  ['lab', 'json'],
+  'status',
+  'main',
+  'mainUrl',
+  'auxiliary',
+  'auxiliaryUrl',
+  ['resources', 'json'],
+]);
+const RESOURCE_BODY_FIELDS = bodyFields([
+  'id',
+  'assetType',
+  'assetId',
+  'stateId',
+  'resourceType',
+  'resourceSlot',
+  'sourceType',
+  'parentResourceId',
+  'prompt',
+  ['promptParams', 'json'],
+  'assetResourceTaskId',
+  'status',
+  'url',
+  'errorMsg',
+  ['lab', 'json'],
+]);
+const RESOURCE_TASK_BODY_FIELDS = bodyFields([
+  'actorId',
+  'locationId',
+  'propId',
+  'stateId',
+  'resourceType',
+  'resourceSlot',
+  'sourceType',
+  'parentResourceId',
+  'modelGroupCode',
+  'taskPrompt',
+  ['promptParams', 'json'],
+]);
+const WHITELIST_BODY_FIELDS = bodyFields([
+  ['actorIds', 'numberList'],
+  ['locationIds', 'numberList'],
+  ['propIds', 'numberList'],
+  ['resourceIds', 'numberList'],
+  ['resourceSlotList', 'stringList'],
+  'whitelistType',
+  'platform',
+  'remark',
+  ['lab', 'json'],
+]);
+
+const commands = [
+  cmd('asset', 'get', '查询项目组全部资产产物', ['--project-group-no <no>'], (a) => get(assetRoot(a))),
+  cmd('asset', 'output', '查询资产详情视图', ['--project-group-no <no>'], (a) => get([...assetRoot(a), 'output'])),
+  cmd('asset', 'style', '查询项目资产风格配置', ['--project-group-no <no>'], (a) => get([...assetRoot(a), 'style'])),
+  cmd('asset', 'upsert-style', '新增或更新项目资产风格配置', bodyCommandOptions(PROJECT_STYLE_BODY_FIELDS), (a) => post([...assetRoot(a), 'style'], a, PROJECT_STYLE_BODY_FIELDS)),
+  cmd('asset', 'delete-style', '逻辑删除项目资产风格配置', ['--project-group-no <no>'], (a) => post([...assetRoot(a), 'style', 'delete'])),
+  cmd('asset', 'actors', '查询项目组角色列表', ['--project-group-no <no>', '--include-states <true|false>'], (a) => get([...assetRoot(a), 'actors'], { includeStates: boolText(a.includeStates, true) })),
+  cmd('asset', 'actor', '查询单个角色', ['--project-group-no <no>', '--actor-key <key>', '--include-states <true|false>'], (a) => get([...assetRoot(a), 'actors', req(a, 'actorKey')], { includeStates: boolText(a.includeStates, true) })),
+  cmd('asset', 'upsert-actor', '新增或更新角色', bodyCommandOptions(ACTOR_BODY_FIELDS), (a) => post([...assetRoot(a), 'actors'], a, ACTOR_BODY_FIELDS)),
+  cmd('asset', 'batch-actors', '批量新增或更新角色', bodyCommandOptions(ACTOR_BODY_FIELDS), (a) => post([...assetRoot(a), 'actors', 'batch'], a, ACTOR_BODY_FIELDS, { array: true })),
+  cmd('asset', 'delete-actor', '逻辑删除角色', ['--project-group-no <no>', '--actor-key <key>'], (a) => post([...assetRoot(a), 'actors', req(a, 'actorKey'), 'delete'])),
+  cmd('asset', 'actor-states', '查询角色状态列表', ['--project-group-no <no>', '--actor-key <key>'], (a) => get([...assetRoot(a), 'actors', req(a, 'actorKey'), 'states'])),
+  cmd('asset', 'actor-state', '查询单个角色状态', ['--project-group-no <no>', '--actor-key <key>', '--state-key <key>'], (a) => get([...assetRoot(a), 'actors', req(a, 'actorKey'), 'states', req(a, 'stateKey')])),
+  cmd('asset', 'upsert-actor-state', '新增或更新角色状态', bodyCommandOptions(ACTOR_STATE_BODY_FIELDS, ['--actor-key <key>']), (a) => post([...assetRoot(a), 'actors', req(a, 'actorKey'), 'states'], a, ACTOR_STATE_BODY_FIELDS)),
+  cmd('asset', 'delete-actor-state', '逻辑删除角色状态', ['--project-group-no <no>', '--actor-key <key>', '--state-key <key>'], (a) => post([...assetRoot(a), 'actors', req(a, 'actorKey'), 'states', req(a, 'stateKey'), 'delete'])),
+  ...assetTypeCommands('props', 'prop', 'propKey', '道具'),
+  ...assetTypeCommands('locations', 'location', 'locationKey', '场景'),
+  cmd('asset', 'resources', '查询资产资源列表', assetFilterOptions(), (a) => get([...assetRoot(a), 'resources'], pick(a, ASSET_FILTER_FIELDS))),
+  cmd('asset', 'upsert-resource', '新增或更新资产资源', bodyCommandOptions(RESOURCE_BODY_FIELDS), (a) => post([...assetRoot(a), 'resources'], a, RESOURCE_BODY_FIELDS)),
+  cmd('asset', 'delete-resource', '逻辑删除资产资源', ['--project-group-no <no>', '--resource-id <id>'], (a) => post([...assetRoot(a), 'resources', req(a, 'resourceId'), 'delete'])),
+  cmd('asset', 'resource-tasks', '查询资产资源任务列表', assetFilterOptions(), (a) => get([...assetRoot(a), 'resource-tasks'], pick(a, ASSET_FILTER_FIELDS))),
+  cmd('asset', 'resource-task', '创建资产图片异步任务', bodyCommandOptions(RESOURCE_TASK_BODY_FIELDS, ['--business-type <image_edit|image_generate>']), (a) => post([...assetRoot(a), 'resource-tasks', businessType(a)], a, RESOURCE_TASK_BODY_FIELDS)),
+  cmd('asset', 'material-task', '创建资产图片异步任务', bodyCommandOptions(RESOURCE_TASK_BODY_FIELDS, ['--business-type <image_edit|image_generate>']), (a) => post([...assetRoot(a), 'material-tasks', businessType(a)], a, RESOURCE_TASK_BODY_FIELDS)),
+  cmd('asset', 'resource-whitelists', '查询资产资源加白记录', whitelistFilterOptions(), (a) => get([...assetRoot(a), 'resource-whitelists'], pick(a, WHITELIST_FILTER_FIELDS))),
+  cmd('asset', 'upsert-resource-whitelist', '新增或更新资产资源加白记录', bodyCommandOptions(WHITELIST_BODY_FIELDS), (a) => post([...assetRoot(a), 'resource-whitelists'], a, WHITELIST_BODY_FIELDS)),
+  cmd('asset', 'delete-resource-whitelist', '逻辑删除资产资源加白记录', ['--project-group-no <no>', '--whitelist-id <id>'], (a) => post([...assetRoot(a), 'resource-whitelists', req(a, 'whitelistId'), 'delete'])),
+];
+
+function assetTypeCommands(plural, singular, keyName, label) {
+  const fields = singular === 'location' ? LOCATION_BODY_FIELDS : PROP_BODY_FIELDS;
+  const stateFields = SIMPLE_STATE_BODY_FIELDS;
+  return [
+    cmd('asset', plural, `查询项目组${label}列表`, ['--project-group-no <no>', '--include-states <true|false>'], (a) => get([...assetRoot(a), plural], { includeStates: boolText(a.includeStates, true) })),
+    cmd('asset', singular, `查询单个${label}`, ['--project-group-no <no>', `--${camelToKebab(keyName)} <key>`, '--include-states <true|false>'], (a) => get([...assetRoot(a), plural, req(a, keyName)], { includeStates: boolText(a.includeStates, true) })),
+    cmd('asset', `upsert-${singular}`, `新增或更新${label}`, bodyCommandOptions(fields), (a) => post([...assetRoot(a), plural], a, fields)),
+    cmd('asset', `batch-${plural}`, `批量新增或更新${label}`, bodyCommandOptions(fields), (a) => post([...assetRoot(a), plural, 'batch'], a, fields, { array: true })),
+    cmd('asset', `delete-${singular}`, `逻辑删除${label}`, ['--project-group-no <no>', `--${camelToKebab(keyName)} <key>`], (a) => post([...assetRoot(a), plural, req(a, keyName), 'delete'])),
+    cmd('asset', `${singular}-states`, `查询${label}状态列表`, ['--project-group-no <no>', `--${camelToKebab(keyName)} <key>`], (a) => get([...assetRoot(a), plural, req(a, keyName), 'states'])),
+    cmd('asset', `${singular}-state`, `查询单个${label}状态`, ['--project-group-no <no>', `--${camelToKebab(keyName)} <key>`, '--state-key <key>'], (a) => get([...assetRoot(a), plural, req(a, keyName), 'states', req(a, 'stateKey')])),
+    cmd('asset', `upsert-${singular}-state`, `新增或更新${label}状态`, bodyCommandOptions(stateFields, [`--${camelToKebab(keyName)} <key>`]), (a) => post([...assetRoot(a), plural, req(a, keyName), 'states'], a, stateFields)),
+    cmd('asset', `delete-${singular}-state`, `逻辑删除${label}状态`, ['--project-group-no <no>', `--${camelToKebab(keyName)} <key>`, '--state-key <key>'], (a) => post([...assetRoot(a), plural, req(a, keyName), 'states', req(a, 'stateKey'), 'delete'])),
+  ];
+}
+
+function assetFilterOptions() {
+  return ['--project-group-no <no>', '--asset-type <type>', '--asset-id <id>', '--state-id <id>', '--resource-type <type>', '--resource-slot <slot>'];
+}
+
+function whitelistFilterOptions() {
+  return ['--project-group-no <no>', '--asset-type <type>', '--asset-id <id>', '--state-id <id>', '--resource-id <id>', '--platform <platform>'];
+}
+
+module.exports = { commands };

package/src/commands/script.js

@@ -0,0 +1,26 @@
+const {
+  cmd,
+  get,
+  pick,
+  post,
+  put,
+  req,
+  scriptRoot,
+} = require('../command-helpers');
+
+const commands = [
+  cmd('script', 'get', '查询完整剧本', ['--project-group-no <no>'], (a) => get(scriptRoot(a))),
+  cmd('script', 'revision', '查询剧本版本', ['--project-group-no <no>'], (a) => get([...scriptRoot(a), 'revision'])),
+  cmd('script', 'replace', '整包替换剧本', ['--project-group-no <no>', '--input-file <file|->', '--user-id <id>'], (a) => put(scriptRoot(a), a)),
+  cmd('script', 'assets', '查询剧本资产', ['--project-group-no <no>', '--asset-kind <kind>'], (a) => get([...scriptRoot(a), 'assets'], pick(a, ['assetKind']))),
+  cmd('script', 'asset-states', '查询资产状态', ['--project-group-no <no>', '--asset-kind <kind>', '--asset-uid <uid>'], (a) => get([...scriptRoot(a), 'assets', req(a, 'assetKind'), req(a, 'assetUid'), 'states'])),
+  cmd('script', 'speakers', '查询发声源', ['--project-group-no <no>'], (a) => get([...scriptRoot(a), 'speakers'])),
+  cmd('script', 'episodes', '查询分集', ['--project-group-no <no>'], (a) => get([...scriptRoot(a), 'episodes'])),
+  cmd('script', 'scenes', '查询分集下场景', ['--project-group-no <no>', '--episode-uid <uid>'], (a) => get([...scriptRoot(a), 'episodes', req(a, 'episodeUid'), 'scenes'])),
+  cmd('script', 'scene', '查询单个场景', ['--project-group-no <no>', '--scene-uid <uid>'], (a) => get([...scriptRoot(a), 'scenes', req(a, 'sceneUid')])),
+  cmd('script', 'actions', '查询场景动作', ['--project-group-no <no>', '--scene-uid <uid>'], (a) => get([...scriptRoot(a), 'scenes', req(a, 'sceneUid'), 'actions'])),
+  cmd('script', 'issues', '查询校验问题', ['--project-group-no <no>', '--revision <revision>'], (a) => get([...scriptRoot(a), 'issues'], pick(a, ['revision']))),
+  cmd('script', 'save-validation-result', '写入校验结果', ['--project-group-no <no>', '--input-file <file|->'], (a) => post([...scriptRoot(a), 'validation-result'], a)),
+];
+
+module.exports = { commands };

package/src/commands/video.js

@@ -0,0 +1,29 @@
+const {
+  cmd,
+  get,
+  post,
+  req,
+  videoRoot,
+} = require('../command-helpers');
+
+const commands = [
+  cmd('video', 'get', '查询项目完整视频产物', ['--project-group-no <no>'], (a) => get(videoRoot(a))),
+  cmd('video', 'episodes', '查询集列表', ['--project-group-no <no>'], (a) => get([...videoRoot(a), 'episodes'])),
+  cmd('video', 'episode', '查询单集', ['--project-group-no <no>', '--episode-id <id>'], (a) => get([...videoRoot(a), 'episodes', req(a, 'episodeId')])),
+  cmd('video', 'upsert-episode', '新增或更新集', ['--project-group-no <no>', '--input-file <file|->'], (a) => post([...videoRoot(a), 'episodes'], a)),
+  cmd('video', 'batch-episodes', '批量新增或更新集', ['--project-group-no <no>', '--input-file <file|->'], (a) => post([...videoRoot(a), 'episodes', 'batch'], a)),
+  cmd('video', 'delete-episode', '逻辑删除集', ['--project-group-no <no>', '--episode-id <id>'], (a) => post([...videoRoot(a), 'episodes', req(a, 'episodeId'), 'delete'])),
+  cmd('video', 'scenes', '查询某集下的场列表', ['--project-group-no <no>', '--episode-id <id>'], (a) => get([...videoRoot(a), 'episodes', req(a, 'episodeId'), 'scenes'])),
+  cmd('video', 'scene', '查询单场', ['--project-group-no <no>', '--episode-id <id>', '--scene-id <id>'], (a) => get([...videoRoot(a), 'episodes', req(a, 'episodeId'), 'scenes', req(a, 'sceneId')])),
+  cmd('video', 'upsert-scene', '新增或更新场', ['--project-group-no <no>', '--episode-id <id>', '--input-file <file|->'], (a) => post([...videoRoot(a), 'episodes', req(a, 'episodeId'), 'scenes'], a)),
+  cmd('video', 'batch-scenes', '批量新增或更新场', ['--project-group-no <no>', '--episode-id <id>', '--input-file <file|->'], (a) => post([...videoRoot(a), 'episodes', req(a, 'episodeId'), 'scenes', 'batch'], a)),
+  cmd('video', 'delete-scene', '逻辑删除场', ['--project-group-no <no>', '--episode-id <id>', '--scene-id <id>'], (a) => post([...videoRoot(a), 'episodes', req(a, 'episodeId'), 'scenes', req(a, 'sceneId'), 'delete'])),
+  cmd('video', 'clips', '查询某场下的 clip 列表', ['--project-group-no <no>', '--episode-id <id>', '--scene-id <id>'], (a) => get([...videoRoot(a), 'episodes', req(a, 'episodeId'), 'scenes', req(a, 'sceneId'), 'clips'])),
+  cmd('video', 'clip', '查询单个 clip', ['--project-group-no <no>', '--episode-id <id>', '--scene-id <id>', '--clip-id <id>'], (a) => get([...videoRoot(a), 'episodes', req(a, 'episodeId'), 'scenes', req(a, 'sceneId'), 'clips', req(a, 'clipId')])),
+  cmd('video', 'upsert-clip', '新增或更新 clip', ['--project-group-no <no>', '--episode-id <id>', '--scene-id <id>', '--input-file <file|->'], (a) => post([...videoRoot(a), 'episodes', req(a, 'episodeId'), 'scenes', req(a, 'sceneId'), 'clips'], a)),
+  cmd('video', 'batch-clips', '批量新增或更新 clip', ['--project-group-no <no>', '--episode-id <id>', '--scene-id <id>', '--input-file <file|->'], (a) => post([...videoRoot(a), 'episodes', req(a, 'episodeId'), 'scenes', req(a, 'sceneId'), 'clips', 'batch'], a)),
+  cmd('video', 'update-clip-video-urls', '更新 clip 视频链接', ['--project-group-no <no>', '--episode-id <id>', '--scene-id <id>', '--clip-id <id>', '--input-file <file|->'], (a) => post([...videoRoot(a), 'episodes', req(a, 'episodeId'), 'scenes', req(a, 'sceneId'), 'clips', req(a, 'clipId'), 'video-urls'], a)),
+  cmd('video', 'delete-clip', '逻辑删除 clip', ['--project-group-no <no>', '--episode-id <id>', '--scene-id <id>', '--clip-id <id>'], (a) => post([...videoRoot(a), 'episodes', req(a, 'episodeId'), 'scenes', req(a, 'sceneId'), 'clips', req(a, 'clipId'), 'delete'])),
+];
+
+module.exports = { commands };