tripo-cli 0.1.0 → 0.2.0

package/dist/src/commands/ai.js

@@ -1,113 +0,0 @@
-/**
- * `tripo ai` — dual mode:
- *   wizard (default without an LLM): knowledge-base decision-tree Q&A
- *   conversation (with an LLM configured): producer + specialist agents
- * Both produce the same plan card; confirmed plans execute through the same
- * deterministic engine as `tripo make`.
- */
-import * as p from '@clack/prompts';
-import { resolveReference } from '../config/history.js';
-import { CliError } from '../core/errors.js';
-import { isInteractive, isYes, log, warn } from '../core/output.js';
-import { t } from '../i18n.js';
-import { EXIT } from '../knowledge/error-catalog.js';
-import { executeMake, planMake } from '../pipeline/make.js';
-import { renderPlanCard } from '../ai/plan-card.js';
-import { resolveLlmConfig } from '../ai/llm.js';
-import { buildExpertPlan } from '../ai/experts.js';
-import { runWizard } from '../ai/wizard.js';
-import { emitMakeOutcome } from './make.js';
-import { newClient, withTaskOptions } from './shared.js';
-export function registerAiCommand(program) {
-    const cmd = program
-        .command('ai')
-        .description('describe what you want in natural language; experts plan it, you confirm, it runs')
-        .argument('[request...]', 'e.g. "给我的手游做一个低模骑士,要跑步动画"')
-        .option('--wizard', 'force wizard mode even when an LLM is configured');
-    withTaskOptions(cmd);
-    cmd.action(async (request, flags) => {
-        const text = expandHistoryRefs(request.join(' ').trim());
-        const llm = resolveLlmConfig();
-        let card;
-        let makeOptions;
-        if (llm && !flags.wizard && text) {
-            log(t({ zh: `对话模式(${llm.model})…`, en: `conversation mode (${llm.model})…` }));
-            try {
-                const plan = await buildExpertPlan(text, isInteractive() ? askUser : undefined);
-                card = plan.card;
-                makeOptions = {
-                    inputs: [plan.prompt],
-                    scenario: plan.scenarioId,
-                    chain: plan.chain,
-                    params: plan.params,
-                    name: flags.name,
-                    outDir: flags.out,
-                    notify: flags.notify,
-                    timeoutMs: flags.timeout ? flags.timeout * 1000 : undefined,
-                };
-            }
-            catch (err) {
-                warn(t({
-                    zh: `LLM 编排失败(${err instanceof Error ? err.message : err}),回落到向导模式`,
-                    en: `LLM planning failed (${err instanceof Error ? err.message : err}); falling back to the wizard`,
-                }));
-                const wizard = await runWizard(text);
-                card = wizard.card;
-                makeOptions = wizardToOptions(wizard.options, flags);
-            }
-        }
-        else {
-            if (llm === undefined && text && !isInteractive()) {
-                throw new CliError(t({
-                    zh: '无 LLM 配置时 tripo ai 需要交互终端;无头环境请用 tripo make --for <场景>(或配置 llm.base_url/llm.model)',
-                    en: 'without an LLM, "tripo ai" needs an interactive terminal; headless callers should use "tripo make --for <scenario>" (or configure llm.base_url/llm.model)',
-                }), EXIT.USAGE);
-            }
-            const wizard = await runWizard(text || undefined);
-            card = wizard.card;
-            makeOptions = wizardToOptions(wizard.options, flags);
-        }
-        process.stderr.write(renderPlanCard(card) + '\n');
-        if (!isYes()) {
-            const go = await p.confirm({ message: t({ zh: '按方案执行?', en: 'Run this plan?' }) });
-            if (p.isCancel(go) || !go) {
-                log(t({ zh: '已取消,未消耗积分', en: 'cancelled; no credits spent' }));
-                return;
-            }
-        }
-        const client = newClient();
-        const plan = await planMake(client, makeOptions);
-        const outcome = await executeMake(client, plan, makeOptions);
-        emitMakeOutcome({ results: [outcome.primary], chainResults: outcome.chainResults, stoppedEarly: outcome.stoppedEarly });
-    });
-}
-function wizardToOptions(options, flags) {
-    return {
-        inputs: [options.prompt],
-        scenario: options.scenario,
-        chain: options.chain,
-        params: flags.param,
-        name: flags.name,
-        outDir: flags.out,
-        notify: flags.notify,
-        timeoutMs: flags.timeout ? flags.timeout * 1000 : undefined,
-    };
-}
-async function askUser(question) {
-    const answer = await p.text({ message: question });
-    if (p.isCancel(answer))
-        return undefined;
-    return answer;
-}
-/** Replace @task-name references in a prompt with their task ids. */
-export function expandHistoryRefs(text) {
-    return text.replace(/@[\w\u4e00-\u9fff-]+/g, (ref) => {
-        try {
-            const entry = resolveReference(ref);
-            return entry ? entry.task_id : ref;
-        }
-        catch {
-            return ref; // ambiguity is reported when the value is actually used
-        }
-    });
-}

package/dist/src/commands/batch.js

@@ -1,148 +0,0 @@
-/**
- * `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/src/commands/completion.js

@@ -1,84 +0,0 @@
-/** `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/src/commands/config-cmd.js

@@ -1,84 +0,0 @@
-/** `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/src/commands/docs.js

@@ -1,30 +0,0 @@
-/**
- * `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/src/commands/doctor.js

@@ -1,94 +0,0 @@
-/** `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, tripoHome } from '../config/config.js';
-import { TripoClient } from '../core/client.js';
-import { emitResult } from '../core/output.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();
-        if (key) {
-            try {
-                const client = new TripoClient();
-                const balance = await client.getBalance();
-                checks.push({ name: 'api reachability', ok: true, detail: `${baseUrl} · 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) {
-                checks.push({
-                    name: 'api reachability',
-                    ok: false,
-                    detail: `${baseUrl}: ${err instanceof Error ? err.message : String(err)}`,
-                    critical: true,
-                });
-            }
-        }
-        else {
-            checks.push({ name: 'api reachability', ok: false, detail: `skipped (no key) · would use ${baseUrl}`, 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/src/commands/generate.js

@@ -1,81 +0,0 @@
-/** `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;
-}