tripo-cli 0.1.0 → 0.2.1

package/dist/src/commands/mcp.js

@@ -1,194 +0,0 @@
-/**
- * `tripo mcp` — MCP (Model Context Protocol) server over stdio, exposing the
- * CLI's capabilities as tools for Cursor / Claude Desktop / any MCP client.
- *
- * Implements the stdio transport (newline-delimited JSON-RPC 2.0):
- * initialize, ping, tools/list, tools/call. Self-contained: no SDK
- * dependency, no stdout pollution (stdout carries protocol frames only).
- */
-import { createInterface } from 'node:readline';
-import { readHistory } from '../config/history.js';
-import { TripoClient } from '../core/client.js';
-import { downloadArtifacts, defaultOutputDir } from '../core/download.js';
-import { configureOutput } from '../core/output.js';
-import { watchTask } from '../core/watch.js';
-import { parseThenExpression } from '../knowledge/chains.js';
-import { scenarioIds } from '../knowledge/scenarios.js';
-import { executeMake, planMake } from '../pipeline/make.js';
-import { cliVersion } from '../version.js';
-const TOOLS = [
-    {
-        name: 'tripo_make',
-        description: 'Generate a 3D asset from text, an image path/URL, or an existing task id. Blocks until finished; downloads artifacts locally and returns file paths (model_file, preview). Use scenario presets for domain defaults.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                input: { type: 'string', description: 'prompt text, image file path, image URL, or task id' },
-                scenario: { type: 'string', enum: scenarioIds(), description: 'production scenario preset' },
-                then: { type: 'string', description: 'processing chain, e.g. "texture,rig,convert:fbx"' },
-                model: { type: 'string', description: 'force model: tripo-v3.1 or tripo-p1' },
-                output_dir: { type: 'string', description: 'directory for artifacts' },
-            },
-            required: ['input'],
-        },
-    },
-    {
-        name: 'tripo_task_get',
-        description: 'Get the status/details of a Tripo task by id.',
-        inputSchema: {
-            type: 'object',
-            properties: { task_id: { type: 'string' } },
-            required: ['task_id'],
-        },
-    },
-    {
-        name: 'tripo_task_wait',
-        description: 'Block until a Tripo task finishes; optionally download artifacts.',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                task_id: { type: 'string' },
-                download: { type: 'boolean', description: 'download artifacts on success (default true)' },
-            },
-            required: ['task_id'],
-        },
-    },
-    {
-        name: 'tripo_balance',
-        description: 'Get the account credit balance.',
-        inputSchema: { type: 'object', properties: {} },
-    },
-    {
-        name: 'tripo_history',
-        description: 'List recent tasks created by this CLI (task ids, names, statuses, output dirs).',
-        inputSchema: {
-            type: 'object',
-            properties: { limit: { type: 'number', description: 'max entries (default 10)' } },
-        },
-    },
-];
-export function registerMcpCommand(program) {
-    program
-        .command('mcp')
-        .description('run as an MCP server over stdio (tools: make/task/balance/history)')
-        .action(async () => {
-        configureOutput({ quiet: true, yes: true, noOpen: true, json: false });
-        await serveMcp();
-    });
-}
-async function serveMcp() {
-    const rl = createInterface({ input: process.stdin, terminal: false });
-    const write = (message) => {
-        process.stdout.write(JSON.stringify(message) + '\n');
-    };
-    for await (const line of rl) {
-        const text = line.trim();
-        if (!text)
-            continue;
-        let request;
-        try {
-            request = JSON.parse(text);
-        }
-        catch {
-            continue;
-        }
-        if (request.id === undefined || request.id === null) {
-            continue; // notification — nothing to answer
-        }
-        try {
-            const result = await dispatch(request.method, request.params ?? {});
-            if (result !== SKIP)
-                write({ jsonrpc: '2.0', id: request.id, result });
-        }
-        catch (err) {
-            write({
-                jsonrpc: '2.0',
-                id: request.id,
-                error: { code: -32000, message: err instanceof Error ? err.message : String(err) },
-            });
-        }
-    }
-}
-const SKIP = Symbol('skip');
-async function dispatch(method, params) {
-    switch (method) {
-        case 'initialize':
-            return {
-                protocolVersion: params.protocolVersion ?? '2024-11-05',
-                capabilities: { tools: {} },
-                serverInfo: { name: 'tripo-cli', version: cliVersion() },
-            };
-        case 'ping':
-            return {};
-        case 'tools/list':
-            return { tools: TOOLS };
-        case 'tools/call':
-            return callTool(params);
-        default:
-            return SKIP;
-    }
-}
-async function callTool(params) {
-    const args = params.arguments ?? {};
-    const asText = (value) => ({
-        content: [{ type: 'text', text: JSON.stringify(value, null, 2) }],
-    });
-    try {
-        switch (params.name) {
-            case 'tripo_make': {
-                const client = new TripoClient();
-                const options = {
-                    inputs: [String(args.input ?? '')],
-                    scenario: args.scenario,
-                    chain: typeof args.then === 'string' ? parseThenExpression(args.then) : undefined,
-                    model: args.model,
-                    outDir: args.output_dir,
-                };
-                const plan = await planMake(client, options);
-                const outcome = await executeMake(client, plan, options);
-                const final = outcome.chainResults[outcome.chainResults.length - 1] ?? outcome.primary;
-                return asText({
-                    task_id: final.task_id,
-                    status: final.status,
-                    output_dir: final.output_dir ?? outcome.primary.output_dir,
-                    model_file: final.model_file ?? outcome.primary.model_file,
-                    preview: final.preview ?? outcome.primary.preview,
-                    chain: outcome.chainResults.map((r) => ({ task_id: r.task_id, type: r.type })),
-                    stopped_early: outcome.stoppedEarly,
-                });
-            }
-            case 'tripo_task_get': {
-                const client = new TripoClient();
-                return asText(await client.getTask(String(args.task_id)));
-            }
-            case 'tripo_task_wait': {
-                const client = new TripoClient();
-                const taskId = String(args.task_id);
-                const detail = await watchTask(client, taskId, { throwOnFailure: false });
-                if (detail.status === 'success' && args.download !== false) {
-                    const entry = readHistory().find((e) => e.task_id === taskId);
-                    const dir = entry?.output_dir ?? defaultOutputDir(process.cwd(), entry?.name ?? 'task', taskId);
-                    const artifacts = await downloadArtifacts(detail, dir);
-                    return asText({ ...detail, output_dir: artifacts.outputDir, model_file: artifacts.modelFile, preview: artifacts.preview });
-                }
-                return asText(detail);
-            }
-            case 'tripo_balance': {
-                const client = new TripoClient();
-                return asText(await client.getBalance());
-            }
-            case 'tripo_history': {
-                const limit = typeof args.limit === 'number' ? args.limit : 10;
-                return asText(readHistory().slice(-limit));
-            }
-            default:
-                return { content: [{ type: 'text', text: `unknown tool: ${params.name}` }], isError: true };
-        }
-    }
-    catch (err) {
-        return {
-            content: [{ type: 'text', text: err instanceof Error ? err.message : String(err) }],
-            isError: true,
-        };
-    }
-}

package/dist/src/commands/process-groups.js

@@ -1,164 +0,0 @@
-/**
- * Processing command groups: `tripo model`, `tripo anim`, `tripo mesh`.
- * Input resolution order: explicit argument > piped NDJSON from stdin > @last.
- * That makes both human implicit-context and shell pipelines work:
- *   tripo make cat.png | tripo anim rig | tripo anim retarget --param animation=preset:walk
- */
-import { UsageError } from '../core/errors.js';
-import { log, warn } from '../core/output.js';
-import { buildStepRequest } from '../core/requests.js';
-import { resolveInputValue, runTask } from '../core/task-service.js';
-import { t } from '../i18n.js';
-import { getStep } from '../knowledge/chains.js';
-import { readPipedTask } from '../pipeline/stdin.js';
-import { newClient, printTaskResult, withTaskOptions } from './shared.js';
-async function resolveStepInput(client, raw) {
-    if (raw)
-        return resolveInputValue(client, raw);
-    const piped = await readPipedTask();
-    if (piped) {
-        log(t({ zh: `使用管道输入任务 ${piped.task_id}`, en: `using piped task ${piped.task_id}` }));
-        return { value: piped.task_id, sourceType: piped.type };
-    }
-    const fallback = await resolveInputValue(client, '@last');
-    log(t({ zh: `未指定输入,使用上一个成功任务 @last`, en: `no input given; defaulting to the last successful task (@last)` }));
-    return fallback;
-}
-function makeStepAction(stepName, extraDefaults = {}) {
-    return async (input, flags) => {
-        const client = newClient();
-        const resolved = await resolveStepInput(client, input);
-        // Local chain legality: catch e.g. retarget-on-non-rig before spending credits.
-        const def = getStep(stepName);
-        if (Array.isArray(def.accepts) && resolved.sourceType && !def.accepts.includes(resolved.sourceType)) {
-            throw new UsageError(`${def.name} only accepts ${def.accepts.join('/')} tasks (input is a ${resolved.sourceType} task)`);
-        }
-        const args = { ...extraDefaults, ...collectStepArgs(stepName, flags), ...flags.param };
-        const built = buildStepRequest(stepName, resolved.value, args);
-        for (const w of built.warnings)
-            warn(w);
-        const result = await runTask({
-            client,
-            request: built.request,
-            taskType: built.taskType,
-            name: flags.name ?? `${stepName}`,
-            outDir: flags.out,
-            noWait: flags.wait === false,
-            noDownload: flags.download === false,
-            notify: flags.notify,
-            timeoutMs: flags.timeout ? flags.timeout * 1000 : undefined,
-        });
-        printTaskResult(result);
-    };
-}
-/** Map first-class flags (e.g. --format) into step args. */
-function collectStepArgs(step, flags) {
-    const pick = (keys) => {
-        const out = {};
-        for (const key of keys) {
-            const flagKey = key.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
-            const v = flags[flagKey] ?? flags[key];
-            if (v !== undefined)
-                out[key] = v;
-        }
-        return out;
-    };
-    switch (step) {
-        case 'convert':
-            return pick(['format', 'texture_size', 'texture_format', 'face_limit', 'quad', 'flatten_bottom', 'fbx_preset', 'export_orientation', 'scale_factor', 'auto_size', 'pivot_to_center_bottom', 'export_vertex_colors']);
-        case 'texture':
-            return pick(['model', 'texture_quality', 'texture_alignment', 'pbr']);
-        case 'stylize':
-            return pick(['style', 'block_size']);
-        case 'rig':
-            return pick(['model', 'rig_type', 'spec', 'out_format']);
-        case 'retarget':
-            return pick(['animation', 'out_format', 'animate_in_place']);
-        case 'decimate':
-            return pick(['face_limit', 'quad', 'bake']);
-        case 'segment':
-            return pick(['model']);
-        case 'complete':
-            return pick(['completion_mode']);
-        case 'smartsegment':
-            return pick(['seg_type', 'granularity', 'hint']);
-        default:
-            return {};
-    }
-}
-export function registerProcessCommands(program) {
-    // ---- tripo model ----
-    const model = program.command('model').description('model processing: refine / texture / stylize / convert / import');
-    withTaskOptions(model.command('refine [input]').description('refine a draft text-to-model task (task id / @last)')).action(makeStepAction('refine'));
-    withTaskOptions(model
-        .command('texture [input]')
-        .description('re-texture a model (task/@last/file/url)')
-        .option('--texture-quality <q>', 'standard|detailed|extreme')
-        .option('--texture-alignment <a>', 'original_image|geometry')).action(makeStepAction('texture'));
-    withTaskOptions(model
-        .command('stylize [input]')
-        .description('stylize a model (lego/voxel/voronoi/minecraft)')
-        .option('--style <style>', 'lego|voxel|voronoi|minecraft')
-        .option('--block-size <n>', 'minecraft block size 32-128', (v) => Number(v))).action(makeStepAction('stylize'));
-    withTaskOptions(model
-        .command('convert [input]')
-        .description('convert format (GLTF/USDZ/FBX/OBJ/STL/3MF)')
-        .option('--format <format>', 'target format', 'GLTF')
-        .option('--texture-size <n>', 'texture size in px', (v) => Number(v))
-        .option('--texture-format <f>', 'JPEG/PNG/OPEN_EXR/...')
-        .option('--face-limit <n>', 'face limit', (v) => Number(v))
-        .option('--quad', 'quad remesh')
-        .option('--flatten-bottom', 'flatten the bottom (3D printing)')
-        .option('--fbx-preset <p>', 'blender|3dsmax|mixamo')
-        .option('--export-orientation <o>', '+x|-x|+y|-y')
-        .option('--scale-factor <n>', 'scale factor', (v) => Number(v))
-        .option('--auto-size', 'scale to real-world size')
-        .option('--pivot-to-center-bottom', 'pivot at center bottom')
-        .option('--export-vertex-colors', 'include vertex colors (OBJ/GLTF)')).action(makeStepAction('convert'));
-    withTaskOptions(model.command('import <input>').description('import an external model file/url (GLB/GLTF/FBX/OBJ/STL ≤150MB)')).action(makeStepAction('import'));
-    // ---- tripo anim ----
-    const anim = program.command('anim').description('animation: check (riggability) / rig / retarget');
-    withTaskOptions(anim.command('check [input]').description('rig-check: is this model riggable? (GLB input)')).action(makeStepAction('rig-check'));
-    withTaskOptions(anim
-        .command('rig [input]')
-        .description('rig a model (skeleton binding)')
-        .option('--rig-type <type>', 'biped|quadruped|hexapod|octopod|avian|serpentine|aquatic')
-        .option('--spec <spec>', 'tripo|mixamo')
-        .option('--out-format <f>', 'glb|fbx')).action(makeStepAction('rig'));
-    withTaskOptions(anim
-        .command('retarget [input]')
-        .description('apply preset animations to a rigged task')
-        .option('--animation <name...>', 'preset:walk preset:run ... (≤5, billed per animation)')
-        .option('--out-format <f>', 'glb|fbx')
-        .option('--animate-in-place', 'no root motion')).action(async (input, flags) => {
-        // --animation may be a list → map to animations[]
-        const anims = flags.animation;
-        if (Array.isArray(anims) && anims.length > 1) {
-            flags.param = { ...flags.param, animations: anims };
-            delete flags.animation;
-        }
-        else if (Array.isArray(anims)) {
-            flags.animation = anims[0];
-        }
-        await makeStepAction('retarget')(input, flags);
-    });
-    // ---- tripo mesh ----
-    const mesh = program.command('mesh').description('mesh ops: segment / complete / decimate / smartsegment');
-    withTaskOptions(mesh.command('segment [input]').description('segment a model into parts').option('--model <v>', 'v1.0-20250506|v2.0-20260430')).action(makeStepAction('segment'));
-    withTaskOptions(mesh
-        .command('complete [input]')
-        .description('complete/fill segmented parts (needs a segment task)')
-        .option('--completion-mode <m>', 'ai_completion|quick_cap')).action(makeStepAction('complete'));
-    withTaskOptions(mesh
-        .command('decimate [input]')
-        .description('high-poly → low-poly (bakes textures by default)')
-        .option('--face-limit <n>', 'target faces 500–20000', (v) => Number(v))
-        .option('--quad', 'quad output')
-        .option('--no-bake', 'skip baking textures onto the low-poly')).action(makeStepAction('decimate'));
-    withTaskOptions(mesh
-        .command('smartsegment [input]')
-        .description('smart segmentation (image or model pipeline)')
-        .option('--seg-type <t>', 'image|model', 'model')
-        .option('--granularity <g>', 'coarse|medium|fine')
-        .option('--hint <text>', 'hint for the parts to find')).action(makeStepAction('smartsegment'));
-}

package/dist/src/commands/shared.js

@@ -1,75 +0,0 @@
-/** Helpers shared by task-producing commands: flag parsing and result output. */
-import { loadConfig } from '../config/config.js';
-import { TripoClient } from '../core/client.js';
-import { UsageError } from '../core/errors.js';
-import { emitResult } from '../core/output.js';
-import { t } from '../i18n.js';
-import { parseThenExpression } from '../knowledge/chains.js';
-/** repeatable --param key=value collector */
-export function collectParam(value, previous) {
-    const eq = value.indexOf('=');
-    if (eq <= 0)
-        throw new UsageError(`--param expects key=value (got "${value}")`);
-    const key = value.slice(0, eq).trim();
-    const raw = value.slice(eq + 1).trim();
-    previous[key] = coerceValue(raw);
-    return previous;
-}
-export function coerceValue(raw) {
-    if (raw === 'true')
-        return true;
-    if (raw === 'false')
-        return false;
-    if (/^-?\d+$/.test(raw))
-        return Number(raw);
-    if (/^-?\d*\.\d+$/.test(raw))
-        return Number(raw);
-    if ((raw.startsWith('[') && raw.endsWith(']')) || (raw.startsWith('{') && raw.endsWith('}'))) {
-        try {
-            return JSON.parse(raw);
-        }
-        catch { }
-    }
-    return raw;
-}
-/** Attach the common generation/processing option set to a command. */
-export function withTaskOptions(cmd) {
-    return cmd
-        .option('-o, --out <dir>', 'output directory (default ./tripo-out/...)')
-        .option('--no-wait', 'submit only; do not wait for completion')
-        .option('--no-download', 'wait but skip downloading artifacts')
-        .option('--notify', 'desktop notification when done')
-        .option('--timeout <seconds>', 'watch timeout in seconds', (v) => Number(v))
-        .option('--name <name>', 'history name for @references')
-        .option('-p, --param <key=value>', 'extra API parameter (repeatable)', collectParam, {});
-}
-export function newClient() {
-    return new TripoClient({ baseUrl: undefined, apiKey: undefined });
-}
-export function parseChainFlag(value) {
-    if (!value)
-        return undefined;
-    return parseThenExpression(value);
-}
-/** Standard result output for a finished task (human + JSON modes). */
-export function printTaskResult(result) {
-    const lines = [];
-    lines.push(t({
-        zh: `任务 ${result.task_id} ${result.status === 'success' ? '完成' : result.status}`,
-        en: `task ${result.task_id} ${result.status}`,
-    }));
-    if (result.credits_consumed !== undefined) {
-        lines.push(t({ zh: `消耗积分: ${result.credits_consumed}`, en: `credits consumed: ${result.credits_consumed}` }));
-    }
-    if (result.output_dir) {
-        lines.push(t({ zh: `产物目录: ${result.output_dir}`, en: `artifacts: ${result.output_dir}` }));
-    }
-    if (result.model_file)
-        lines.push(t({ zh: `模型文件: ${result.model_file}`, en: `model file: ${result.model_file}` }));
-    if (result.preview)
-        lines.push(t({ zh: `预览图: ${result.preview}`, en: `preview: ${result.preview}` }));
-    emitResult(result, lines.join('\n'));
-}
-export function llmConfigured() {
-    return Boolean(loadConfig().llm?.base_url && loadConfig().llm?.model);
-}

package/dist/src/commands/task.js

@@ -1,127 +0,0 @@
-/** `tripo task get|list|watch` and `tripo files upload`. */
-import { readHistory, resolveReference, updateHistoryStatus } from '../config/history.js';
-import { TripoClient } from '../core/client.js';
-import { defaultOutputDir, downloadArtifacts } from '../core/download.js';
-import { emitNdjson, emitResult, isJsonMode, isQuiet, log } from '../core/output.js';
-import { watchTask } from '../core/watch.js';
-import { uploadLocalFile } from '../core/upload.js';
-import { t } from '../i18n.js';
-import { createSpinner } from '../util/spinner.js';
-import { newClient } from './shared.js';
-function resolveTaskId(target) {
-    if (target.startsWith('@')) {
-        const entry = resolveReference(target);
-        if (entry)
-            return entry.task_id;
-    }
-    return target;
-}
-function humanTask(task) {
-    const lines = [
-        `${task.task_id}  ${task.type}  ${task.status}${typeof task.progress === 'number' ? ` ${task.progress}%` : ''}`,
-    ];
-    if (task.credits_consumed !== undefined)
-        lines.push(t({ zh: `消耗积分 ${task.credits_consumed}`, en: `credits ${task.credits_consumed}` }));
-    const output = task.output ?? {};
-    for (const [key, value] of Object.entries(output)) {
-        if (typeof value === 'string' && value.startsWith('http'))
-            lines.push(`${key}: ${value}`);
-    }
-    return lines.join('\n');
-}
-export function registerTaskCommands(program) {
-    const task = program.command('task').description('query, list, and watch tasks');
-    task
-        .command('get <task-id>')
-        .description('fetch one task (accepts @last/@name)')
-        .option('--step', 'include pipeline step details')
-        .option('--download', 'download artifacts if successful')
-        .option('-o, --out <dir>', 'output directory for --download')
-        .action(async (target, opts) => {
-        const client = new TripoClient();
-        const taskId = resolveTaskId(target);
-        const detail = await client.getTask(taskId, opts.step);
-        if (opts.download && detail.status === 'success') {
-            const entry = readHistory().find((e) => e.task_id === taskId);
-            const dir = opts.out ?? entry?.output_dir ?? defaultOutputDir(process.cwd(), entry?.name ?? 'task', taskId);
-            const artifacts = await downloadArtifacts(detail, dir);
-            emitResult({ ...detail, output_dir: artifacts.outputDir, files: artifacts.files }, `${humanTask(detail)}\n${t({ zh: `产物目录: ${artifacts.outputDir}`, en: `artifacts: ${artifacts.outputDir}` })}`);
-            return;
-        }
-        emitResult(detail, humanTask(detail));
-    });
-    task
-        .command('list [task-ids...]')
-        .description('batch-query tasks (default: recent history)')
-        .option('--limit <n>', 'how many from history', (v) => Number(v), 10)
-        .action(async (targets, opts) => {
-        const client = new TripoClient();
-        const ids = targets.length > 0
-            ? targets.map(resolveTaskId)
-            : readHistory().slice(-opts.limit).map((e) => e.task_id);
-        if (ids.length === 0) {
-            emitResult([], t({ zh: '本地历史为空', en: 'no local history yet' }));
-            return;
-        }
-        const list = await client.listTasks(ids);
-        const human = list
-            .map((d) => `${d.task_id}  ${(d.type ?? '').padEnd(24)} ${d.status}${typeof d.progress === 'number' ? ` ${d.progress}%` : ''}`)
-            .join('\n');
-        emitResult(list, human);
-    });
-    task
-        .command('watch <task-id>')
-        .description('block until a task finishes (streams NDJSON progress in --json mode)')
-        .option('--download', 'download artifacts on success')
-        .option('-o, --out <dir>', 'output directory for --download')
-        .option('--timeout <seconds>', 'timeout in seconds', (v) => Number(v))
-        .action(async (target, opts) => {
-        const client = new TripoClient();
-        const taskId = resolveTaskId(target);
-        const spinner = isJsonMode() ? undefined : createSpinner(`watch ${taskId}`, isQuiet());
-        let lastProgress = -1;
-        const detail = await watchTask(client, taskId, {
-            timeoutMs: opts.timeout ? opts.timeout * 1000 : undefined,
-            onProgress: (d) => {
-                if (spinner) {
-                    spinner.update(`${d.type ?? 'task'} · ${d.status}${typeof d.progress === 'number' ? ` ${d.progress}%` : ''}`);
-                }
-                else if (isJsonMode() && typeof d.progress === 'number' && d.progress !== lastProgress) {
-                    lastProgress = d.progress;
-                    emitNdjson({ event: 'progress', task_id: d.task_id, status: d.status, progress: d.progress });
-                }
-            },
-        });
-        spinner?.succeed(`${detail.type} · success`);
-        updateHistoryStatus(taskId, detail.status, { credits_consumed: detail.credits_consumed });
-        if (opts.download) {
-            const entry = readHistory().find((e) => e.task_id === taskId);
-            const dir = opts.out ?? entry?.output_dir ?? defaultOutputDir(process.cwd(), entry?.name ?? 'task', taskId);
-            log(t({ zh: '下载产物…', en: 'downloading artifacts…' }));
-            const artifacts = await downloadArtifacts(detail, dir);
-            emitResult({ ...detail, output_dir: artifacts.outputDir, files: artifacts.files, model_file: artifacts.modelFile, preview: artifacts.preview }, `${humanTask(detail)}\n${t({ zh: `产物目录: ${artifacts.outputDir}`, en: `artifacts: ${artifacts.outputDir}` })}`);
-            return;
-        }
-        emitResult(detail, humanTask(detail));
-    });
-    const files = program.command('files').description('file uploads');
-    files
-        .command('upload <path>')
-        .description('upload a local image/model and print the file_token')
-        .action(async (path) => {
-        const client = newClient();
-        const token = await uploadLocalFile(client, path);
-        emitResult({ file_token: token }, token);
-    });
-    program
-        .command('history')
-        .description('recent tasks created by this CLI (@name references)')
-        .option('--limit <n>', 'rows', (v) => Number(v), 20)
-        .action((opts) => {
-        const entries = readHistory().slice(-opts.limit);
-        const human = entries
-            .map((e) => `${e.created_at.slice(0, 19)}  ${(e.name ?? '').padEnd(24)} ${e.type.padEnd(22)} ${e.status.padEnd(9)} ${e.task_id}`)
-            .join('\n');
-        emitResult(entries, human || t({ zh: '本地历史为空', en: 'no local history yet' }));
-    });
-}

package/dist/src/commands/topup.js

@@ -1,61 +0,0 @@
-/**
- * `tripo topup` — payment stays in the browser (Stripe/Alipay pages already
- * handle it); the CLI opens the billing page and then polls the balance so
- * the user sees "credits arrived" without leaving the terminal.
- */
-import { resolvePlatformBaseUrl } from '../config/config.js';
-import { sleep, TripoClient } from '../core/client.js';
-import { emitResult, log, shouldOpen } from '../core/output.js';
-import { t } from '../i18n.js';
-import { createSpinner } from '../util/spinner.js';
-import { openExternal } from '../util/open.js';
-const POLL_INTERVAL_MS = 3000;
-const POLL_TIMEOUT_MS = 10 * 60 * 1000;
-export function registerTopupCommand(program) {
-    program
-        .command('topup')
-        .description('open the billing page and watch for the credits to arrive')
-        .option('--no-watch', 'just open the page; skip balance polling')
-        .action(async (opts) => {
-        const client = new TripoClient();
-        const before = await client.getBalance();
-        const url = `${resolvePlatformBaseUrl()}/billing`;
-        if (shouldOpen()) {
-            openExternal(url);
-            log(t({ zh: `已打开充值页面: ${url}`, en: `opened the billing page: ${url}` }));
-        }
-        else {
-            log(t({ zh: `充值页面: ${url}`, en: `billing page: ${url}` }));
-        }
-        log(t({ zh: `当前余额 ${before.balance} 积分`, en: `current balance: ${before.balance} credits` }));
-        if (!opts.watch || !shouldOpen()) {
-            emitResult({ billing_url: url, balance: before.balance }, url);
-            return;
-        }
-        const spinner = createSpinner(t({ zh: '等待到账…(Ctrl+C 退出,不影响支付)', en: 'waiting for credits… (Ctrl+C is safe; payment continues in the browser)' }));
-        const deadline = Date.now() + POLL_TIMEOUT_MS;
-        let current = Number(before.balance);
-        while (Date.now() < deadline) {
-            await sleep(POLL_INTERVAL_MS);
-            try {
-                const now = await client.getBalance();
-                const value = Number(now.balance);
-                if (value > current) {
-                    spinner.succeed(t({
-                        zh: `到账 +${value - current} 积分,当前余额 ${value}`,
-                        en: `+${value - current} credits arrived; balance is now ${value}`,
-                    }));
-                    emitResult({ billing_url: url, balance: value, delta: value - current });
-                    return;
-                }
-                current = value;
-            }
-            catch {
-                // transient polling errors are fine; keep waiting
-            }
-        }
-        spinner.stop();
-        log(t({ zh: '未检测到到账(超时 10 分钟);支付完成后余额会自动生效', en: 'no balance change detected within 10 minutes; credits apply automatically once payment completes' }));
-        emitResult({ billing_url: url, balance: current });
-    });
-}