tripo-cli 0.1.0

package/dist/commands/batch.js

@@ -0,0 +1,148 @@
+/**
+ * `tripo batch run <manifest.yaml>` — bulk production with concurrency,
+ * retries, and resumable state (skip jobs already succeeded on re-run).
+ *
+ * Manifest:
+ *   concurrency: 2
+ *   defaults: { for: game-mobile, then: "texture,convert:fbx", out: ./assets }
+ *   jobs:
+ *     - input: "a sword"
+ *     - input: cat.png
+ *       for: print
+ *     - inputs: [hero-front.png, hero-back.png]
+ *       name: hero
+ */
+import { readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+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 { parseThenExpression } from '../knowledge/chains.js';
+import { executeMake, planMake } from '../pipeline/make.js';
+import { newClient } from './shared.js';
+export function registerBatchCommand(program) {
+    const batch = program.command('batch').description('bulk pipelines from a YAML manifest');
+    batch
+        .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('--fresh', 'ignore previous state and re-run everything')
+        .action(async (manifestPath, opts) => {
+        const absPath = resolve(manifestPath);
+        const manifest = loadManifest(absPath);
+        const statePath = `${absPath}.state.json`;
+        const state = opts.fresh ? { jobs: {} } : loadState(statePath);
+        const jobs = manifest.jobs.map((job, index) => ({
+            key: job.name ?? `job-${index + 1}`,
+            spec: { ...manifest.defaults, ...job },
+        }));
+        // Duplicate names would corrupt state bookkeeping — fail fast.
+        const seen = new Set();
+        for (const { key } of jobs) {
+            if (seen.has(key))
+                throw new UsageError(`duplicate job name "${key}" in manifest`);
+            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;
+        if (skipped > 0) {
+            log(t({ zh: `跳过 ${skipped} 个已完成任务(断点续跑)`, en: `skipping ${skipped} already-finished job(s) (resume)` }));
+        }
+        log(t({ zh: `批量执行 ${queue.length} 个任务,并发 ${concurrency}`, en: `running ${queue.length} job(s), concurrency ${concurrency}` }));
+        const client = newClient();
+        let cursor = 0;
+        const runNext = async () => {
+            for (;;) {
+                const item = queue[cursor++];
+                if (!item)
+                    return;
+                const jobState = state.jobs[item.key] ?? { status: 'pending', attempts: 0 };
+                state.jobs[item.key] = jobState;
+                const maxAttempts = 1 + opts.retries;
+                for (let attempt = jobState.attempts + 1; attempt <= maxAttempts; attempt++) {
+                    jobState.attempts = attempt;
+                    try {
+                        const outcome = await runJob(client, item.key, item.spec);
+                        jobState.status = 'success';
+                        jobState.task_id = outcome.taskId;
+                        jobState.output_dir = outcome.outputDir;
+                        delete jobState.error;
+                        success(`[${item.key}] done${outcome.outputDir ? ` → ${outcome.outputDir}` : ''}`);
+                        break;
+                    }
+                    catch (err) {
+                        const message = err instanceof Error ? err.message : String(err);
+                        jobState.status = 'failed';
+                        jobState.error = message;
+                        errorLine(`[${item.key}] attempt ${attempt}/${maxAttempts} failed: ${message}`);
+                    }
+                    finally {
+                        saveState(statePath, state);
+                    }
+                }
+            }
+        };
+        await Promise.all(Array.from({ length: Math.min(concurrency, queue.length) }, runNext));
+        const summary = {
+            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,
+            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)
+            process.exitCode = 6;
+    });
+}
+async function runJob(client, key, spec) {
+    const inputs = spec.inputs ?? (spec.input !== undefined ? [spec.input] : []);
+    if (inputs.length === 0)
+        throw new UsageError(`job "${key}" has no input`);
+    const chain = spec.then ? parseThenExpression(spec.then) : undefined;
+    const options = {
+        inputs,
+        scenario: spec.for,
+        chain,
+        model: spec.model,
+        params: spec.params ?? {},
+        name: spec.name ?? key,
+        outDir: spec.out,
+    };
+    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 };
+}
+function loadManifest(path) {
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch {
+        throw new UsageError(`manifest not found: ${path}`);
+    }
+    const doc = parseYaml(raw);
+    if (!doc || !Array.isArray(doc.jobs) || doc.jobs.length === 0) {
+        throw new UsageError('manifest must contain a non-empty "jobs" list');
+    }
+    return doc;
+}
+function loadState(path) {
+    try {
+        return JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch {
+        return { jobs: {} };
+    }
+}
+function saveState(path, state) {
+    writeFileSync(path, JSON.stringify(state, null, 2) + '\n');
+}

package/dist/commands/completion.js

@@ -0,0 +1,84 @@
+/** `tripo completion <shell>` — static shell completion scripts. */
+import { UsageError } from '../core/errors.js';
+const COMMANDS = [
+    'login', 'logout', 'whoami', 'balance', 'usage', 'topup',
+    'make', 'view', 'redo', 'ai',
+    'generate', 'model', 'anim', 'mesh', 'task', 'files', 'batch', 'history',
+    'config', 'doctor', 'docs', 'completion', 'mcp',
+];
+const SUBS = {
+    generate: ['text-to-model', 'image-to-model', 'multiview-to-model', 'text-to-image', 'image-to-image', 'image-to-multiview', 'edit-multiview', 'image-to-splat'],
+    model: ['refine', 'texture', 'stylize', 'convert', 'import'],
+    anim: ['check', 'rig', 'retarget'],
+    mesh: ['segment', 'complete', 'decimate', 'smartsegment'],
+    task: ['get', 'list', 'watch'],
+    files: ['upload'],
+    batch: ['run'],
+    config: ['list', 'set', 'unset', 'context'],
+};
+export function registerCompletionCommand(program) {
+    program
+        .command('completion <shell>')
+        .description('print a completion script (bash|zsh|fish); e.g. tripo completion zsh >> ~/.zshrc')
+        .action((shell) => {
+        switch (shell) {
+            case 'bash':
+                process.stdout.write(bashScript());
+                break;
+            case 'zsh':
+                process.stdout.write(zshScript());
+                break;
+            case 'fish':
+                process.stdout.write(fishScript());
+                break;
+            default:
+                throw new UsageError('supported shells: bash, zsh, fish');
+        }
+    });
+}
+function bashScript() {
+    const cases = Object.entries(SUBS)
+        .map(([cmd, subs]) => `    ${cmd}) COMPREPLY=($(compgen -W "${subs.join(' ')}" -- "$cur"));;`)
+        .join('\n');
+    return `# tripo bash completion
+_tripo_completions() {
+  local cur prev
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[1]}"
+  if [ "$COMP_CWORD" -eq 1 ]; then
+    COMPREPLY=($(compgen -W "${COMMANDS.join(' ')}" -- "$cur"))
+    return
+  fi
+  case "$prev" in
+${cases}
+  esac
+}
+complete -F _tripo_completions tripo
+`;
+}
+function zshScript() {
+    return `# tripo zsh completion
+autoload -Uz compinit && compinit
+_tripo() {
+  local -a cmds
+  cmds=(${COMMANDS.join(' ')})
+  if (( CURRENT == 2 )); then
+    compadd -a cmds
+  else
+    case $words[2] in
+${Object.entries(SUBS)
+        .map(([cmd, subs]) => `      ${cmd}) compadd ${subs.join(' ')};;`)
+        .join('\n')}
+    esac
+  fi
+}
+compdef _tripo tripo
+`;
+}
+function fishScript() {
+    const lines = [
+        `complete -c tripo -f -n '__fish_use_subcommand' -a '${COMMANDS.join(' ')}'`,
+        ...Object.entries(SUBS).map(([cmd, subs]) => `complete -c tripo -f -n '__fish_seen_subcommand_from ${cmd}' -a '${subs.join(' ')}'`),
+    ];
+    return lines.join('\n') + '\n';
+}

package/dist/commands/config-cmd.js

@@ -0,0 +1,84 @@
+/** `tripo config` — global config + directory context management. */
+import { loadConfig, maskKey, saveConfig } from '../config/config.js';
+import { findContextFile, loadContext, updateContext } from '../config/context.js';
+import { UsageError } from '../core/errors.js';
+import { emitResult, success } from '../core/output.js';
+import { coerceValue } from './shared.js';
+const SETTABLE = new Set([
+    'region',
+    'api_base_url',
+    'platform_base_url',
+    'language',
+    'default_output_dir',
+    'llm.base_url',
+    'llm.api_key',
+    'llm.model',
+]);
+export function registerConfigCommands(program) {
+    const config = program.command('config').description('global config (~/.tripo) and directory context (.tripo)');
+    config
+        .command('list')
+        .description('show effective config (key masked)')
+        .action(() => {
+        const cfg = loadConfig();
+        const shown = {
+            ...cfg,
+            api_key: cfg.api_key ? maskKey(cfg.api_key) : undefined,
+            llm: cfg.llm ? { ...cfg.llm, api_key: cfg.llm.api_key ? maskKey(cfg.llm.api_key) : undefined } : undefined,
+        };
+        const context = loadContext();
+        emitResult({ config: shown, context, context_file: findContextFile() }, JSON.stringify({ config: shown, context }, null, 2));
+    });
+    config
+        .command('set <key> <value>')
+        .description(`set a config value (${[...SETTABLE].join(', ')})`)
+        .action((key, value) => {
+        if (!SETTABLE.has(key)) {
+            throw new UsageError(`unknown config key "${key}" (valid: ${[...SETTABLE].join(', ')})`);
+        }
+        const cfg = loadConfig();
+        applyPath(cfg, key.split('.'), coerceValue(value));
+        saveConfig(cfg);
+        success(`${key} = ${key.includes('api_key') ? maskKey(value) : value}`);
+    });
+    config
+        .command('unset <key>')
+        .description('remove a config value')
+        .action((key) => {
+        const cfg = loadConfig();
+        const parts = key.split('.');
+        const parent = parts.slice(0, -1).reduce((acc, part) => (acc && typeof acc[part] === 'object' ? acc[part] : undefined), cfg);
+        if (parent)
+            delete parent[parts[parts.length - 1]];
+        saveConfig(cfg);
+        success(`${key} removed`);
+    });
+    config
+        .command('context [entries...]')
+        .description('set directory context: tripo config context default_scenario=game-mobile output_dir=./assets')
+        .action((entries) => {
+        if (entries.length === 0) {
+            const ctx = loadContext();
+            emitResult({ context: ctx, file: findContextFile() }, JSON.stringify(ctx, null, 2));
+            return;
+        }
+        const patch = {};
+        for (const entry of entries) {
+            const eq = entry.indexOf('=');
+            if (eq <= 0)
+                throw new UsageError(`context entries are key=value (got "${entry}")`);
+            patch[entry.slice(0, eq)] = coerceValue(entry.slice(eq + 1));
+        }
+        updateContext(patch);
+        success(`context updated: ${Object.keys(patch).join(', ')}`);
+    });
+}
+function applyPath(obj, path, value) {
+    let node = obj;
+    for (const part of path.slice(0, -1)) {
+        if (typeof node[part] !== 'object' || node[part] === null)
+            node[part] = {};
+        node = node[part];
+    }
+    node[path[path.length - 1]] = value;
+}

package/dist/commands/docs.js

@@ -0,0 +1,30 @@
+/**
+ * `tripo docs` — print bundled documentation. `--llm` prints the skill map
+ * designed for AI coding agents (the npm package ships skill/ alongside dist/).
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { UsageError } from '../core/errors.js';
+export function skillRoot() {
+    return new URL('../../skill/', import.meta.url);
+}
+export function readSkillFile(relative) {
+    const url = new URL(relative, skillRoot());
+    if (!existsSync(url))
+        throw new UsageError(`documentation file not found: ${relative}`);
+    return readFileSync(url, 'utf8');
+}
+export function registerDocsCommand(program) {
+    program
+        .command('docs')
+        .description('print bundled docs (default: the LLM/agent skill map)')
+        .option('--llm', 'print the agent-facing SKILL.md (default)')
+        .option('--topic <name>', 'print a specific doc: commands/<cmd> or examples/<scenario> or common-errors')
+        .action((opts) => {
+        if (opts.topic) {
+            const file = opts.topic.endsWith('.md') ? opts.topic : `${opts.topic}.md`;
+            process.stdout.write(readSkillFile(file));
+            return;
+        }
+        process.stdout.write(readSkillFile('SKILL.md'));
+    });
+}

package/dist/commands/doctor.js

@@ -0,0 +1,102 @@
+/** `tripo doctor` — environment/config/network self-diagnosis. */
+import { statSync } from 'node:fs';
+import { join } from 'node:path';
+import pc from 'picocolors';
+import { configFileExists, loadConfig, 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';
+import { emitResult } from '../core/output.js';
+import { EXIT } from '../knowledge/error-catalog.js';
+import { resolveLlmConfig } from '../ai/llm.js';
+import { terminalSupportsInlineImages } from '../util/term-image.js';
+export function registerDoctorCommand(program) {
+    program
+        .command('doctor')
+        .description('diagnose environment, key, network, and terminal capabilities')
+        .action(async () => {
+        const checks = [];
+        const nodeMajor = Number(process.versions.node.split('.')[0]);
+        checks.push({
+            name: 'node',
+            ok: nodeMajor >= 20,
+            detail: `v${process.versions.node} (need >= 20)`,
+            critical: true,
+        });
+        const key = resolveApiKey();
+        checks.push({
+            name: 'api key',
+            ok: Boolean(key),
+            detail: key
+                ? process.env.TRIPO_API_KEY
+                    ? 'from TRIPO_API_KEY env'
+                    : 'from ~/.tripo/config.json'
+                : 'missing — run "tripo login"',
+            critical: true,
+        });
+        if (configFileExists()) {
+            try {
+                const mode = statSync(join(tripoHome(), 'config.json')).mode & 0o777;
+                checks.push({
+                    name: 'config permissions',
+                    ok: mode === 0o600,
+                    detail: `0${mode.toString(8)} (expect 0600)`,
+                    critical: false,
+                });
+            }
+            catch { }
+        }
+        const baseUrl = resolveApiBaseUrl();
+        const region = resolveRegion();
+        if (key) {
+            try {
+                const client = new TripoClient();
+                const balance = await client.getBalance();
+                checks.push({ name: 'api reachability', ok: true, detail: `${baseUrl} (region ${region}) · balance ${balance.balance}`, critical: true });
+                checks.push({
+                    name: 'balance',
+                    ok: Number(balance.balance) > 0,
+                    detail: `${balance.balance} credits (${balance.frozen} frozen)${Number(balance.balance) <= 0 ? ' — run "tripo topup"' : ''}`,
+                    critical: false,
+                });
+            }
+            catch (err) {
+                let detail = `${baseUrl}: ${err instanceof Error ? err.message : String(err)}`;
+                // Auth failure is the classic region-mismatch symptom: the key may
+                // simply live in the other region. Probe and hand over the exact fix.
+                if (err instanceof CliError && err.exitCode === EXIT.AUTH && !process.env.TRIPO_API_BASE_URL) {
+                    const detected = await detectRegionForKey(key);
+                    if (detected && detected.region !== region) {
+                        detail += ` — key belongs to region "${detected.region}"; run: tripo config set region ${detected.region}`;
+                    }
+                }
+                checks.push({ name: 'api reachability', ok: false, detail, critical: true });
+            }
+        }
+        else {
+            checks.push({ name: 'api reachability', ok: false, detail: `skipped (no key) · would use ${baseUrl} (region ${region})`, critical: false });
+        }
+        const llm = resolveLlmConfig();
+        checks.push({
+            name: 'llm (tripo ai conversation mode)',
+            ok: true,
+            detail: llm ? `${llm.model} @ ${llm.base_url}` : 'not configured — wizard mode only (this is fine)',
+            critical: false,
+        });
+        checks.push({
+            name: 'terminal',
+            ok: true,
+            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}`)
+            .join('\n');
+        emitResult({ ok: !failedCritical, checks }, human);
+        if (failedCritical)
+            process.exitCode = 1;
+    });
+}

package/dist/commands/generate.js

@@ -0,0 +1,81 @@
+/** `tripo generate <endpoint>` — deterministic 1:1 mapping to the 8 generation endpoints. */
+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 { assignViews } from '../pipeline/make.js';
+import { newClient, printTaskResult, withTaskOptions } from './shared.js';
+export function registerGenerateCommands(program) {
+    const generate = program.command('generate').description('deterministic generation endpoints (text/image/multiview → model/image/splat)');
+    const add = (name, description, inputArity, build) => {
+        const cmd = generate
+            .command(`${name} ${inputArity === 'prompt' ? '<prompt...>' : inputArity === 'single' ? '<input>' : '<inputs...>'}`)
+            .description(description)
+            .option('--model <model>', 'model version override');
+        if (inputArity !== 'prompt')
+            cmd.option('--prompt <text>', 'prompt for prompt-guided endpoints');
+        withTaskOptions(cmd);
+        cmd.action(async (inputs, flags) => {
+            const list = Array.isArray(inputs) ? inputs : [inputs];
+            const client = newClient();
+            const built = await build(client, list, flags);
+            for (const w of built.warnings)
+                warn(w);
+            const result = await runTask({
+                client,
+                request: built.request,
+                taskType: built.taskType,
+                name: flags.name ?? (inputArity === 'prompt' ? list.join(' ') : list[0]),
+                outDir: flags.out,
+                noWait: flags.wait === false,
+                noDownload: flags.download === false,
+                notify: flags.notify,
+                timeoutMs: flags.timeout ? flags.timeout * 1000 : undefined,
+            });
+            printTaskResult(result);
+        });
+    };
+    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') });
+        return buildTextToModel(prompt, model, flags.param);
+    });
+    add('image-to-model', 'single image → 3D model', 'single', async (client, inputs, flags) => {
+        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 → 3D model', 'multi', async (client, inputs, flags) => {
+        const views = await assignViews(client, inputs);
+        const { model } = chooseModel({ explicit: flags.model, faceLimit: numberParam(flags, 'face_limit') });
+        return buildMultiviewToModel(views, model, flags.param);
+    });
+    add('text-to-image', 'text → image (concept art / t_pose templates)', 'prompt', async (_c, inputs, flags) => buildTextToImage(inputs.join(' '), { ...(flags.model ? { model: flags.model } : {}), ...flags.param }));
+    add('image-to-image', 'image + prompt → edited image', 'single', async (client, inputs, flags) => {
+        const { value } = await resolveInputValue(client, inputs[0]);
+        const params = { ...(flags.model ? { model: flags.model } : {}), ...flags.param };
+        if (flags.prompt)
+            params.prompt = flags.prompt;
+        if (!params.prompt && !params.template) {
+            throw new UsageError('image-to-image needs --prompt or --param template=...');
+        }
+        return buildImageToImage(value, params);
+    });
+    add('image-to-multiview', 'single image → 4-view sheet', 'single', async (client, inputs, flags) => {
+        const { value } = await resolveInputValue(client, inputs[0]);
+        return buildImageToMultiview(value, flags.param);
+    });
+    add('edit-multiview', 'edit views of a multiview task', 'single', async (client, inputs, flags) => {
+        const { value } = await resolveInputValue(client, inputs[0]);
+        return buildEditMultiview(value, flags.param);
+    });
+    add('image-to-splat', 'image → gaussian splat', 'single', async (client, inputs, flags) => {
+        const { value } = await resolveInputValue(client, inputs[0]);
+        return buildImageToSplat(value, flags.param);
+    });
+}
+function numberParam(flags, key) {
+    const v = flags.param[key];
+    return typeof v === 'number' ? v : undefined;
+}

package/dist/commands/home.js

@@ -0,0 +1,68 @@
+/** Bare `tripo` — interactive home: status, quick actions, continue last task. */
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { loadConfig, resolveApiKey } from '../config/config.js';
+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 () => {
+        if (!isInteractive()) {
+            program.outputHelp();
+            return;
+        }
+        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)' }));
+            await runLogin({});
+            return;
+        }
+        let balanceLine = '';
+        try {
+            const balance = await new TripoClient().getBalance();
+            balanceLine = t({ zh: `余额 ${balance.balance} 积分`, en: `${balance.balance} credits` });
+        }
+        catch {
+            balanceLine = t({ zh: '余额获取失败', en: 'balance unavailable' });
+        }
+        const last = readHistory().filter((e) => e.status === 'success').pop();
+        log(`${balanceLine}${last ? t({ zh: ` · 上次任务 @${last.name}`, en: ` · last task @${last.name}` }) : ''}`);
+        const action = await p.select({
+            message: t({ zh: '想做什么?', en: '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' }) },
+            ],
+        });
+        if (p.isCancel(action))
+            return;
+        switch (action) {
+            case 'ai':
+                await program.parseAsync(['ai'], { from: 'user' });
+                break;
+            case 'make': {
+                const promptText = await p.text({
+                    message: t({ zh: '输入一句描述或文件路径', en: 'enter a description or file path' }),
+                });
+                if (p.isCancel(promptText) || !promptText.trim())
+                    return;
+                await program.parseAsync(['make', promptText.trim()], { from: 'user' });
+                break;
+            }
+            case 'view':
+                await program.parseAsync(['view'], { from: 'user' });
+                break;
+            case 'topup':
+                await program.parseAsync(['topup'], { from: 'user' });
+                break;
+            default:
+                program.outputHelp();
+        }
+    });
+}