tripo-cli 0.7.3 → 0.8.1

package/dist/commands/batch.js

@@ -1,6 +1,8 @@
 /**
  * `tripo batch run <manifest.yaml>` — bulk production with concurrency,
  * retries, and resumable state (skip jobs already succeeded on re-run).
+ * A job is never resubmitted once a paid task may exist for it: such jobs
+ * stop as needs_attention instead of retrying.
  *
  * Manifest:
  *   concurrency: 2
@@ -14,10 +16,10 @@
  */
 import { readFileSync, writeFileSync } from 'node:fs';
 import { resolve } from 'node:path';
+import pc from 'picocolors';
 import { parse as parseYaml } from 'yaml';
-import { UsageError } from '../core/errors.js';
-import { emitResult, errorLine, log, success } from '../core/output.js';
-import { t } from '../i18n.js';
+import { CliError, TaskFailedError, UsageError } from '../core/errors.js';
+import { emitResult, errorLine, log, success, warn } from '../core/output.js';
 import { parseThenExpression } from '../knowledge/chains.js';
 import { executeMake, planMake } from '../pipeline/make.js';
 import { newClient } from './shared.js';
@@ -27,7 +29,7 @@ export function registerBatchCommand(program) {
         .command('run <manifest>')
         .description('run all jobs (resumable: finished jobs are skipped on re-run)')
         .option('--concurrency <n>', 'parallel jobs (default from manifest or 2)', (v) => Number(v))
-        .option('--retries <n>', 'retries per failed job', (v) => Number(v), 1)
+        .option('--retries <n>', 'retries per failed job (only when no paid task was left behind)', (v) => Number(v), 1)
         .option('--fresh', 'ignore previous state and re-run everything')
         .action(async (manifestPath, opts) => {
         const absPath = resolve(manifestPath);
@@ -46,12 +48,17 @@ export function registerBatchCommand(program) {
             seen.add(key);
         }
         const concurrency = Math.max(1, opts.concurrency ?? manifest.concurrency ?? 2);
-        const queue = jobs.filter(({ key }) => state.jobs[key]?.status !== 'success');
-        const skipped = jobs.length - queue.length;
+        const queue = jobs.filter(({ key }) => state.jobs[key]?.status !== 'success' && state.jobs[key]?.status !== 'needs_attention');
+        const attention = jobs.filter(({ key }) => state.jobs[key]?.status === 'needs_attention');
+        const skipped = jobs.length - queue.length - attention.length;
         if (skipped > 0) {
-            log(t({ zh: `跳过 ${skipped} 个已完成任务(断点续跑)`, en: `skipping ${skipped} already-finished job(s) (resume)` }));
+            log(`skipping ${skipped} already-finished job(s) (resume)`);
         }
-        log(t({ zh: `批量执行 ${queue.length} 个任务,并发 ${concurrency}`, en: `running ${queue.length} job(s), concurrency ${concurrency}` }));
+        for (const { key } of attention) {
+            const ids = (state.jobs[key].tasks ?? []).map((t) => t.task_id).join(', ') || 'unknown';
+            warn(`[${key}] needs attention, not resubmitted (tasks: ${ids}); delete its entry in ${statePath} or use --fresh to run it again`);
+        }
+        log(`running ${queue.length} job(s), concurrency ${concurrency}`);
         const client = newClient();
         let cursor = 0;
         const runNext = async () => {
@@ -64,20 +71,34 @@ export function registerBatchCommand(program) {
                 const maxAttempts = 1 + opts.retries;
                 for (let attempt = jobState.attempts + 1; attempt <= maxAttempts; attempt++) {
                     jobState.attempts = attempt;
+                    const created = [];
                     try {
-                        const outcome = await runJob(client, item.key, item.spec);
+                        const outcome = await runJob(client, item.key, item.spec, (task) => {
+                            created.push(task);
+                            (jobState.tasks ??= []).push(task);
+                            saveState(statePath, state);
+                        });
                         jobState.status = 'success';
                         jobState.task_id = outcome.taskId;
                         jobState.output_dir = outcome.outputDir;
                         delete jobState.error;
+                        delete jobState.suggestion;
                         success(`[${item.key}] done${outcome.outputDir ? ` → ${outcome.outputDir}` : ''}`);
                         break;
                     }
                     catch (err) {
                         const message = err instanceof Error ? err.message : String(err);
-                        jobState.status = 'failed';
+                        const retryable = mayRetry(err, created);
+                        jobState.status = retryable ? 'failed' : 'needs_attention';
                         jobState.error = message;
-                        errorLine(`[${item.key}] attempt ${attempt}/${maxAttempts} failed: ${message}`);
+                        jobState.suggestion = retryable
+                            ? err instanceof CliError ? err.suggestion : undefined
+                            : attentionSuggestion(err, jobState.tasks ?? []);
+                        errorLine(`[${item.key}] attempt ${attempt}/${maxAttempts} failed${retryable ? '' : ' (needs attention: a paid task may exist, not retried)'}: ${message}`);
+                        if (jobState.suggestion)
+                            process.stderr.write(pc.dim(`  → ${jobState.suggestion}\n`));
+                        if (!retryable)
+                            break;
                     }
                     finally {
                         saveState(statePath, state);
@@ -90,19 +111,18 @@ export function registerBatchCommand(program) {
             total: jobs.length,
             success: Object.values(state.jobs).filter((j) => j.status === 'success').length,
             failed: Object.values(state.jobs).filter((j) => j.status === 'failed').length,
+            needs_attention: Object.values(state.jobs).filter((j) => j.status === 'needs_attention').length,
             state_file: statePath,
             jobs: state.jobs,
         };
-        const failed = summary.failed;
-        emitResult(summary, t({
-            zh: `批量完成: 成功 ${summary.success}/${summary.total}${failed ? `,失败 ${failed}(重跑同一命令续跑)` : ''}`,
-            en: `batch finished: ${summary.success}/${summary.total} succeeded${failed ? `, ${failed} failed (re-run the same command to resume)` : ''}`,
-        }));
-        if (failed > 0)
+        const { failed, needs_attention: needsAttention } = summary;
+        emitResult(summary, `batch finished: ${summary.success}/${summary.total} succeeded${failed ? `, ${failed} failed (re-run the same command to resume)` : ''}` +
+            `${needsAttention ? `, ${needsAttention} need attention (never resubmitted automatically; see "suggestion" in ${statePath})` : ''}`);
+        if (failed > 0 || needsAttention > 0)
             process.exitCode = 6;
     });
 }
-async function runJob(client, key, spec) {
+async function runJob(client, key, spec, onTaskCreated) {
     const inputs = spec.inputs ?? (spec.input !== undefined ? [spec.input] : []);
     if (inputs.length === 0)
         throw new UsageError(`job "${key}" has no input`);
@@ -115,12 +135,32 @@ async function runJob(client, key, spec) {
         params: spec.params ?? {},
         name: spec.name ?? key,
         outDir: spec.out,
+        onTaskCreated,
     };
     const plan = await planMake(client, options);
     const outcome = await executeMake(client, plan, options);
     const finalResult = outcome.chainResults[outcome.chainResults.length - 1] ?? outcome.primary;
     return { taskId: finalResult.task_id, outputDir: finalResult.output_dir ?? outcome.primary.output_dir };
 }
+/**
+ * Retrying is safe only when the failed attempt left no billed or still-running
+ * task behind: it failed before anything was submitted, or its only task failed
+ * server-side (failed/cancelled tasks are refunded).
+ */
+function mayRetry(err, created) {
+    if (created.length === 0)
+        return !(err instanceof CliError && err.submissionUncertain);
+    return (created.length === 1 &&
+        err instanceof TaskFailedError &&
+        err.taskId === created[0].task_id &&
+        (err.status === 'failed' || err.status === 'cancelled'));
+}
+function attentionSuggestion(err, tasks) {
+    if (err instanceof CliError && err.suggestion)
+        return err.suggestion;
+    const list = tasks.map((t) => `${t.task_id} (${t.type})`).join(', ');
+    return `paid tasks already exist for this job: ${list}; do not rerun the whole job, continue from the last successful one (tripo make <task_id> --then <remaining steps>)`;
+}
 function loadManifest(path) {
     let raw;
     try {

package/dist/commands/completion.js

@@ -2,7 +2,7 @@
 import { UsageError } from '../core/errors.js';
 import { isMeshEditEnabled } from '../knowledge/chains.js';
 const COMMANDS = [
-    'login', 'logout', 'whoami', 'use', 'balance', 'usage', 'topup',
+    'login', 'logout', 'whoami', 'use', 'balance', 'usage', 'models', 'topup',
     'make', 'view', 'redo', 'ai',
     'generate', 'model', 'anim', 'mesh', 'task', 'files', 'batch', 'history',
     'config', 'doctor', 'update', 'docs', 'completion', 'mcp',

package/dist/commands/config-cmd.js

@@ -7,7 +7,7 @@ import { coerceValue } from './shared.js';
 /** Account-bound settings — these live in the *active profile*. */
 const PROFILE_SETTABLE = new Set(['region', 'api_base_url', 'platform_base_url']);
 /** User preferences — top-level, shared by all profiles. */
-const GLOBAL_SETTABLE = new Set(['language', 'default_output_dir', 'llm.base_url', 'llm.api_key', 'llm.model']);
+const GLOBAL_SETTABLE = new Set(['default_output_dir', 'llm.base_url', 'llm.api_key', 'llm.model']);
 const SETTABLE = [...PROFILE_SETTABLE, ...GLOBAL_SETTABLE];
 export function registerConfigCommands(program) {
     const config = program.command('config').description('global config (~/.tripo) and directory context (.tripo)');

package/dist/commands/doctor.js

@@ -2,7 +2,7 @@
 import { statSync } from 'node:fs';
 import { join } from 'node:path';
 import pc from 'picocolors';
-import { configFileExists, describeKeySource, listProfiles, loadConfig, resolveApiBaseUrl, resolveApiKey, resolveRegion, tripoHome } from '../config/config.js';
+import { configFileExists, describeKeySource, listProfiles, resolveApiBaseUrl, resolveApiKey, resolveRegion, tripoHome } from '../config/config.js';
 import { TripoClient } from '../core/client.js';
 import { CliError } from '../core/errors.js';
 import { detectRegionForKey } from '../core/region.js';
@@ -93,8 +93,6 @@ export function registerDoctorCommand(program) {
             detail: `${process.stdout.isTTY ? 'interactive TTY' : 'non-TTY (headless mode)'}${terminalSupportsInlineImages() ? ' · inline images supported' : ''}`,
             critical: false,
         });
-        const language = loadConfig().language ?? 'auto';
-        checks.push({ name: 'language', ok: true, detail: language, critical: false });
         const failedCritical = checks.some((c) => c.critical && !c.ok);
         const human = checks
             .map((c) => `${c.ok ? pc.green('✓') : c.critical ? pc.red('✗') : pc.yellow('!')} ${c.name.padEnd(34)} ${c.detail}`)

package/dist/commands/generate.js

@@ -3,7 +3,7 @@ import { UsageError } from '../core/errors.js';
 import { warn } from '../core/output.js';
 import { buildEditMultiview, buildImageToImage, buildImageToModel, buildImageToMultiview, buildImageToSplat, buildMultiviewToModel, buildTextToImage, buildTextToModel, } from '../core/requests.js';
 import { resolveInputValue, runTask } from '../core/task-service.js';
-import { chooseModel } from '../knowledge/models.js';
+import { chooseModel, detectDenseGeometryIntent, detectLowPolyIntent, detectRealtimeIntent } from '../knowledge/models.js';
 import { assignViews } from '../pipeline/make.js';
 import { detectInput } from '../util/input-detect.js';
 import { newClient, printTaskResult, withTaskOptions } from './shared.js';
@@ -39,16 +39,43 @@ export function registerGenerateCommands(program) {
     };
     add('text-to-model', 'text → 3D model', 'prompt', async (_c, inputs, flags) => {
         const prompt = inputs.join(' ');
-        const { model } = chooseModel({ explicit: flags.model, faceLimit: numberParam(flags, 'face_limit') });
+        const { model } = chooseModel({
+            explicit: flags.model,
+            faceLimit: numberParam(flags, 'face_limit'),
+            quad: flags.param.quad === true,
+            lowPoly: detectLowPolyIntent(prompt),
+            realtime: detectRealtimeIntent(prompt),
+            denseGeometry: detectDenseGeometryIntent(prompt),
+            params: flags.param,
+        });
         return buildTextToModel(prompt, model, flags.param);
     });
     add('image-to-model', 'single image → 3D model', 'single', async (client, inputs, flags) => {
+        const intent = flags.prompt ?? '';
+        const { model } = chooseModel({
+            explicit: flags.model,
+            faceLimit: numberParam(flags, 'face_limit'),
+            quad: flags.param.quad === true,
+            lowPoly: detectLowPolyIntent(intent),
+            realtime: detectRealtimeIntent(intent),
+            denseGeometry: detectDenseGeometryIntent(intent),
+            params: flags.param,
+        });
+        buildImageToModel(inputs[0], model, flags.param);
         const { value } = await resolveInputValue(client, inputs[0]);
-        const { model } = chooseModel({ explicit: flags.model, faceLimit: numberParam(flags, 'face_limit') });
         return buildImageToModel(value, model, flags.param);
     });
     add('multiview-to-model', '2–4 view images, or one image-to-multiview/edit-multiview task → 3D model', 'multi', async (client, inputs, flags) => {
-        const { model } = chooseModel({ explicit: flags.model, faceLimit: numberParam(flags, 'face_limit') });
+        const intent = flags.prompt ?? '';
+        const { model } = chooseModel({
+            explicit: flags.model,
+            faceLimit: numberParam(flags, 'face_limit'),
+            quad: flags.param.quad === true,
+            lowPoly: detectLowPolyIntent(intent),
+            realtime: detectRealtimeIntent(intent),
+            denseGeometry: detectDenseGeometryIntent(intent),
+            params: flags.param,
+        });
         const kind = inputs.length === 1 ? detectInput(inputs[0]).kind : undefined;
         if (kind === 'task-id' || kind === 'history-ref') {
             const { value, sourceTaskType } = await resolveInputValue(client, inputs[0]);
@@ -57,6 +84,8 @@ export function registerGenerateCommands(program) {
             }
             return buildMultiviewToModel({ task_id: value }, model, flags.param);
         }
+        const previewViews = await assignViews(client, inputs, { dryRun: true });
+        buildMultiviewToModel(previewViews, model, flags.param);
         const views = await assignViews(client, inputs);
         return buildMultiviewToModel(views, model, flags.param);
     });
@@ -68,6 +97,8 @@ export function registerGenerateCommands(program) {
         if (!params.prompt && !params.template) {
             throw new UsageError('image-to-image needs --prompt or --param template=...');
         }
+        // Validate deterministic parameters before resolving any local uploads.
+        buildImageToImage(inputs, params);
         const values = [];
         for (const input of inputs)
             values.push((await resolveInputValue(client, input)).value);

package/dist/commands/home.js

@@ -5,7 +5,6 @@ import { activeProfileName, listProfiles, loadConfig, resolveApiKey } from '../c
 import { readHistory } from '../config/history.js';
 import { TripoClient } from '../core/client.js';
 import { isInteractive, log } from '../core/output.js';
-import { t } from '../i18n.js';
 import { runLogin } from './login.js';
 export function registerHomeAction(program) {
     program.action(async () => {
@@ -16,30 +15,30 @@ export function registerHomeAction(program) {
         p.intro(pc.bold('tripo'));
         const key = resolveApiKey(loadConfig());
         if (!key) {
-            log(t({ zh: '还没有配置 API Key,先登录吧(新用户可领免费额度)', en: 'no API key yet — log in first (new accounts get free credits)' }));
+            log('no API key yet — log in first (new accounts get free credits)');
             await runLogin({});
             return;
         }
         let balanceLine = '';
         try {
             const balance = await new TripoClient().getBalance();
-            balanceLine = t({ zh: `余额 ${balance.balance} 积分`, en: `${balance.balance} credits` });
+            balanceLine = `${balance.balance} credits`;
         }
         catch {
-            balanceLine = t({ zh: '余额获取失败', en: 'balance unavailable' });
+            balanceLine = 'balance unavailable';
         }
         const last = readHistory().filter((e) => e.status === 'success').pop();
         const config = loadConfig();
-        const profileNote = listProfiles(config).length > 1 ? t({ zh: ` · 账号 ${activeProfileName(config)}`, en: ` · profile ${activeProfileName(config)}` }) : '';
-        log(`${balanceLine}${profileNote}${last ? t({ zh: ` · 上次任务 @${last.name}`, en: ` · last task @${last.name}` }) : ''}`);
+        const profileNote = listProfiles(config).length > 1 ? ` · profile ${activeProfileName(config)}` : '';
+        log(`${balanceLine}${profileNote}${last ? ` · last task @${last.name}` : ''}`);
         const action = await p.select({
-            message: t({ zh: '想做什么?', en: 'What do you want to do?' }),
+            message: 'What do you want to do?',
             options: [
-                { value: 'ai', label: t({ zh: '描述需求,让专家帮我定方案 (tripo ai)', en: 'describe what I want, experts plan it (tripo ai)' }) },
-                { value: 'make', label: t({ zh: '直接生成 (tripo make ...)', en: 'generate directly (tripo make ...)' }) },
-                ...(last ? [{ value: 'view', label: t({ zh: '看看上一个结果 (tripo view)', en: 'view the last result (tripo view)' }) }] : []),
-                { value: 'topup', label: t({ zh: '充值 (tripo topup)', en: 'top up credits (tripo topup)' }) },
-                { value: 'help', label: t({ zh: '看全部命令', en: 'show all commands' }) },
+                { value: 'ai', label: 'describe what I want, experts plan it (tripo ai)' },
+                { value: 'make', label: 'generate directly (tripo make ...)' },
+                ...(last ? [{ value: 'view', label: 'view the last result (tripo view)' }] : []),
+                { value: 'topup', label: 'top up credits (tripo topup)' },
+                { value: 'help', label: 'show all commands' },
             ],
         });
         if (p.isCancel(action))
@@ -50,7 +49,7 @@ export function registerHomeAction(program) {
                 break;
             case 'make': {
                 const promptText = await p.text({
-                    message: t({ zh: '输入一句描述或文件路径', en: 'enter a description or file path' }),
+                    message: 'enter a description or file path',
                 });
                 if (p.isCancel(promptText) || !promptText.trim())
                     return;