tripo-cli 0.1.0

package/dist/commands/login.js

@@ -0,0 +1,309 @@
+/**
+ * Onboarding loop: `tripo login` (device flow: browser approves, key arrives
+ * automatically; falls back to open-keys-page-and-paste), `tripo logout`,
+ * `tripo whoami`. Key precedence: TRIPO_API_KEY env > ~/.tripo/config.json.
+ */
+import * as p from '@clack/prompts';
+import { deleteApiKey, loadConfig, maskKey, REGION_DEFAULTS, resolveApiKey, resolvePlatformBaseUrl, resolveRegion, updateConfig, } from '../config/config.js';
+import { TripoClient } from '../core/client.js';
+import { DeviceAuthUnavailableError, requestDeviceCode, waitForDeviceApproval } from '../core/device-auth.js';
+import { AuthError, CliError, UsageError } from '../core/errors.js';
+import { detectRegionForKey } from '../core/region.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';
+import { createSpinner } from '../util/spinner.js';
+const LOGIN_TIMEOUT_MS = 5 * 60 * 1000;
+export function registerAuthCommands(program) {
+    program
+        .command('login')
+        .description('sign in: browser authorizes, the key arrives automatically')
+        .option('--paste', 'skip the browser flow; just paste an API key')
+        .option('--key <key>', 'provide the API key directly (tsk_...); region is auto-detected')
+        .option('--region <region>', 'ov or cn — only needed for the browser flow; auto-detected once a key exists')
+        .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 region = resolveRegion(config);
+        const client = new TripoClient();
+        const balance = await client.getBalance();
+        emitResult({
+            key: maskKey(key),
+            source,
+            region,
+            api_base_url: client.baseUrl,
+            balance: balance.balance,
+            frozen: balance.frozen,
+        }, [
+            `key      ${maskKey(key)} (${source})`,
+            `region   ${region}`,
+            `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) {
+        // Key in hand → region is detected, not asked (a key lives in exactly one region).
+        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');
+    // The browser/paste flows need a console URL *before* any key exists — the
+    // one moment region cannot be probed. So: guess from the system timezone/
+    // locale to pre-select the right option (Enter = correct for ~everyone),
+    // and even a wrong answer is harmless — it only opens the wrong console
+    // page; once a key is in hand it is probed against both regions and the
+    // key's real region wins.
+    if (!region) {
+        const answer = await p.select({
+            message: t({
+                zh: '你的账号在哪个站?(选错没关系,验证 Key 时会自动纠正)',
+                en: 'Where is your account? (a wrong pick self-corrects once the key is verified)',
+            }),
+            initialValue: guessRegion(),
+            options: [
+                { value: 'ov', label: t({ zh: '海外站 developers.tripo3d.ai(Stripe 支付)', en: 'International — developers.tripo3d.ai (Stripe)' }) },
+                { value: 'cn', label: t({ zh: '国内站 developers.tripo3d.com(支付宝)', en: 'China mainland — developers.tripo3d.com (Alipay)' }) },
+            ],
+        });
+        if (p.isCancel(answer))
+            throw new CliError('cancelled', EXIT.FATAL);
+        region = answer;
+    }
+    const key = opts.paste ? await keyFromConsole(region, false) : await deviceFlowWithFallback(region);
+    await validateAndSave(key, region);
+    p.outro(t({
+        zh: '登录完成!试试: tripo make "一只可爱的机器人"',
+        en: 'logged in! try: tripo make "a cute robot"',
+    }));
+}
+/**
+ * Preferred path: RFC 8628 device flow — the browser does the sign-in and a
+ * one-click approve, the key arrives over the CLI↔console-API channel, and
+ * nothing is ever pasted. Falls back to the open-/keys-and-paste flow when
+ * the backend feature flag is off (endpoints 404) or the console API is
+ * unreachable, so login never hard-fails on a backend rollout state.
+ */
+async function deviceFlowWithFallback(region) {
+    let grant;
+    try {
+        grant = await requestDeviceCode(region);
+    }
+    catch (err) {
+        if (err instanceof DeviceAuthUnavailableError) {
+            if (err.kind === 'backend_error') {
+                // Deployed but broken: fall back so the user is not blocked, but
+                // report the failure loudly — a masked 5xx is undebuggable.
+                warn(t({
+                    zh: `浏览器授权服务故障(${err.message}),请把此错误报给平台;已改用粘贴方式登录`,
+                    en: `device authorization backend error (${err.message}) — please report this; falling back to paste login`,
+                }));
+            }
+            else {
+                log(t({ zh: '浏览器授权服务暂未开通,改用粘贴方式登录', en: 'device authorization not available yet — falling back to paste login' }));
+            }
+            return keyFromConsole(region, true);
+        }
+        throw err;
+    }
+    // Guidance before the browser steals focus: the code and the exact steps
+    // must already be on screen when the user lands on the login page — the
+    // page deliberately never pre-fills the code (anti-phishing), so typing it
+    // is the one thing the user has to do and the one thing we spell out.
+    p.note(grant.user_code, t({ zh: '你的终端码', en: 'Your one-time code' }));
+    const willOpen = shouldOpen();
+    log(t({
+        zh: [
+            '接下来三步:',
+            willOpen ? '  1. 浏览器即将打开授权页面(如未登录,先登录或注册 Tripo 账号)' : `  1. 在浏览器打开: ${grant.verification_url_complete}(如未登录,先登录或注册)`,
+            `  2. 在页面的「Verification code」输入框填入终端码: ${grant.user_code}`,
+            '  3. 点击「Authorize」完成授权,回到这个终端等待即可',
+        ].join('\n'),
+        en: [
+            'Three steps:',
+            willOpen ? '  1. your browser will open the authorization page (sign in or sign up first if needed)' : `  1. open in a browser: ${grant.verification_url_complete} (sign in or sign up first if needed)`,
+            `  2. type this one-time code into the "Verification code" field: ${grant.user_code}`,
+            '  3. click "Authorize", then come back to this terminal and wait',
+        ].join('\n'),
+    }));
+    if (willOpen) {
+        openExternal(grant.verification_url_complete);
+        log(t({ zh: `(浏览器未弹出?手动访问: ${grant.verification_url_complete})`, en: `(browser didn't open? visit: ${grant.verification_url_complete})` }));
+    }
+    const spinner = createSpinner(t({
+        zh: `等待网页授权… 终端码 ${grant.user_code}(Ctrl+C 取消,或改用 tripo login --paste)`,
+        en: `waiting for approval… code ${grant.user_code} (Ctrl+C to cancel, or use tripo login --paste)`,
+    }));
+    const result = await waitForDeviceApproval(region, grant);
+    if (result.status === 'approved') {
+        spinner.succeed(t({ zh: '网页授权完成', en: 'authorization approved' }));
+        return result.apikey;
+    }
+    spinner.stop();
+    if (result.status === 'denied') {
+        throw new CliError(t({ zh: '授权被拒绝;重新运行 tripo login 再试', en: 'authorization denied — run tripo login to try again' }), EXIT.AUTH);
+    }
+    throw new CliError(t({
+        zh: '授权超时或已过期;重新运行 tripo login,或改用 tripo login --paste 粘贴 Key',
+        en: 'authorization expired — run tripo login again, or use tripo login --paste',
+    }), EXIT.AUTH);
+}
+function normalizeRegion(value) {
+    if (value === undefined)
+        return undefined;
+    if (value === 'ov' || value === 'cn')
+        return value;
+    throw new UsageError('--region must be ov or cn');
+}
+/**
+ * Pre-key region guess for the login prompt's default option. Mainland
+ * timezone or zh_CN locale → cn, everything else → ov. Only positions the
+ * cursor — never decides silently (expats and cross-region accounts exist).
+ */
+export function guessRegion(timeZone = safeTimeZone(), lang = process.env.LC_ALL || process.env.LANG || '') {
+    if (/^Asia\/(Shanghai|Chongqing|Urumqi|Harbin)$/i.test(timeZone))
+        return 'cn';
+    if (/zh_CN/i.test(lang))
+        return 'cn';
+    return 'ov';
+}
+function safeTimeZone() {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone ?? '';
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Fallback path: get a key from the console's API Keys page — open it in the
+ * browser (unless --paste / --no-open), then wait for the user to paste the
+ * key back. Used when the device-auth endpoints are not deployed/reachable,
+ * and directly via `tripo login --paste`. Sign-in method differences (ov:
+ * email-first; cn: +86 SMS-first) live entirely on the website either way.
+ */
+async function keyFromConsole(region, openBrowser) {
+    const keysUrl = `${platformUrlFor(region)}/keys`;
+    if (openBrowser && shouldOpen()) {
+        openExternal(keysUrl);
+        log(t({ zh: `已打开控制台 API Keys 页面(未弹出请手动访问):\n  ${keysUrl}`, en: `opened the console API Keys page (visit manually if it didn't open):\n  ${keysUrl}` }));
+    }
+    else {
+        log(t({ zh: `请访问: ${keysUrl}`, en: `visit: ${keysUrl}` }));
+    }
+    log(t({
+        zh: `在网页上登录并创建/复制 Key,回来粘贴(新用户注册可领免费额度;选错站?Ctrl+C 后运行 tripo login --region ${region === 'cn' ? 'ov' : 'cn'})`,
+        en: `sign in on the page, create/copy a key, then paste it here (new accounts get free credits; wrong site? Ctrl+C and run: tripo login --region ${region === 'cn' ? 'ov' : 'cn'})`,
+    }));
+    const pastePromise = 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_' })),
+    })
+        .then((v) => {
+        if (p.isCancel(v))
+            throw new CliError('cancelled', EXIT.FATAL);
+        return v.trim();
+    });
+    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new CliError(t({ zh: '登录超时(5 分钟)', en: 'login timed out (5 minutes)' }), EXIT.AUTH)), LOGIN_TIMEOUT_MS));
+    try {
+        return await Promise.race([pastePromise, timeoutPromise]);
+    }
+    finally {
+        // Ensure the pending clack prompt does not hold the process open on timeout.
+        process.stdin.pause();
+    }
+}
+/**
+ * Validate the key and persist it together with its *actual* region.
+ *
+ * With a custom TRIPO_API_BASE_URL the region concept does not apply (the
+ * caller owns routing), so we validate against that URL directly. Otherwise
+ * we probe both regions with the key — the probe doubles as validation, and
+ * its verdict beats whatever the user selected, so a wrong region choice
+ * self-heals instead of producing a config that 401s on every call.
+ */
+async function validateAndSave(key, selectedRegion) {
+    if (process.env.TRIPO_API_BASE_URL) {
+        const client = new TripoClient({ apiKey: key });
+        try {
+            const balance = await client.getBalance();
+            finishSave(key, selectedRegion ?? 'ov', balance.balance);
+        }
+        catch (err) {
+            throw asAuthError(err);
+        }
+        return;
+    }
+    const detected = await detectRegionForKey(key);
+    if (!detected) {
+        throw new AuthError(t({
+            zh: 'Key 验证失败:国内(openapi.tripo3d.com)和海外(openapi.tripo3d.ai)都不接受这把 Key — 无效或已被删除',
+            en: 'key validation failed: rejected by both cn (openapi.tripo3d.com) and ov (openapi.tripo3d.ai) — invalid or deleted',
+        }));
+    }
+    if (selectedRegion && selectedRegion !== detected.region) {
+        warn(t({
+            zh: `这把 Key 属于${detected.region === 'cn' ? '国内' : '海外'}站,已自动切换 region=${detected.region}(你选的 ${selectedRegion} 不生效)`,
+            en: `this key belongs to the ${detected.region} region — auto-switched (your choice "${selectedRegion}" was wrong)`,
+        }));
+    }
+    finishSave(key, detected.region, detected.balance.balance);
+}
+function finishSave(key, region, balance) {
+    updateConfig({ api_key: key, region });
+    success(t({
+        zh: `Key 验证通过(region=${region}),当前余额 ${balance} 积分(已保存到 ~/.tripo/config.json,权限 0600)`,
+        en: `key verified (region=${region}); balance ${balance} credits (saved to ~/.tripo/config.json, mode 0600)`,
+    }));
+    if (Number(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"',
+        }));
+    }
+}
+function asAuthError(err) {
+    if (err instanceof CliError && err.exitCode === EXIT.AUTH) {
+        return new AuthError(t({ zh: 'Key 验证失败:无效或已被删除', en: 'key validation failed: invalid or deleted' }));
+    }
+    return err instanceof Error ? err : new Error(String(err));
+}
+function platformUrlFor(region) {
+    return process.env.TRIPO_PLATFORM_BASE_URL || REGION_DEFAULTS[region].platform;
+}

package/dist/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/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,
+        };
+    }
+}