tripo-cli 0.1.0

package/dist/src/commands/login.js

@@ -0,0 +1,225 @@
+/**
+ * Onboarding loop: `tripo login` (browser flow with paste fallback),
+ * `tripo logout`, `tripo whoami`. Key precedence: TRIPO_API_KEY env >
+ * ~/.tripo/config.json.
+ */
+import { randomBytes } from 'node:crypto';
+import { createServer } from 'node:http';
+import { hostname } from 'node:os';
+import * as p from '@clack/prompts';
+import { deleteApiKey, loadConfig, maskKey, REGION_DEFAULTS, resolveApiKey, resolvePlatformBaseUrl, updateConfig, } from '../config/config.js';
+import { TripoClient } from '../core/client.js';
+import { AuthError, CliError, UsageError } from '../core/errors.js';
+import { emitResult, isInteractive, log, shouldOpen, success, warn } from '../core/output.js';
+import { t } from '../i18n.js';
+import { EXIT } from '../knowledge/error-catalog.js';
+import { openExternal } from '../util/open.js';
+const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
+export function registerAuthCommands(program) {
+    program
+        .command('login')
+        .description('sign in: browser flow (default) or paste an API key')
+        .option('--paste', 'paste an API key instead of using the browser')
+        .option('--key <key>', 'provide the API key directly (tsk_...)')
+        .option('--region <region>', 'ov (international) or cn (China mainland)')
+        .action(async (opts) => {
+        await runLogin(opts);
+    });
+    program
+        .command('logout')
+        .description('remove the locally stored API key')
+        .action(() => {
+        const config = loadConfig();
+        if (!config.api_key) {
+            log(t({ zh: '本地没有存储 API Key', en: 'no API key stored locally' }));
+        }
+        else {
+            deleteApiKey();
+            success(t({ zh: '已删除本地 API Key', en: 'local API key removed' }));
+        }
+        log(t({
+            zh: `如需吊销 Key 本身,请前往 ${resolvePlatformBaseUrl()} 的 API Keys 页面`,
+            en: `to revoke the key itself, visit the API Keys page at ${resolvePlatformBaseUrl()}`,
+        }));
+    });
+    program
+        .command('whoami')
+        .description('show the active key (masked), region, and balance')
+        .action(async () => {
+        const config = loadConfig();
+        const key = resolveApiKey(config);
+        if (!key)
+            throw new AuthError(t({ zh: '未配置 API Key', en: 'no API key configured' }));
+        const source = process.env.TRIPO_API_KEY ? 'env:TRIPO_API_KEY' : '~/.tripo/config.json';
+        const client = new TripoClient();
+        const balance = await client.getBalance();
+        emitResult({
+            key: maskKey(key),
+            source,
+            region: config.region ?? 'ov',
+            api_base_url: client.baseUrl,
+            balance: balance.balance,
+            frozen: balance.frozen,
+        }, [
+            `key      ${maskKey(key)} (${source})`,
+            `region   ${config.region ?? 'ov'}`,
+            `api      ${client.baseUrl}`,
+            t({ zh: `余额     ${balance.balance} 积分(冻结 ${balance.frozen})`, en: `balance  ${balance.balance} credits (${balance.frozen} frozen)` }),
+        ].join('\n'));
+    });
+}
+export async function runLogin(opts) {
+    let region = normalizeRegion(opts.region);
+    if (opts.key) {
+        region ??= 'ov';
+        await validateAndSave(opts.key, region);
+        return;
+    }
+    if (!isInteractive()) {
+        throw new UsageError(t({
+            zh: '非交互环境请用 TRIPO_API_KEY 环境变量或 tripo login --key tsk_...',
+            en: 'in non-interactive environments use the TRIPO_API_KEY env var or "tripo login --key tsk_..."',
+        }));
+    }
+    p.intro('tripo login');
+    if (!region) {
+        const answer = await p.select({
+            message: t({ zh: '选择服务区域', en: 'Choose your region' }),
+            options: [
+                { value: 'ov', label: t({ zh: '海外 (api: openapi.tripo3d.ai)', en: 'International (openapi.tripo3d.ai)' }) },
+                { value: 'cn', label: t({ zh: '中国大陆 (api: openapi.tripo3d.com)', en: 'China mainland (openapi.tripo3d.com)' }) },
+            ],
+        });
+        if (p.isCancel(answer))
+            throw new CliError('cancelled', EXIT.FATAL);
+        region = answer;
+    }
+    const key = opts.paste ? await pasteFlow(region) : await browserFlow(region);
+    await validateAndSave(key, region);
+    p.outro(t({
+        zh: '登录完成!试试: tripo make "一只可爱的机器人"',
+        en: 'logged in! try: tripo make "a cute robot"',
+    }));
+}
+function normalizeRegion(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === 'ov' || value === 'cn')
+        return value;
+    throw new UsageError('--region must be ov or cn');
+}
+async function pasteFlow(region) {
+    const platform = platformUrlFor(region);
+    log(t({
+        zh: `在 ${platform} 的「API Keys」页面创建 Key(新用户注册可领免费额度)`,
+        en: `create a key on the "API Keys" page at ${platform} (new accounts get free credits)`,
+    }));
+    const answer = await p.password({
+        message: t({ zh: '粘贴你的 API Key (tsk_...)', en: 'Paste your API key (tsk_...)' }),
+        validate: (v) => (v && v.trim().startsWith('tsk_') ? undefined : t({ zh: 'Key 应以 tsk_ 开头', en: 'keys start with tsk_' })),
+    });
+    if (p.isCancel(answer))
+        throw new CliError('cancelled', EXIT.FATAL);
+    return answer.trim();
+}
+/**
+ * Browser flow (gh-auth style): open <platform>/cli-auth?state=...&callback=…
+ * and wait for the page to POST/GET the new key back to localhost. Races
+ * against manual paste so the flow still works before the platform page
+ * ships (graceful degradation, zero backend changes required).
+ */
+async function browserFlow(region) {
+    const platform = platformUrlFor(region);
+    const state = randomBytes(16).toString('hex');
+    const { server, port, keyPromise } = await startCallbackServer(state);
+    try {
+        const authUrl = `${platform}/cli-auth?state=${state}&callback=${encodeURIComponent(`http://127.0.0.1:${port}/callback`)}&name=${encodeURIComponent(`CLI - ${hostname()}`)}`;
+        if (shouldOpen()) {
+            openExternal(authUrl);
+            log(t({ zh: `已打开浏览器登录页(未弹出请手动访问):\n  ${authUrl}`, en: `opened the browser login page (visit manually if it didn't open):\n  ${authUrl}` }));
+        }
+        else {
+            log(t({ zh: `请访问: ${authUrl}`, en: `visit: ${authUrl}` }));
+        }
+        log(t({
+            zh: '等待浏览器完成登录…(也可以直接在下方粘贴 Key)',
+            en: 'waiting for the browser… (or paste a key below instead)',
+        }));
+        const pastePromise = p
+            .password({
+            message: t({ zh: '或直接粘贴 API Key (tsk_...)', en: 'or paste an API key (tsk_...)' }),
+        })
+            .then((v) => {
+            if (p.isCancel(v))
+                throw new CliError('cancelled', EXIT.FATAL);
+            const trimmed = v.trim();
+            if (!trimmed.startsWith('tsk_'))
+                throw new UsageError(t({ zh: 'Key 应以 tsk_ 开头', en: 'keys start with tsk_' }));
+            return trimmed;
+        });
+        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new CliError(t({ zh: '登录超时(5 分钟)', en: 'login timed out (5 minutes)' }), EXIT.AUTH)), LOGIN_TIMEOUT_MS));
+        return await Promise.race([keyPromise, pastePromise, timeoutPromise]);
+    }
+    finally {
+        server.close();
+        // Ensure the pending clack prompt does not hold the process open.
+        process.stdin.pause();
+    }
+}
+function startCallbackServer(state) {
+    let resolveKey;
+    const keyPromise = new Promise((resolve) => (resolveKey = resolve));
+    const server = createServer((req, res) => {
+        const url = new URL(req.url ?? '/', 'http://localhost');
+        if (url.pathname !== '/callback') {
+            res.writeHead(404);
+            res.end();
+            return;
+        }
+        const gotState = url.searchParams.get('state');
+        const key = url.searchParams.get('key') ?? url.searchParams.get('api_key');
+        if (gotState !== state || !key || !key.startsWith('tsk_')) {
+            res.writeHead(400, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end('<h3>Invalid login callback. Return to the terminal and try again.</h3>');
+            return;
+        }
+        res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+        res.end('<h3>✓ Tripo CLI login complete. You can close this tab and return to the terminal.</h3>');
+        resolveKey(key);
+    });
+    return new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(0, '127.0.0.1', () => {
+            const address = server.address();
+            const port = typeof address === 'object' && address ? address.port : 0;
+            resolve({ server, port, keyPromise });
+        });
+    });
+}
+async function validateAndSave(key, region) {
+    const config = updateConfig({ region });
+    const client = new TripoClient({ apiKey: key });
+    try {
+        const balance = await client.getBalance();
+        updateConfig({ ...config, api_key: key, region });
+        success(t({
+            zh: `Key 验证通过,当前余额 ${balance.balance} 积分(已保存到 ~/.tripo/config.json,权限 0600)`,
+            en: `key verified; balance ${balance.balance} credits (saved to ~/.tripo/config.json, mode 0600)`,
+        }));
+        if (Number(balance.balance) === 0) {
+            warn(t({
+                zh: '余额为 0:新账号可在控制台领取免费额度,或运行 tripo topup 充值',
+                en: 'balance is 0: claim free credits in the console for new accounts, or run "tripo topup"',
+            }));
+        }
+    }
+    catch (err) {
+        if (err instanceof CliError && err.exitCode === EXIT.AUTH) {
+            throw new AuthError(t({ zh: 'Key 验证失败:无效或已被删除', en: 'key validation failed: invalid or deleted' }));
+        }
+        throw err;
+    }
+}
+function platformUrlFor(region) {
+    return process.env.TRIPO_PLATFORM_BASE_URL || REGION_DEFAULTS[region].platform;
+}

package/dist/src/commands/make.js

@@ -0,0 +1,142 @@
+/**
+ * `tripo make` — the magic command. Give it anything (a sentence, an image,
+ * 2–4 views, a model file, or @last/task id) and it picks the endpoint, the
+ * model, the parameters, runs the chain, and downloads the artifacts.
+ */
+import * as p from '@clack/prompts';
+import { UsageError } from '../core/errors.js';
+import { emitResult, isInteractive, log, warn } from '../core/output.js';
+import { t } from '../i18n.js';
+import { scenarioIds } from '../knowledge/scenarios.js';
+import { executeMake, planMake } from '../pipeline/make.js';
+import { newClient, parseChainFlag, printTaskResult, withTaskOptions } from './shared.js';
+import { printInlineImage } from '../util/term-image.js';
+export function registerMakeCommand(program) {
+    const cmd = program
+        .command('make')
+        .description('turn text / images / a model file / a task ref into 3D artifacts (the magic command)')
+        .argument('<input...>', 'prompt text, image file(s), model file, URL, task id, or @last')
+        .option('--for <scenario>', `scenario preset: ${scenarioIds().join('|')}`)
+        .option('--then <steps>', 'processing chain, e.g. "texture,rig,convert:fbx"')
+        .option('--model <model>', 'force model version (tripo-v3.1 / tripo-p1 / ...)')
+        .option('-n, --candidates <n>', 'generate N candidates in parallel', (v) => Number(v), 1)
+        .option('--seed <n>', 'model_seed for reproducible geometry', (v) => Number(v));
+    withTaskOptions(cmd);
+    cmd.action(async (inputs, flags) => {
+        const result = await runMake(inputs, flags);
+        emitMakeOutcome(result);
+    });
+}
+export async function runMake(inputs, flags) {
+    const client = newClient();
+    const params = { ...flags.param };
+    if (flags.seed !== undefined)
+        params.model_seed = flags.seed;
+    const options = {
+        inputs,
+        scenario: flags.for,
+        chain: parseChainFlag(flags.then),
+        model: flags.model,
+        params,
+        name: flags.name,
+        outDir: flags.out,
+        noWait: flags.wait === false,
+        noDownload: flags.download === false,
+        notify: flags.notify,
+        timeoutMs: flags.timeout ? flags.timeout * 1000 : undefined,
+    };
+    const n = flags.candidates;
+    if (n <= 1) {
+        const plan = await planMake(client, options);
+        const outcome = await executeMake(client, plan, options);
+        return { results: [outcome.primary], chainResults: outcome.chainResults, stoppedEarly: outcome.stoppedEarly };
+    }
+    // -n candidates: N parallel generations with distinct seeds.
+    if (n > 4)
+        throw new UsageError('at most 4 candidates per run (-n 4)');
+    const basePlan = await planMake(client, options);
+    if (!basePlan.generation) {
+        throw new UsageError('-n only applies to generation inputs (text/image), not task references');
+    }
+    const chain = basePlan.chain;
+    const interactive = isInteractive();
+    if (chain.length > 0 && !interactive) {
+        throw new UsageError('-n with --then needs an interactive terminal to pick the winner; run the chain afterwards with "tripo make <task-id> --then ..."');
+    }
+    log(t({ zh: `并行生成 ${n} 个候选…`, en: `generating ${n} candidates in parallel…` }));
+    const seeds = Array.from({ length: n }, () => Math.floor(Math.random() * 2 ** 31));
+    const runs = seeds.map((seed, i) => (async () => {
+        const candidateOptions = {
+            ...options,
+            chain: [],
+            params: { ...params, model_seed: seed },
+            name: `${flags.name ?? inputs[0] ?? 'make'}-c${i + 1}`,
+        };
+        const plan = await planMake(client, candidateOptions);
+        plan.chain = [];
+        return executeMake(client, plan, candidateOptions);
+    })());
+    const settled = await Promise.allSettled(runs);
+    const results = [];
+    for (const s of settled) {
+        if (s.status === 'fulfilled')
+            results.push(s.value.primary);
+        else
+            warn(String(s.reason instanceof Error ? s.reason.message : s.reason));
+    }
+    if (results.length === 0)
+        throw new UsageError('all candidates failed');
+    for (const r of results) {
+        if (r.preview)
+            printInlineImage(r.preview);
+    }
+    let chainResults = [];
+    let stoppedEarly;
+    if (chain.length > 0 && interactive) {
+        const pick = await p.select({
+            message: t({ zh: '选择一个候选继续加工链', en: 'pick a candidate to continue the chain' }),
+            options: results.map((r, i) => ({
+                value: r.task_id,
+                label: `#${i + 1} ${r.task_id.slice(0, 8)} ${r.output_dir ?? ''}`,
+            })),
+        });
+        if (!p.isCancel(pick)) {
+            const winner = results.find((r) => r.task_id === pick);
+            const { runChain } = await import('../pipeline/runner.js');
+            const chainRun = await runChain({
+                client,
+                chain,
+                sourceTaskId: winner.task_id,
+                sourceType: winner.type,
+                namePrefix: flags.name ?? 'make',
+                outDir: flags.out,
+                timeoutMs: options.timeoutMs,
+            });
+            chainResults = chainRun.results;
+            stoppedEarly = chainRun.stoppedEarly;
+        }
+    }
+    return { results, chainResults, stoppedEarly };
+}
+export function emitMakeOutcome(outcome) {
+    const finalChain = outcome.chainResults[outcome.chainResults.length - 1];
+    if (outcome.results.length === 1) {
+        const primary = outcome.results[0];
+        const merged = finalChain
+            ? { ...finalChain, chain: undefined, source_task_id: primary.task_id }
+            : primary;
+        if (outcome.chainResults.length > 0)
+            merged.chain = outcome.chainResults;
+        if (outcome.stoppedEarly)
+            merged.stopped_early = outcome.stoppedEarly;
+        printTaskResult(merged);
+        if (merged.preview)
+            printInlineImage(merged.preview);
+    }
+    else {
+        const human = outcome.results
+            .map((r, i) => `#${i + 1} ${r.task_id} ${r.output_dir ?? r.status}`)
+            .join('\n');
+        emitResult({ candidates: outcome.results, chain: outcome.chainResults }, human);
+    }
+}

package/dist/src/commands/mcp.js

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