@lingjingai/lj-awb-cli-pre 0.3.15

package/packages/awb-core/src/output.js

@@ -0,0 +1,1189 @@
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function compactRecord(record) {
+  const result = {};
+  for (const [key, value] of Object.entries(record || {})) {
+    if (value === undefined || value === null || value === '') continue;
+    result[key] = value;
+  }
+  return result;
+}
+
+function commandPrefix() {
+  return process.env.LINGJING_AWB_COMMAND_PREFIX || 'lj-awb';
+}
+
+function rewriteCommandPrefix(value) {
+  if (typeof value !== 'string') return value;
+  return value.replace(/\blj-awb\b/g, commandPrefix());
+}
+
+function cleanNested(value) {
+  if (Array.isArray(value)) return value.map((item) => cleanNested(item));
+  if (!isPlainObject(value)) return rewriteCommandPrefix(value);
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (['updatedAt', 'updatedAtText'].includes(key)) continue;
+    if (item === undefined) continue;
+    result[key] = cleanNested(item);
+  }
+  return result;
+}
+
+function rewriteNested(value) {
+  if (Array.isArray(value)) return value.map((item) => rewriteNested(item));
+  if (!isPlainObject(value)) return rewriteCommandPrefix(value);
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (item === undefined) continue;
+    result[key] = rewriteNested(item);
+  }
+  return result;
+}
+
+function requestSummary(request = {}) {
+  const promptParams = request.promptParams || {};
+  return compactRecord({
+    requestSource: request.requestSource,
+    modelGroupCode: request.modelGroupCode,
+    projectGroupNo: request.projectGroupNo,
+    customBizId: request.customBizId,
+    prompt: promptParams.prompt,
+    ratio: promptParams.ratio,
+    quality: promptParams.quality,
+    duration: promptParams.duration,
+    needAudio: promptParams.need_audio,
+    generateNum: promptParams.generate_num,
+    resourceCount: Array.isArray(promptParams.resources) ? promptParams.resources.length : undefined,
+  });
+}
+
+function scalarRequestSummary(request = {}) {
+  if (!isPlainObject(request)) return {};
+  const result = {};
+  for (const [key, value] of Object.entries(request)) {
+    if (value === undefined || value === null || value === '') continue;
+    if (Array.isArray(value) || isPlainObject(value)) continue;
+    result[key] = value;
+  }
+  return result;
+}
+
+function scalarDataSummary(data = {}) {
+  if (!isPlainObject(data)) return {};
+  const excluded = new Set([
+    'request',
+    'files',
+    'assets',
+    'localFile',
+    'localFiles',
+    'results',
+    'raw',
+    'subject',
+    'upload',
+    'uploads',
+    'waited',
+    'data',
+  ]);
+  const result = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (excluded.has(key)) continue;
+    if (value === undefined || value === null || value === '') continue;
+    if (Array.isArray(value) || isPlainObject(value)) continue;
+    result[key] = value;
+  }
+  return result;
+}
+
+function normalizeAuthStatus(data = {}) {
+  return compactRecord({
+    configured: data.loginState === '已配置',
+    authType: data.authType,
+    accessKey: data.accessKey,
+    source: [data.accessKeySource, data.accessKeySourceName].filter(Boolean).join('/'),
+    verified: data.verified,
+    verification: data.verification,
+    verifyCommand: data.verifyCommand,
+    userId: data.user?.userId,
+    userName: data.user?.userName,
+    groupId: data.user?.groupId,
+    groupName: data.user?.groupName,
+    user: data.user,
+  });
+}
+
+function normalizeAuthLogin(data = {}) {
+  return compactRecord({
+    saved: data.saved ?? Boolean(data.auth || data.accessKey),
+    verified: data.verified,
+    accessKey: data.accessKey || data.auth?.accessKey,
+    source: data.auth ? [data.auth.accessKeySource, data.auth.accessKeySourceName].filter(Boolean).join('/') : undefined,
+    user: data.user,
+    dryRun: data.dryRun,
+  });
+}
+
+function normalizeDryRunResult(row = {}) {
+  if (!isPlainObject(row) || !row.dryRun) return cleanNested(row);
+  const localFiles = Array.isArray(row.localFiles) ? row.localFiles : (row.localFile ? [row.localFile] : []);
+  return compactRecord({
+    ...scalarDataSummary(row),
+    ...scalarRequestSummary(row.request),
+    ...requestSummary(row.request),
+    localFileCount: localFiles.length || undefined,
+    fileCount: Array.isArray(row.files) ? row.files.length : undefined,
+    assetCount: Array.isArray(row.assets) ? row.assets.length : undefined,
+  });
+}
+
+function normalizeDryRun(data = {}) {
+  const localFiles = Array.isArray(data.localFiles) ? data.localFiles : (data.localFile ? [data.localFile] : undefined);
+  const resourceConversions = Array.isArray(data.resourceConversions) ? data.resourceConversions : undefined;
+  return compactRecord({
+    dryRun: true,
+    action: data.action,
+    ...scalarDataSummary(data),
+    ...scalarRequestSummary(data.request),
+    ...requestSummary(data.request),
+    localFileCount: Array.isArray(localFiles) ? localFiles.length : undefined,
+    resourceConversionCount: Array.isArray(resourceConversions) ? resourceConversions.length : undefined,
+    resourceConversion: Array.isArray(resourceConversions) && resourceConversions.length === 1
+      ? `${resourceConversions[0].resource || 'resource'} ${resourceConversions[0].fromFormat}->${resourceConversions[0].toFormat}`
+      : undefined,
+    fileCount: Array.isArray(data.files) ? data.files.length : undefined,
+    assetCount: Array.isArray(data.assets) ? data.assets.length : undefined,
+    files: data.files,
+    assets: data.assets,
+    localFiles,
+    results: Array.isArray(data.results) ? data.results.map((row) => normalizeDryRunResult(row)) : data.results,
+    nextRefSubject: data.nextRefSubject,
+  });
+}
+
+function normalizeTaskSubmission(data = {}) {
+  return compactRecord({
+    taskId: data.taskId,
+    taskType: data.taskType,
+    modelGroupCode: data.modelGroupCode,
+    projectGroupNo: data.projectGroupNo,
+    pointNo: data.pointNo,
+    points: data.points ?? data.point ?? data.costPoint ?? data.estimatePoint,
+    pointCost: data.pointCost,
+    billingPointBalance: data.billingPointBalance ?? data.teamPointBalance,
+    billingPointRemainingAfter: data.billingPointRemainingAfter ?? data.teamPointRemainingAfter,
+    projectBudgetBalance: data.projectBudgetBalance ?? data.projectPointBalance,
+    projectBudgetMax: data.projectBudgetMax ?? data.projectPointMax,
+    projectBudgetRemainingAfter: data.projectBudgetRemainingAfter ?? data.projectPointRemainingAfter,
+    uploadCount: Array.isArray(data.uploads) ? data.uploads.length : undefined,
+    nextCommand: rewriteCommandPrefix(data.nextCommand),
+    waited: data.waited ? normalizeTaskStatus(data.waited) : undefined,
+  });
+}
+
+function normalizeSubtitleSubmission(data = {}) {
+  return compactRecord({
+    submitted: data.submitted,
+    remoteTaskId: data.remoteTaskId,
+    publicId: data.publicId,
+  });
+}
+
+function normalizeFee(data = {}) {
+  return compactRecord({
+    modelGroupCode: data.modelGroupCode,
+    projectGroupNo: data.projectGroupNo,
+    pointCost: data.pointCost,
+    billingPointBalance: data.billingPointBalance ?? data.teamPointBalance,
+    billingPointRemainingAfter: data.billingPointRemainingAfter ?? data.teamPointRemainingAfter,
+    projectBudgetBalance: data.projectBudgetBalance ?? data.projectPointBalance,
+    projectBudgetMax: data.projectBudgetMax ?? data.projectPointMax,
+    projectBudgetRemainingAfter: data.projectBudgetRemainingAfter ?? data.projectPointRemainingAfter,
+  });
+}
+
+function normalizeAccountInfo(data = {}) {
+  return compactRecord({
+    userId: data.userId,
+    userName: data.userName,
+    groupId: data.groupId,
+    groupName: data.groupName,
+    currentProjectGroupNo: data.currentProjectGroupNo,
+    currentProjectGroupName: data.currentProjectGroupName,
+    billingPointBalance: data.billingPointBalance ?? data.teamPointBalance,
+    projectBudgetBalance: data.projectBudgetBalance ?? data.projectPointBalance,
+    projectBudgetMax: data.projectBudgetMax ?? data.projectPointMax,
+  });
+}
+
+function normalizeCredits(data = {}) {
+  return compactRecord({
+    billingPointBalance: data.billingPointBalance ?? data.teamPointBalance,
+    currentProjectGroupNo: data.currentProjectGroupNo,
+    currentProjectGroupName: data.currentProjectGroupName,
+    projectBudgetBalance: data.projectBudgetBalance ?? data.projectPointBalance,
+    projectBudgetMax: data.projectBudgetMax ?? data.projectPointMax,
+  });
+}
+
+function normalizeProjectSummary(data = {}) {
+  return compactRecord({
+    selected: data.selected,
+    created: data.created,
+    updated: data.updated,
+    reused: data.reused,
+    projectGroupNo: data.projectGroupNo,
+    projectGroupName: data.projectGroupName,
+    isSelected: data.isSelected,
+    projectBudgetBalance: data.projectBudgetBalance ?? data.projectPointBalance,
+    projectBudgetMax: data.projectBudgetMax ?? data.projectPointMax,
+    memberCount: data.memberCount,
+  });
+}
+
+function normalizeCreditsUsage(data = {}) {
+  const buckets = isPlainObject(data.buckets)
+    ? Object.entries(data.buckets).map(([taskType, bucket]) => compactRecord({
+      taskType,
+      taskCount: bucket?.taskCount,
+      successTaskCount: bucket?.successTaskCount,
+      resultCount: bucket?.resultCount,
+      pointTotal: bucket?.pointTotal,
+    }))
+    : undefined;
+  return compactRecord({
+    projectGroupNo: data.projectGroupNo,
+    sinceMs: data.sinceMs,
+    sinceText: data.sinceText,
+    untilMs: data.untilMs,
+    untilText: data.untilText,
+    scannedTaskCount: data.scannedTaskCount,
+    pointTotal: data.pointTotal,
+    buckets,
+    tasks: data.tasks,
+  });
+}
+
+function normalizeTaskStatus(data = {}) {
+  return compactRecord({
+    taskId: data.taskId,
+    publicId: data.publicId,
+    remoteTaskId: data.remoteTaskId,
+    taskType: data.taskType,
+    taskStatus: data.taskStatus,
+    isTerminal: data.isTerminal,
+    modelGroupCode: data.modelGroupCode,
+    projectGroupNo: data.projectGroupNo,
+    pointNo: data.pointNo,
+    gmtCreate: data.gmtCreate,
+    resultCount: data.resultCount,
+    resultUrls: data.resultUrls,
+    originUrls: data.originUrls,
+    errorMessage: data.errorMessage,
+    timedOut: data.timedOut,
+    waitedMs: data.waitedMs,
+  });
+}
+
+function normalizeSubject(data = {}) {
+  return compactRecord({
+    created: data.created,
+    name: data.name,
+    elementId: data.elementId,
+    subjectId: data.subjectId,
+    externalId: data.externalId,
+    status: data.status,
+    nextRefSubject: data.nextRefSubject,
+  });
+}
+
+function normalizeAsset(data = {}) {
+  return compactRecord({
+    created: data.created,
+    updated: data.updated,
+    registered: data.registered,
+    groupId: data.groupId,
+    assetId: data.assetId,
+    name: data.name,
+    projectName: data.projectName,
+    assetPath: data.assetPath,
+    uploadBackendPath: data.upload?.backendPath,
+    uploadUrl: data.upload?.url,
+  });
+}
+
+function normalizeList(data = {}, keys) {
+  const key = keys.find((item) => Array.isArray(data[item]));
+  if (!key) return cleanNested(data);
+  return compactRecord({
+    count: data.count ?? data[key].length,
+    [key]: data[key],
+    ...Object.fromEntries(Object.entries(data).filter(([item]) => ![key, 'raw'].includes(item))),
+  });
+}
+
+function normalizeArtifactList(commandName, data) {
+  if (Array.isArray(data)) {
+    return compactRecord({ count: data.length, items: cleanNested(data) });
+  }
+  if (!isPlainObject(data)) return cleanNested(data);
+  const arrayKey = Object.keys(data).find((key) => Array.isArray(data[key]));
+  if (arrayKey) {
+    return compactRecord({
+      count: data.count ?? data[arrayKey].length,
+      [arrayKey]: cleanNested(data[arrayKey]),
+      ...Object.fromEntries(
+        Object.entries(data)
+          .filter(([key]) => key !== arrayKey && key !== 'raw')
+          .map(([key, value]) => [key, cleanNested(value)]),
+      ),
+    });
+  }
+  return cleanNested(data);
+}
+
+function normalizeArtifactRecord(data) {
+  if (!isPlainObject(data)) return cleanNested(data);
+  const out = compactRecord({
+    id: data.id,
+    projectId: data.projectId,
+    rowKind: data.rowKind,
+    entityKey: data.entityKey,
+    parentKey: data.parentKey,
+    sortOrder: data.sortOrder,
+    actorKey: data.actorKey,
+    propKey: data.propKey,
+    locationKey: data.locationKey,
+    stateKey: data.stateKey,
+    episodeId: data.episodeId,
+    sceneId: data.sceneId,
+    clipId: data.clipId,
+    videoEpisodeId: data.videoEpisodeId,
+    status: data.status,
+    title: data.title,
+    name: data.name,
+    displayName: data.displayName,
+    description: data.description,
+  });
+  for (const [key, value] of Object.entries(data)) {
+    if (key in out) continue;
+    if (Array.isArray(value)) out[`${key}Count`] = value.length;
+    else if (!isPlainObject(value)) out[key] = value;
+  }
+  return cleanNested(out);
+}
+
+function normalizeArtifactFull(data) {
+  if (!isPlainObject(data)) return cleanNested(data);
+  const out = compactRecord({
+    projectId: data.projectId,
+    id: data.id,
+    title: data.title,
+    status: data.status,
+  });
+  for (const [key, value] of Object.entries(data)) {
+    if (Array.isArray(value)) out[`${key}Count`] = value.length;
+    else if (isPlainObject(value)) {
+      const innerKey = Object.keys(value).find((k) => Array.isArray(value[k]));
+      if (innerKey) out[`${key}.${innerKey}Count`] = value[innerKey].length;
+    } else if (!(key in out)) out[key] = value;
+  }
+  return out;
+}
+
+function normalizeArtifactImport(data = {}) {
+  if (!isPlainObject(data)) return cleanNested(data);
+  return compactRecord({
+    imported: data.imported,
+    dryRun: data.dryRun,
+    action: data.action,
+    projectId: data.projectId,
+    sourceFile: data.sourceFile,
+    inputDir: data.inputDir,
+    inputFile: data.inputFile,
+    rowCount: data.rowCount,
+    actorCount: data.actorCount,
+    propCount: data.propCount,
+    locationCount: data.locationCount,
+    episodeCount: data.episodeCount,
+    sceneCount: data.sceneCount,
+    clipCount: data.clipCount,
+    batchCount: Array.isArray(data.batch) ? data.batch.length : undefined,
+    rowsByKind: data.rowsByKind,
+    files: isPlainObject(data.files)
+      ? compactRecord({
+          actors: data.files.actorsFile,
+          props: data.files.propsFile,
+          locations: data.files.locationsFile,
+        })
+      : undefined,
+  });
+}
+
+function normalizeArtifactWrite(data) {
+  if (!isPlainObject(data)) return cleanNested(data);
+  return normalizeArtifactRecord(data);
+}
+
+function normalizeArtifactDelete(data) {
+  if (!isPlainObject(data)) return cleanNested(data);
+  return compactRecord({
+    deleted: data.deleted ?? true,
+    action: data.action,
+    projectId: data.projectId,
+    key: data.key,
+    stateKey: data.stateKey,
+    episodeId: data.episodeId,
+    sceneId: data.sceneId,
+    clipId: data.clipId,
+    videoEpisodeId: data.videoEpisodeId,
+    rowKind: data.rowKind,
+    entityKey: data.entityKey,
+  });
+}
+
+function normalizeArtifactStatus(data) {
+  if (!isPlainObject(data)) return cleanNested(data);
+  return compactRecord({
+    updated: data.updated ?? true,
+    videoEpisodeId: data.videoEpisodeId ?? data.id,
+    status: data.status,
+    messageCount: Array.isArray(data.messages) ? data.messages.length : undefined,
+  });
+}
+
+export function normalizeOutputData(commandName, data) {
+  if (!isPlainObject(data)) return cleanNested(data);
+  switch (commandName) {
+    case 'auth status':
+    case 'auth verify':
+      return normalizeAuthStatus(data);
+    case 'auth login':
+      return normalizeAuthLogin(data);
+    default:
+      break;
+  }
+  if (data.dryRun) return normalizeDryRun(data);
+  switch (commandName) {
+    case 'image create':
+    case 'video create':
+      return normalizeTaskSubmission(data);
+    case 'video subtitle-remove':
+      return normalizeSubtitleSubmission(data);
+    case 'image fee':
+    case 'video fee':
+      return normalizeFee(data);
+    case 'account info':
+      return normalizeAccountInfo(data);
+    case 'credits balance':
+      return normalizeCredits(data);
+    case 'project current':
+    case 'project use':
+    case 'project create':
+    case 'project update':
+    case 'project ensure':
+      return normalizeProjectSummary(data);
+    case 'credits usage':
+      return normalizeCreditsUsage(data);
+    case 'image status':
+    case 'video status':
+    case 'task wait':
+    case 'video subtitle-status':
+      return normalizeTaskStatus(data);
+    case 'subject publish':
+    case 'subject wait':
+      return normalizeSubject(data);
+    case 'asset group-create':
+    case 'asset group-update':
+    case 'asset register':
+      return normalizeAsset(data);
+    case 'model image-models':
+    case 'model video-models':
+      return normalizeList(data, ['models', 'items', 'rows']);
+    case 'account teams':
+      return normalizeList(data, ['teams']);
+    case 'project list':
+      return normalizeList(data, ['projectGroups']);
+    case 'project users':
+      return normalizeList(data, ['users']);
+    case 'task list':
+      return normalizeList(data, ['tasks']);
+    case 'task records':
+      return normalizeList(data, ['records']);
+    case 'asset groups':
+      return normalizeList(data, ['groups']);
+    case 'asset match-actor':
+      return normalizeList(data, ['matches']);
+    case 'subject list':
+      return normalizeList(data, ['subjects']);
+    default:
+      break;
+  }
+  if (commandName?.startsWith('artifact ')) {
+    return normalizeArtifactByCommand(commandName, data);
+  }
+  return cleanNested(data);
+}
+
+const ARTIFACT_LIST_COMMANDS = new Set([
+  'artifact script rows',
+  'artifact script children',
+  'artifact asset actors',
+  'artifact asset props',
+  'artifact asset locations',
+  'artifact video episodes',
+  'artifact video scenes',
+  'artifact video clips',
+  'artifact clip episodes',
+]);
+
+const ARTIFACT_RECORD_COMMANDS = new Set([
+  'artifact script document',
+  'artifact script row',
+  'artifact asset actor',
+  'artifact asset prop',
+  'artifact asset location',
+  'artifact video episode',
+  'artifact video scene',
+  'artifact video clip',
+  'artifact clip episode',
+  'artifact clip episode-by-id',
+]);
+
+const ARTIFACT_FULL_COMMANDS = new Set([
+  'artifact script get',
+  'artifact asset get',
+  'artifact video get',
+  'artifact clip get',
+]);
+
+const ARTIFACT_IMPORT_COMMANDS = new Set([
+  'artifact script import',
+  'artifact asset import',
+  'artifact video import-storyboard',
+  'artifact clip upsert-batch',
+]);
+
+const ARTIFACT_WRITE_COMMANDS = new Set([
+  'artifact script upsert-row',
+  'artifact asset upsert-actor',
+  'artifact asset upsert-prop',
+  'artifact asset upsert-location',
+  'artifact asset upsert-actor-state',
+  'artifact asset upsert-prop-state',
+  'artifact asset upsert-location-state',
+  'artifact video upsert-episode',
+  'artifact video upsert-scene',
+  'artifact video upsert-clip',
+  'artifact video update-clip-urls',
+  'artifact clip upsert-episode',
+]);
+
+const ARTIFACT_DELETE_COMMANDS = new Set([
+  'artifact script delete-row',
+  'artifact asset delete-actor',
+  'artifact asset delete-prop',
+  'artifact asset delete-location',
+  'artifact asset delete-actor-state',
+  'artifact asset delete-prop-state',
+  'artifact asset delete-location-state',
+  'artifact video delete-episode',
+  'artifact video delete-scene',
+  'artifact video delete-clip',
+  'artifact clip delete-episode',
+]);
+
+function normalizeArtifactByCommand(commandName, data) {
+  if (ARTIFACT_LIST_COMMANDS.has(commandName)) return normalizeArtifactList(commandName, data);
+  if (ARTIFACT_RECORD_COMMANDS.has(commandName)) return normalizeArtifactRecord(data);
+  if (ARTIFACT_FULL_COMMANDS.has(commandName)) return normalizeArtifactFull(data);
+  if (ARTIFACT_IMPORT_COMMANDS.has(commandName)) return normalizeArtifactImport(data);
+  if (ARTIFACT_WRITE_COMMANDS.has(commandName)) return normalizeArtifactWrite(data);
+  if (ARTIFACT_DELETE_COMMANDS.has(commandName)) return normalizeArtifactDelete(data);
+  if (commandName === 'artifact clip update-status') return normalizeArtifactStatus(data);
+  return cleanNested(data);
+}
+
+export function normalizeJsonData(commandName, data) {
+  if (!isPlainObject(data)) return rewriteNested(data);
+  if (data.dryRun) return rewriteNested(data);
+  return normalizeOutputData(commandName, data);
+}
+
+function shortValue(value) {
+  if (Array.isArray(value)) {
+    if (value.every((item) => !isPlainObject(item) && !Array.isArray(item))) return valueList(value, 8) || '[]';
+    return `[${value.length}]`;
+  }
+  if (isPlainObject(value)) return '{...}';
+  const text = String(value);
+  if (/\s/.test(text)) return JSON.stringify(text.length > 96 ? `${text.slice(0, 93)}...` : text);
+  return text.length > 120 ? `${text.slice(0, 117)}...` : text;
+}
+
+function valueList(values, limit = 12) {
+  if (!Array.isArray(values) || !values.length) return undefined;
+  const items = values
+    .map((item) => {
+      if (!isPlainObject(item)) return item;
+      return item.enumValue ?? item.value ?? item.label ?? item.enumName ?? item.name;
+    })
+    .filter((item) => item !== undefined && item !== null && item !== '');
+  if (!items.length) return undefined;
+  const visible = items.slice(0, limit).join('|');
+  return items.length > limit ? `${visible}|...(+${items.length - limit})` : visible;
+}
+
+function renderRecord(record, preferredKeys = [], excludedKeys = []) {
+  const excluded = new Set(excludedKeys);
+  const keys = [
+    ...preferredKeys.filter((key) => !excluded.has(key) && record[key] !== undefined),
+    ...Object.keys(record).filter((key) => !excluded.has(key) && !preferredKeys.includes(key) && !Array.isArray(record[key]) && !isPlainObject(record[key])),
+  ];
+  return keys.map((key) => `${key}=${shortValue(record[key])}`).join(' ');
+}
+
+function firstList(data) {
+  for (const [key, value] of Object.entries(data || {})) {
+    if (['resultUrls', 'originUrls'].includes(key)) continue;
+    if (Array.isArray(value)) return { key, rows: value };
+  }
+  return null;
+}
+
+function rowSummary(row) {
+  if (!isPlainObject(row)) return shortValue(row);
+  const keys = [
+    'id',
+    'taskId',
+    'publicId',
+    'remoteTaskId',
+    'taskType',
+    'modelGroupCode',
+    'provider',
+    'displayName',
+    'modelStatus',
+    'taskQueueNum',
+    'feeCalcType',
+    'inputModes',
+    'params',
+    'name',
+    'status',
+    'message',
+    'title',
+    'description',
+    'groupId',
+    'groupName',
+    'projectGroupNo',
+    'projectGroupName',
+    'projectId',
+    'isSelected',
+    'userId',
+    'userName',
+    'role',
+    'isCheck',
+    'currentGroup',
+    'dryRun',
+    'action',
+    'created',
+    'updated',
+    'registered',
+    'imported',
+    'submitted',
+    'selected',
+    'reused',
+    'cleared',
+    'memberCount',
+    'taskStatus',
+    'taskCount',
+    'successTaskCount',
+    'pointTotal',
+    'billingPointBalance',
+    'billingPointRemainingAfter',
+    'projectBudgetBalance',
+    'projectBudgetMax',
+    'projectBudgetRemainingAfter',
+    'projectPointBalance',
+    'projectPointMax',
+    'teamPointBalance',
+    'assetId',
+    'assetKind',
+    'assetKey',
+    'assetName',
+    'actorKey',
+    'propKey',
+    'locationKey',
+    'stateKey',
+    'stateName',
+    'partType',
+    'score',
+    'imageUrl',
+    'subjectId',
+    'elementId',
+    'externalId',
+    'label',
+    'assetPath',
+    'isPrimary',
+    'referenceType',
+    'resultCount',
+    'promptSummary',
+    'recordedAt',
+    'gmtCreate',
+    'gmtModified',
+    'createdAt',
+    'filePath',
+    'fileName',
+    'exists',
+    'size',
+    'mime',
+    'mimeType',
+    'width',
+    'height',
+    'format',
+    'backendPath',
+    'url',
+    'sceneType',
+    'projectName',
+    'inputIndex',
+    'rowKind',
+    'entityKey',
+    'parentKey',
+    'revisionNo',
+    'sortOrder',
+    'schemaVersion',
+    'speakerKey',
+    'episodeKey',
+    'episodeId',
+    'episodeNo',
+    'episodeTitle',
+    'sceneKey',
+    'sceneId',
+    'sceneNo',
+    'clipId',
+    'expectedDuration',
+    'completePrompt',
+    'key',
+    'sourceFile',
+    'inputDir',
+    'rowCount',
+    'actorCount',
+    'propCount',
+    'locationCount',
+    'sceneCount',
+    'clipCount',
+    'requestSource',
+    'prompt',
+    'ratio',
+    'quality',
+    'duration',
+    'needAudio',
+    'generateNum',
+    'resourceCount',
+    'paramKey',
+    'cliArg',
+    'paramName',
+    'paramType',
+    'meaning',
+  ];
+  return keys
+    .filter((key) => {
+      const value = row[key];
+      if (value === undefined || value === null || value === '') return false;
+      if (Array.isArray(value) && value.length === 0) return false;
+      return true;
+    })
+    .map((key) => `${key}=${shortValue(row[key])}`)
+    .join(' ');
+}
+
+function textSources(values = []) {
+  const names = {
+    local_file: 'file',
+    http_url: 'url',
+    backendPath: 'platformPath',
+    asset_id: 'asset',
+  };
+  return valueList((Array.isArray(values) ? values : []).map((item) => names[item] || item));
+}
+
+function textFileCount(item = {}) {
+  if (item.minFiles != null && item.maxFiles != null && item.minFiles === item.maxFiles) return String(item.maxFiles);
+  if (item.minFiles != null && item.maxFiles != null) return `${item.minFiles}..${item.maxFiles}`;
+  if (item.maxFiles != null) return `<=${item.maxFiles}`;
+  if (item.minFiles != null) return `>=${item.minFiles}`;
+  return undefined;
+}
+
+function textDurationRange(item = {}) {
+  if (item.minDurationMs != null && item.maxDurationMs != null) return `${item.minDurationMs}..${item.maxDurationMs}`;
+  if (item.maxDurationMs != null) return `<=${item.maxDurationMs}`;
+  if (item.minDurationMs != null) return `>=${item.minDurationMs}`;
+  return undefined;
+}
+
+function textItemCount(item = {}) {
+  if (item.minItems != null && item.maxItems != null && item.minItems === item.maxItems) return String(item.maxItems);
+  if (item.minItems != null && item.maxItems != null) return `${item.minItems}..${item.maxItems}`;
+  if (item.maxItems != null) return `<=${item.maxItems}`;
+  if (item.minItems != null) return `>=${item.minItems}`;
+  return undefined;
+}
+
+function textAllowValues(values = []) {
+  return Array.isArray(values) && values.length ? valueList(values) : '<none>';
+}
+
+function textConditionValue(value) {
+  if (value === '__NOT_EMPTY__') return 'present';
+  if (value === '__EMPTY__') return 'empty';
+  return value;
+}
+
+function textConstraintConditions(conditions = []) {
+  if (!Array.isArray(conditions) || !conditions.length) return undefined;
+  return conditions
+    .map((item) => {
+      const key = item.key || item.configCode;
+      return key ? `${key}=${textConditionValue(item.value)}` : null;
+    })
+    .filter(Boolean)
+    .join('&');
+}
+
+const NORMAL_IMAGE_FORMATS = ['jpg', 'jpeg', 'png', 'jfif'];
+
+function textImageFormats(item = {}) {
+  const policy = String(item.formatPolicy || '');
+  if (policy === 'normal_plus_webp') return valueList([...NORMAL_IMAGE_FORMATS, 'webp']);
+  if (policy === 'normal_without_webp') return valueList(NORMAL_IMAGE_FORMATS);
+  return valueList(item.fileTypes);
+}
+
+function textResourceFormats(item = {}) {
+  if (item.mediaType === 'IMAGE') return textImageFormats(item);
+  return valueList(item.fileTypes);
+}
+
+function textWebpInput(item = {}) {
+  if (item.mediaType !== 'IMAGE') return undefined;
+  const policy = String(item.formatPolicy || '');
+  if (policy === 'normal_plus_webp') return 'accepted';
+  if (policy === 'normal_without_webp') return item.autoConvertTo ? `autoConvertTo${String(item.autoConvertTo).toUpperCase()}` : 'unsupported';
+  return undefined;
+}
+
+function textResourceAutoConvert(item = {}) {
+  if (item.mediaType === 'IMAGE' && ['normal_plus_webp', 'normal_without_webp'].includes(String(item.formatPolicy || ''))) return undefined;
+  return item.autoConvertTo;
+}
+
+function formatModelOptionsOutput(data = {}) {
+  const params = Array.isArray(data.params) ? data.params : [];
+  const resources = Array.isArray(data.resources) ? data.resources : [];
+  const constraints = Array.isArray(data.constraints) ? data.constraints : [];
+  const lines = ['ok model options'];
+  lines.push(renderRecord(compactRecord({
+    modelGroupCode: data.modelGroupCode,
+    taskKind: data.taskKind,
+  }), ['modelGroupCode', 'taskKind']));
+  lines.push(`params.count=${params.length}`);
+  for (const [index, param] of params.entries()) {
+    lines.push(`param[${index}]: ${renderRecord(compactRecord({
+      key: param.key,
+      type: param.valueType,
+      values: valueList(param.values),
+      default: param.defaultValue,
+      maxLength: param.maxLength,
+      required: param.required,
+    }), ['key', 'type', 'values', 'default', 'maxLength', 'required'])}`);
+  }
+  if (resources.length) {
+    lines.push(`resources.count=${resources.length}`);
+    for (const [index, item] of resources.entries()) {
+      lines.push(`resource[${index}]: ${renderRecord(compactRecord({
+        mode: item.mode,
+        media: item.mediaType,
+        usage: item.usage,
+        sources: textSources(item.sources),
+        formats: textResourceFormats(item),
+        webpInput: textWebpInput(item),
+        autoConvert: textResourceAutoConvert(item),
+        files: textFileCount(item),
+        maxSizeKB: item.maxSizeKB,
+        durationMs: textDurationRange(item),
+        totalDurationMs: item.maxTotalDurationMs != null ? `<=${item.maxTotalDurationMs}` : undefined,
+        items: textItemCount(item),
+        maxPromptLength: item.maxPromptLength,
+        lastFrameOnly: item.supportLastFrameOnly,
+      }), [
+        'mode',
+        'media',
+        'usage',
+        'sources',
+        'formats',
+        'webpInput',
+        'autoConvert',
+        'files',
+        'maxSizeKB',
+        'durationMs',
+        'totalDurationMs',
+        'items',
+        'maxPromptLength',
+        'lastFrameOnly',
+      ])}`);
+    }
+  }
+  if (constraints.length) {
+    lines.push(`constraints.count=${constraints.length}`);
+    for (const [index, item] of constraints.entries()) {
+      lines.push(`constraint[${index}]: ${renderRecord(compactRecord({
+        target: item.target,
+        targetConfig: item.targetConfigCode && item.targetConfigCode !== item.target ? item.targetConfigCode : undefined,
+        allowedValues: textAllowValues(item.allowValues),
+        when: textConstraintConditions(item.conditions),
+        effect: item.effect,
+        priority: item.priority,
+        name: item.name,
+      }), ['target', 'targetConfig', 'allowedValues', 'when', 'effect', 'priority', 'name'])}`);
+    }
+  }
+  return `${lines.join('\n')}\n`;
+}
+
+function textKeyBinding(value) {
+  if (value === 'key_required') return 'required';
+  if (value === 'optional_key') return 'optional';
+  if (value === 'none') return 'none';
+  return value;
+}
+
+function formatModelCreateSpecOutput(data = {}) {
+  const intents = Array.isArray(data.supportedIntents) ? data.supportedIntents : [];
+  const examples = Array.isArray(data.examples) ? data.examples : [];
+  const lines = ['ok model create-spec'];
+  lines.push(renderRecord(compactRecord({
+    modelGroupCode: data.modelGroupCode,
+    taskKind: data.taskKind,
+    create: data.createCommand,
+    fee: data.feeCommand,
+    statusTaskType: data.statusCommandTaskType,
+  }), ['modelGroupCode', 'taskKind', 'create', 'fee', 'statusTaskType']));
+  lines.push(renderRecord(compactRecord({
+    input: data.inputRequirement?.summary,
+    acceptedModes: valueList(data.inputRequirement?.acceptedModes),
+  }), ['input', 'acceptedModes']));
+  lines.push(`intents.count=${intents.length}`);
+  for (const [index, intent] of intents.entries()) {
+    lines.push(`intent[${index}]: ${renderRecord(compactRecord({
+      mode: intent.mode,
+      intent: intent.intent,
+      args: valueList(intent.requiredArgs),
+      usage: valueList(intent.resourceUsages),
+      resources: valueList(intent.resourceSyntax),
+      key: textKeyBinding(intent.promptBinding),
+    }), ['mode', 'intent', 'args', 'usage', 'resources', 'key'])}`);
+  }
+  if (examples.length) {
+    lines.push(`examples.count=${examples.length}`);
+    for (const [index, example] of examples.entries()) lines.push(`example[${index}]=${example}`);
+  }
+  if (data.optionsCommand) lines.push(`options=${commandPrefix()} ${data.optionsCommand}`);
+  return `${lines.join('\n')}\n`;
+}
+
+function formatGuideTableRows(rows = []) {
+  return (Array.isArray(rows) ? rows : []).map((item, index) => {
+    const values = valueList(item.values);
+    return `field[${index}]: ${renderRecord(compactRecord({
+      name: item.field,
+      values,
+      desc: item.description,
+    }), ['name', 'values', 'desc'])}`;
+  });
+}
+
+function formatModelInputGuideOutput(data = {}) {
+  const lines = ['ok model input-guide'];
+  lines.push('commonFields.count=' + (Array.isArray(data.commonFields) ? data.commonFields.length : 0));
+  lines.push(...formatGuideTableRows(data.commonFields));
+  lines.push('resourceFields.count=' + (Array.isArray(data.resourceFields) ? data.resourceFields.length : 0));
+  lines.push(...formatGuideTableRows(data.resourceFields));
+  const rules = Array.isArray(data.resourceRules) ? data.resourceRules : [];
+  if (rules.length) {
+    lines.push(`resourceRules.count=${rules.length}`);
+    for (const [index, rule] of rules.entries()) lines.push(`rule[${index}]=${rule}`);
+  }
+  const referenceKeyGuide = Array.isArray(data.referenceKeyGuide) ? data.referenceKeyGuide : [];
+  if (referenceKeyGuide.length) {
+    lines.push(`referenceKey.count=${referenceKeyGuide.length}`);
+    for (const [index, item] of referenceKeyGuide.entries()) lines.push(`referenceKey[${index}]=${item}`);
+  }
+  return `${lines.join('\n')}\n`;
+}
+
+function defaultJsonCommand(commandName) {
+  return `${commandPrefix()} ${commandName} -f json`;
+}
+
+function modelListNextCommand(commandName) {
+  if (commandName === 'model image-models' || commandName === 'model video-models') {
+    return `${commandPrefix()} model options --model-group-code <modelGroupCode>`;
+  }
+  return null;
+}
+
+function statusNextCommand(commandName, normalized) {
+  if (!isPlainObject(normalized) || normalized.isTerminal !== false || !normalized.taskId) return null;
+  const taskType = normalized.taskType || (commandName === 'video status' ? 'VIDEO_GROUP' : 'IMAGE_CREATE');
+  return `${commandPrefix()} task wait --task-id ${normalized.taskId} --task-type ${taskType} --wait-seconds 180`;
+}
+
+function subtitleRemoveNextCommand(commandName, normalized) {
+  if (commandName !== 'video status' && commandName !== 'task wait') return null;
+  if (!Array.isArray(normalized.originUrls) || !normalized.originUrls.length) return null;
+  return `${commandPrefix()} video subtitle-remove --video-url <originUrl[0]> --dry-run`;
+}
+
+export function formatTextOutput(commandName, data, context = {}) {
+  if (commandName === 'model options') return formatModelOptionsOutput(data);
+  if (commandName === 'model create-spec') return formatModelCreateSpecOutput(data);
+  if (commandName === 'model input-guide') return formatModelInputGuideOutput(data);
+  const normalized = normalizeOutputData(commandName, data);
+  if (!isPlainObject(normalized)) return `ok ${commandName}\nvalue=${shortValue(normalized)}\n`;
+  const lines = [`ok ${commandName}`];
+  const list = firstList(normalized);
+  const isModelList = commandName === 'model image-models' || commandName === 'model video-models';
+  const scalarLine = renderRecord(
+    normalized,
+    [
+      'configured',
+      'accessKey',
+      'verified',
+      'verification',
+      'verifyCommand',
+      'userId',
+      'userName',
+      'doctorStatus',
+      'taskId',
+      'publicId',
+      'remoteTaskId',
+      'pointNo',
+      'taskType',
+      'taskStatus',
+      'modelGroupCode',
+      'projectGroupNo',
+      'projectId',
+      'groupId',
+      'groupName',
+      'assetId',
+      'elementId',
+      'externalId',
+      'status',
+      'imported',
+      'updated',
+      'deleted',
+      'sourceFile',
+      'inputDir',
+      'inputFile',
+      'count',
+      'rowCount',
+      'actorCount',
+      'propCount',
+      'locationCount',
+      'episodeCount',
+      'sceneCount',
+      'clipCount',
+      'batchCount',
+      'id',
+      'videoEpisodeId',
+      'episodeId',
+      'rowKind',
+      'entityKey',
+      'parentKey',
+      'assetKind',
+      'assetKey',
+      'actorKey',
+      'propKey',
+      'locationKey',
+      'stateKey',
+      'sceneId',
+      'clipId',
+      'name',
+      'displayName',
+      'title',
+      'resultCount',
+      'resourceConversionCount',
+      'resourceConversion',
+      'pointCost',
+      'billingPointBalance',
+      'billingPointRemainingAfter',
+      'projectBudgetBalance',
+      'projectBudgetMax',
+      'projectBudgetRemainingAfter',
+      'pointTotal',
+      'dryRun',
+      'action',
+    ],
+    ['nextCommand', 'nextRefSubject', ...(list ? ['count'] : []), ...(isModelList ? ['usage'] : [])],
+  );
+  if (scalarLine) lines.push(scalarLine);
+  if (list) {
+    const total = list.rows.length;
+    lines.push(`${list.key}.count=${total}`);
+    const configuredLimit = context.listLimit === Number.POSITIVE_INFINITY
+      ? list.rows.length
+      : (Number.isFinite(context.listLimit) ? context.listLimit : 8);
+    const visibleLimit = Math.max(0, configuredLimit);
+    const visibleRows = list.rows.slice(0, visibleLimit);
+    for (const [index, row] of visibleRows.entries()) {
+      const summary = rowSummary(row);
+      if (summary) lines.push(`${list.key}[${index}]: ${summary}`);
+      if (isPlainObject(row) && Array.isArray(row.resultUrls)) {
+        for (const [urlIndex, url] of row.resultUrls.slice(0, 2).entries()) lines.push(`${list.key}[${index}].resultUrl[${urlIndex}]=${url}`);
+      }
+      if (isPlainObject(row) && Array.isArray(row.originUrls)) {
+        for (const [urlIndex, url] of row.originUrls.slice(0, 2).entries()) lines.push(`${list.key}[${index}].originUrl[${urlIndex}]=${url}`);
+      }
+    }
+    if (total > visibleRows.length) {
+      lines.push(`${list.key}.more=${total - visibleRows.length}`);
+      lines.push(`moreCommand=${context.moreCommand || context.jsonCommand || defaultJsonCommand(commandName)}`);
+    }
+  }
+  if (normalized.nextCommand) lines.push(`next=${normalized.nextCommand}`);
+  if (normalized.nextRefSubject) lines.push(`nextRefSubject=${normalized.nextRefSubject}`);
+  if (normalized.dryRun && context.confirmCommand) lines.push(`nextAfterConfirm=${context.confirmCommand}`);
+  if (normalized.dryRun && !context.confirmCommand && context.executeCommand) lines.push(`next=${context.executeCommand}`);
+  const modelNext = modelListNextCommand(commandName);
+  if (modelNext) lines.push(`next=${modelNext}`);
+  const waitNext = statusNextCommand(commandName, normalized);
+  if (waitNext) lines.push(`next=${waitNext}`);
+  const subtitleNext = subtitleRemoveNextCommand(commandName, normalized);
+  if (subtitleNext) lines.push(`nextSubtitleRemove=${subtitleNext}`);
+  if (Array.isArray(normalized.resultUrls)) {
+    for (const [index, url] of normalized.resultUrls.slice(0, 3).entries()) lines.push(`resultUrl[${index}]=${url}`);
+  }
+  if (Array.isArray(normalized.originUrls)) {
+    for (const [index, url] of normalized.originUrls.slice(0, 3).entries()) lines.push(`originUrl[${index}]=${url}`);
+  }
+  return `${lines.join('\n')}\n`;
+}
+
+export function formatTextError(error) {
+  const lines = [`error type=${error.type || 'error'}`, `message=${JSON.stringify(error.message || String(error))}`];
+  if (error.hint) lines.push(`hint=${JSON.stringify(rewriteCommandPrefix(error.hint))}`);
+  if (isPlainObject(error.details)) {
+    const payload = isPlainObject(error.details.payload) ? error.details.payload : {};
+    const detailLine = renderRecord(compactRecord({
+      status: error.details.status ?? payload.status,
+      code: error.details.code ?? payload.code,
+      msg: error.details.msg ?? payload.msg ?? payload.message,
+      traceId: error.details.traceId ?? payload.traceId,
+      causeCode: error.details.causeCode,
+      unknownOptions: Array.isArray(error.details.unknownOptions) ? error.details.unknownOptions.join(',') : undefined,
+    }), ['status', 'code', 'msg', 'traceId', 'causeCode', 'unknownOptions']);
+    if (detailLine) lines.push(`details ${detailLine}`);
+  }
+  return `${lines.join('\n')}\n`;
+}