tripo-cli 0.7.2 → 0.8.0

package/dist/commands/view.js

@@ -10,7 +10,6 @@ import { downloadArtifacts, defaultOutputDir } from '../core/download.js';
 import { UsageError } from '../core/errors.js';
 import { emitResult, log, shouldOpen } from '../core/output.js';
 import { startViewer } from '../core/viewer.js';
-import { t } from '../i18n.js';
 import { runTask } from '../core/task-service.js';
 import { openExternal } from '../util/open.js';
 import { printTaskResult, newClient } from './shared.js';
@@ -26,11 +25,11 @@ export function registerViewCommands(program) {
         const handle = await startViewer(modelFile, target);
         if (shouldOpen()) {
             openExternal(handle.url);
-            log(t({ zh: `预览已打开: ${handle.url}`, en: `preview opened: ${handle.url}` }));
+            log(`preview opened: ${handle.url}`);
         }
         emitResult({ url: handle.url, model_file: modelFile }, `${handle.url}\n${modelFile}`);
         if (opts.keep || shouldOpen()) {
-            log(t({ zh: 'Ctrl+C 关闭预览服务', en: 'Ctrl+C to stop the preview server' }));
+            log('Ctrl+C to stop the preview server');
             await new Promise(() => { }); // hold until interrupted
         }
         else {
@@ -84,7 +83,7 @@ async function resolveModelFile(target) {
     const task = await client.getTask(taskId);
     if (task.status !== 'success')
         throw new UsageError(`task ${taskId} is ${task.status}, nothing to view yet`);
-    log(t({ zh: '正在下载模型用于预览…', en: 'downloading the model for preview…' }));
+    log('downloading the model for preview…');
     const dir = entry?.output_dir ?? defaultOutputDir(process.cwd(), entry?.name ?? 'view', taskId);
     const artifacts = await downloadArtifacts(task, dir);
     if (!artifacts.modelFile || !VIEWABLE.has(extname(artifacts.modelFile).toLowerCase())) {

package/dist/config/config.js

@@ -4,7 +4,7 @@
  * Multi-account model: credentials live in named *profiles* (a dict plus an
  * `active_profile` pointer — same shape as AWS CLI profiles / kubectl
  * contexts). Everything account-bound (key, region, URL overrides) is
- * per-profile; user preferences (language, llm, output dir) stay top-level.
+ * per-profile; user preferences (llm, output dir) stay top-level.
  *
  * v0.1.0 stored a single key at the top level. That format is normalized
  * into `profiles.default` on *every* load, so old files keep working

package/dist/core/analytics.js

@@ -10,10 +10,12 @@ export const ANALYTICS_APP_ID = "2908364badd34996a1cd44a5f7a71223";
 const operations = new AsyncLocalStorage();
 let activeOperation;
 let installationId;
+/** Account lookups held only in this process's memory: at most one per key per CLI command or MCP session. */
+const identities = new Map();
 const currentOperation = () => operations.getStore() ?? activeOperation;
 export function beginOperation(command, disabled = false, info, regionHint) {
     activeOperation = { command, started: Date.now(), disabled, finished: false, collectors: new Map(), regionHint, context: {
-            ...attribution(process.env.TRIPO_CLIENT_APP, process.env.TRIPO_DISTRIBUTION_CHANNEL, info),
+            ...attribution(process.env.TRIPO_CLIENT_APP, process.env.TRIPO_DISTRIBUTION_CHANNEL, info, undefined, hostClientApp()),
             distinctId: randomUUID(), operation_id: randomUUID(), integration_mode: info ? "local_mcp" : "cli",
         } };
     operations.enterWith(activeOperation);
@@ -27,8 +29,15 @@ export function identifyUser(apiKey, region, apiUrl) {
         return;
     const consoleApi = process.env.TRIPO_CONSOLE_API_BASE_URL ?? REGION_DEFAULTS[region].consoleApi;
     const key = createHash('sha256').update(JSON.stringify([region, apiUrl, consoleApi, apiKey])).digest('hex');
-    if (operation.identity?.key !== key)
-        operation.identity = { key, value: analytics.identify(apiKey, consoleApi) };
+    if (operation.identity?.key === key)
+        return;
+    let value = identities.get(key);
+    if (!value) {
+        // A CLI command ends its lookup when it finishes; an MCP session lets it outlive the tool call, for at most 10 s.
+        const signal = operation.context.integration_mode === 'local_mcp' ? AbortSignal.timeout(10_000) : (operation.lookups ??= new AbortController()).signal;
+        identities.set(key, value = analytics.identify(apiKey, consoleApi, signal));
+    }
+    operation.identity = { key, value };
 }
 function collector(region = currentOperation()?.regionHint ?? resolveRegion(), apiUrl = resolveApiBaseUrl()) {
     const operation = currentOperation();
@@ -95,6 +104,7 @@ export async function finishOperation(result, error) {
         ...(operation.context.integration_mode === 'local_mcp' ? { tool_name: operation.command } : {}),
         result, duration_ms: Date.now() - operation.started, ...(error ? errorProperties(error) : {}) });
     await flushAnalytics();
+    operation.lookups?.abort();
 }
 export function taskOrigin(model) {
     const context = analyticsContext();
@@ -136,23 +146,35 @@ export function clientApp(value) {
     if (typeof value !== "string")
         return "unknown";
     const name = value.trim().toLowerCase();
-    for (const app of ["codex", "workbuddy", "zcode", "kimi", "deepseek"]) {
-        if (new RegExp(`(^|[\\s_./-])${app}($|[\\s_./-])`).test(name))
-            return app;
-    }
-    return "unknown";
+    if (name === "dsh")
+        return "deepseek";
+    const matches = ["codex", "workbuddy", "zcode", "kimi", "deepseek", "claude", "cursor", "chatgpt"]
+        .filter((app) => new RegExp(`(^|[\\s_./():-])${app}($|[\\s_./():-])`).test(name));
+    return matches.length === 1 ? matches[0] : "unknown";
+}
+function hostClientApp() {
+    // Session markers identify the caller; install paths and terminal names do not.
+    const hosts = [];
+    if (process.env.CODEX_THREAD_ID?.trim())
+        hosts.push("codex");
+    if (process.env.ZCODE_SESSION_ID?.trim())
+        hosts.push("zcode");
+    if (process.env.CODEBUDDY_HOST === "workbuddy-desktop")
+        hosts.push("workbuddy");
+    return hosts.length === 1 ? hosts[0] : "unknown";
 }
-export function attribution(explicit, distribution, info, oauthName) {
+export function attribution(explicit, distribution, info, oauthName, hostName) {
     const tagged = clientApp(explicit);
     const initialized = clientApp(info?.name);
     const oauth = clientApp(oauthName);
-    const chosen = tagged !== "unknown" ? tagged : initialized !== "unknown" ? initialized : oauth;
+    const host = clientApp(hostName);
+    const chosen = tagged !== "unknown" ? tagged : initialized !== "unknown" ? initialized : oauth !== "unknown" ? oauth : host;
     const channels = ["codex_plugin", "workbuddy_plugin", "zcode_plugin", "kimi_plugin", "deepseek_plugin"];
     return {
         client_app: chosen,
         distribution_channel: typeof distribution === "string" && channels.includes(distribution) ? distribution : "unknown",
-        attribution_method: tagged !== "unknown" ? "explicit_tag" : initialized !== "unknown" ? "mcp_client_info" : oauth !== "unknown" ? "oauth_client_name" : "unknown",
-        attribution_conflict: [tagged, initialized, oauth].some((app) => app !== "unknown" && chosen !== app),
+        attribution_method: tagged !== "unknown" ? "explicit_tag" : initialized !== "unknown" ? "mcp_client_info" : oauth !== "unknown" ? "oauth_client_name" : host !== "unknown" ? "host_environment" : "unknown",
+        attribution_conflict: [tagged, initialized, oauth, host].some((app) => app !== "unknown" && chosen !== app),
         ...(typeof info?.version === "string" && /^[a-zA-Z0-9._+-]{1,64}$/.test(info.version) && !/tsk_|bearer|token/i.test(info.version) ? { client_version: info.version } : {}),
     };
 }
@@ -202,7 +224,7 @@ export class Analytics {
             && (testing ? env.TRIPO_ANALYTICS_ENABLED === "1" && testReceiver : officialApi || testReceiver);
         this.identityEnabled = this.enabled && (testing ? localApi : officialApi);
     }
-    async identify(apiKey, consoleApi) {
+    async identify(apiKey, consoleApi, signal = AbortSignal.timeout(1000)) {
         if (!this.identityEnabled)
             return undefined;
         try {
@@ -214,7 +236,7 @@ export class Analytics {
             const response = await fetch(url, {
                 method: "POST", headers: { "Content-Type": "application/json" },
                 body: JSON.stringify({ apikey: apiKey, with_detail: true }),
-                redirect: "error", signal: AbortSignal.timeout(1000),
+                redirect: "error", signal,
             });
             if (!response.ok)
                 return undefined;
@@ -268,9 +290,10 @@ export class Analytics {
             const deadline = Date.now() + 2000;
             while (this.queue.length && Date.now() < deadline) {
                 const batch = this.queue.splice(0, 100);
-                // Each lookup began before its event and gives up after 1 s, so this wait leaves the send at least 1 s of the budget.
+                // A lookup may outlive its events, so wait at most 1 s for it; that leaves the send at least 1 s of the budget.
+                const wait = new Promise((resolve) => setTimeout(() => resolve(undefined), 1000).unref());
                 await Promise.all(batch.map(async ({ event, identity }) => {
-                    const userId = await identity;
+                    const userId = await Promise.race([identity, wait]);
                     if (userId)
                         event.data.properties.platform_user_id = userId;
                 }));

package/dist/core/client.js

@@ -2,10 +2,10 @@
  * Lightweight V3 API client on top of global fetch (Node 20+).
  * Handles the response envelope, error translation, timeouts, and
  * exponential-backoff retries for transient failures (429/5xx/network;
- * task creation is only resent on 429).
+ * task creation is only resent on 429). A 429 waits at least as long as the
+ * server's Retry-After / X-RateLimit-Reset hint, capped at 60s per wait.
  */
 import { activeProfileName, DEFAULT_PROFILE, listProfiles, loadConfig, resolveApiBaseUrl, resolveApiKey } from '../config/config.js';
-import { t } from '../i18n.js';
 import { EXIT } from '../knowledge/error-catalog.js';
 import { ApiError, AuthError, NetworkError } from './errors.js';
 import { identifyUser, observeTask, trackEvent, taskOrigin } from './analytics.js';
@@ -27,15 +27,9 @@ export class TripoClient {
             const wanted = activeProfileName(config);
             const known = listProfiles(config).map((p) => p.name);
             if (wanted !== DEFAULT_PROFILE && !known.includes(wanted)) {
-                throw new AuthError(t({
-                    zh: `没有叫「${wanted}」的 profile${known.length ? `(现有: ${known.join(', ')})` : ''}`,
-                    en: `profile "${wanted}" not found${known.length ? ` (have: ${known.join(', ')})` : ''}`,
-                }), t({
-                    zh: `用 tripo login --profile ${wanted} 登录,或 tripo use 切换`,
-                    en: `run "tripo login --profile ${wanted}" to create it, or "tripo use" to switch`,
-                }));
+                throw new AuthError(`profile "${wanted}" not found${known.length ? ` (have: ${known.join(', ')})` : ''}`, `run "tripo login --profile ${wanted}" to create it, or "tripo use" to switch`);
             }
-            throw new AuthError(t({ zh: '未配置 API Key', en: 'no API key configured' }));
+            throw new AuthError('no API key configured');
         }
         this.apiKey = key;
         this.timeoutMs = options.timeoutMs ?? 60_000;
@@ -54,12 +48,35 @@ export class TripoClient {
         form.append('file', data, fileName);
         return this.send('POST', '/v3/files', { body: form });
     }
+    /**
+     * Large-file upload: presign, then PUT straight to storage. The PUT carries
+     * no Authorization header and no request timeout (files up to 150MB).
+     */
+    async uploadFileViaPresign(format, data) {
+        const { presigned_url, file_token } = await this.request('POST', '/v3/files/presign', { format });
+        let response;
+        try {
+            response = await fetch(presigned_url, {
+                method: 'PUT',
+                headers: { 'Content-Type': 'application/octet-stream' },
+                body: data,
+            });
+        }
+        catch (err) {
+            throw new NetworkError(`presigned upload failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        if (!response.ok)
+            throw new NetworkError(`presigned upload failed: HTTP ${response.status}`);
+        return { file_token };
+    }
     async send(method, path, init) {
         identifyUser(this.apiKey, this.region, this.baseUrl);
         let lastError;
         for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
             if (attempt > 0) {
-                const delay = Math.min(1000 * 2 ** (attempt - 1), 8000);
+                const backoff = Math.min(1000 * 2 ** (attempt - 1), 8000);
+                const hint = lastError instanceof ApiError ? (lastError.retryAfterMs ?? 0) : 0;
+                const delay = Math.min(Math.max(backoff, hint), 60_000);
                 this.onRetry?.(attempt, delay, lastError?.message ?? 'retry');
                 await sleep(delay);
             }
@@ -99,13 +116,14 @@ export class TripoClient {
         finally {
             clearTimeout(timer);
         }
+        const retryAfterMs = response.status === 429 ? retryHintMs(response.headers) : undefined;
         let envelope;
         try {
             envelope = (await response.json());
         }
         catch {
             if (!response.ok) {
-                throw new ApiError({ httpStatus: response.status, message: `HTTP ${response.status} with non-JSON body` });
+                throw new ApiError({ httpStatus: response.status, message: `HTTP ${response.status} with non-JSON body`, retryAfterMs });
             }
             throw new NetworkError(`invalid JSON response from ${path}`);
         }
@@ -116,6 +134,7 @@ export class TripoClient {
                 message: envelope.message,
                 suggestion: envelope.suggestion,
                 requestId: envelope.request_id,
+                retryAfterMs,
             });
         }
         return envelope.data;
@@ -128,18 +147,23 @@ export class TripoClient {
         return task;
     }
     /**
-     * Batch task query. The server returns `{tasks: {id: detail}, missed: [id]}`
-     * (NOT an array — the public docs are wrong here; verified against production).
+     * Batch task query, at most 100 ids per request. The server returns
+     * `{tasks: {id: detail}, missed: [id]}`.
      */
     async listTasks(taskIds) {
-        const data = await this.request('POST', '/v3/tasks/list', { task_ids: taskIds });
-        const byId = data.tasks ?? {};
+        const byId = {};
+        const missed = [];
+        for (let i = 0; i < taskIds.length; i += 100) {
+            const data = await this.request('POST', '/v3/tasks/list', { task_ids: taskIds.slice(i, i + 100) });
+            Object.assign(byId, data.tasks ?? {});
+            missed.push(...(data.missed ?? []));
+        }
         for (const [id, task] of Object.entries(byId))
             observeTask({ ...task, task_id: task.task_id ?? id }, this.region, this.baseUrl);
         const tasks = taskIds
             .filter((id) => byId[id])
             .map((id) => ({ ...byId[id], task_id: byId[id].task_id ?? id }));
-        return { tasks, missed: data.missed ?? [] };
+        return { tasks, missed };
     }
     getBalance() {
         return this.request('GET', '/v3/account/balance');
@@ -157,10 +181,8 @@ export class TripoClient {
         }
         catch (err) {
             if (err instanceof NetworkError || (err instanceof ApiError && err.exitCode === EXIT.NETWORK)) {
-                err.suggestion = t({
-                    zh: '任务可能已在服务端创建并冻结积分;重试前先用 tripo balance 查看冻结额或到控制台确认,避免重复扣费',
-                    en: 'the task may already exist server-side (credits frozen); check "tripo balance" or the console before retrying, to avoid a duplicate charge',
-                });
+                err.suggestion = 'the task may already exist server-side (credits frozen); check "tripo balance" or the console before retrying, to avoid a duplicate charge';
+                err.submissionUncertain = true;
             }
             throw err;
         }
@@ -169,3 +191,13 @@ export class TripoClient {
 export function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+/** Retry-After is in seconds; X-RateLimit-Reset is a unix timestamp in seconds. */
+function retryHintMs(headers) {
+    const after = Number(headers.get('retry-after') ?? NaN);
+    if (Number.isFinite(after))
+        return after * 1000;
+    const reset = Number(headers.get('x-ratelimit-reset') ?? NaN);
+    if (Number.isFinite(reset))
+        return Math.max(reset * 1000 - Date.now(), 0);
+    return undefined;
+}

package/dist/core/device-auth.js

@@ -8,7 +8,7 @@
  * /cli/device endpoints 404 and the caller falls back to paste login.
  */
 import { randomBytes } from 'node:crypto';
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { chmodSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import { hostname } from 'node:os';
 import { join } from 'node:path';
 import { REGION_DEFAULTS, tripoHome } from '../config/config.js';
@@ -148,6 +148,54 @@ export async function waitForDeviceApproval(region, grant, onTick) {
     trackEvent('agent_auth_result', { result: 'expired', auth_method: 'device' }, region, REGION_DEFAULTS[region].api);
     return { status: 'expired' };
 }
+/** A single poll without waiting; slow_down only means "asked too soon", so it reads as pending. */
+export async function checkDeviceApproval(region, grant) {
+    const poll = await pollDeviceToken(region, grant.device_code);
+    if (poll.status === 'pending' || poll.status === 'slow_down')
+        return { status: 'pending' };
+    trackEvent('agent_auth_result', { result: poll.status === 'approved' ? 'success' : poll.status, auth_method: 'device' }, region, REGION_DEFAULTS[region].api);
+    return poll;
+}
+/**
+ * A headless login must outlive its process: a chat agent can only relay the
+ * code by ending its turn, and its shell may be killed or suspended before the
+ * human approves. The grant is parked here (0600, removed once redeemed,
+ * denied, or expired) so the next `tripo login` resumes the code the human
+ * already has. device_code redeems the key — it never goes to stdout or logs.
+ */
+function pendingGrantFile() {
+    return join(tripoHome(), 'pending-login.json');
+}
+export function savePendingGrant(region, profile, grant) {
+    mkdirSync(tripoHome(), { recursive: true, mode: 0o700 });
+    const file = pendingGrantFile();
+    writeFileSync(file, JSON.stringify({ region, profile, expires_at: Date.now() + grant.expires_in * 1000, grant }) + '\n', { mode: 0o600 });
+    chmodSync(file, 0o600);
+}
+/** The parked grant for this region + profile, with its remaining lifetime as expires_in. */
+export function loadPendingGrant(region, profile) {
+    let saved;
+    try {
+        saved = JSON.parse(readFileSync(pendingGrantFile(), 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+    const left = Math.floor(((saved.expires_at ?? 0) - Date.now()) / 1000);
+    if (left <= 0 || typeof saved.grant?.device_code !== 'string') {
+        clearPendingGrant();
+        return undefined;
+    }
+    if (saved.region !== region || saved.profile !== profile)
+        return undefined;
+    return { ...saved.grant, expires_in: left };
+}
+export function clearPendingGrant() {
+    try {
+        unlinkSync(pendingGrantFile());
+    }
+    catch { }
+}
 /**
  * POST JSON and return the response envelope regardless of HTTP status —
  * device-auth errors (4290/4291/4292) arrive as HTTP 400/429 with a JSON

package/dist/core/download.js

@@ -11,7 +11,7 @@ import { Readable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 import { NetworkError } from './errors.js';
 import { trackEvent, errorProperties } from './analytics.js';
-const MODEL_EXTS = new Set(['.glb', '.gltf', '.fbx', '.obj', '.stl', '.3mf', '.usdz', '.zip', '.ply']);
+const MODEL_EXTS = new Set(['.glb', '.gltf', '.fbx', '.obj', '.stl', '.3mf', '.usdz', '.zip', '.ply', '.splat']);
 const IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.webp']);
 /** Collect every downloadable URL in the output map (string or {url} object). */
 export function collectOutputUrls(output) {
@@ -97,6 +97,7 @@ export async function downloadArtifacts(task, outputDir, historyEntry, options =
             status: task.status,
             input: task.input ?? historyEntry?.payload ?? {},
             output_fields: urls.map((u) => u.field),
+            normalize_scale: task.output?.normalize_scale,
             credits_consumed: task.credits_consumed,
             created_at: task.created_at,
             completed_at: task.completed_at,

package/dist/core/errors.js

@@ -1,9 +1,10 @@
 /** CLI error types carrying stable exit codes and human translations. */
-import { t } from '../i18n.js';
 import { EXIT, exitCodeFor, isRetryable, lookupError } from '../knowledge/error-catalog.js';
 export class CliError extends Error {
     exitCode;
     suggestion;
+    /** A create request failed without a response: the paid task may exist server-side. */
+    submissionUncertain;
     constructor(message, exitCode = EXIT.FATAL, suggestion) {
         super(message);
         this.exitCode = exitCode;
@@ -17,7 +18,7 @@ export class UsageError extends CliError {
 }
 export class AuthError extends CliError {
     constructor(message, suggestion) {
-        super(message, EXIT.AUTH, suggestion ?? t({ zh: '运行 tripo login 配置 API Key', en: 'run "tripo login" to configure an API key' }));
+        super(message, EXIT.AUTH, suggestion ?? 'run "tripo login" to configure an API key');
     }
 }
 export class ApiError extends CliError {
@@ -25,9 +26,13 @@ export class ApiError extends CliError {
     httpStatus;
     requestId;
     retryable;
+    /** Server wait hint on 429 (Retry-After / X-RateLimit-Reset). */
+    retryAfterMs;
     constructor(opts) {
-        const info = opts.apiCode !== undefined ? lookupError(opts.apiCode) : undefined;
-        const translated = info ? t(info) : undefined;
+        // HTTP 401 reads as an auth failure whatever code the body carries (see error-catalog).
+        const code = opts.httpStatus === 401 ? 1002 : opts.apiCode;
+        const info = code !== undefined ? lookupError(code) : undefined;
+        const translated = info?.message;
         const parts = [translated ?? opts.message ?? `API error (HTTP ${opts.httpStatus})`];
         if (translated && opts.message && opts.message !== translated)
             parts.push(`(${opts.message})`);
@@ -36,6 +41,7 @@ export class ApiError extends CliError {
         this.httpStatus = opts.httpStatus;
         this.requestId = opts.requestId;
         this.retryable = isRetryable(opts.apiCode, opts.httpStatus);
+        this.retryAfterMs = opts.retryAfterMs;
     }
 }
 export class NetworkError extends CliError {
@@ -43,17 +49,24 @@ export class NetworkError extends CliError {
         super(message, EXIT.NETWORK, suggestion);
     }
 }
+/** The task succeeded (and was billed); only fetching its artifacts failed. */
+export class ArtifactDownloadError extends NetworkError {
+    taskId;
+    result;
+    constructor(taskId, result, reason) {
+        super(`task ${taskId} succeeded but downloading its artifacts failed: ${reason}`, `the task is finished and billed; do not regenerate. Download it with "tripo task get ${taskId} --download"`);
+        this.taskId = taskId;
+        this.result = result;
+    }
+}
 export class TaskFailedError extends CliError {
     taskId;
     status;
     constructor(taskId, status, detail) {
-        const refundNote = t({
-            zh: '预扣积分已自动退还',
-            en: 'frozen credits have been refunded automatically',
-        });
+        const refundNote = 'frozen credits have been refunded automatically';
         super(
-        // A timed-out task is still running server-side: nothing has been refunded.
-        `task ${taskId} ${status}${detail ? `: ${detail}` : ''}${status === 'timeout' ? '' : ` (${refundNote})`}`, EXIT.TASK_FAILED);
+        // Only failed/cancelled tasks are refunded; a timed-out task is still running server-side.
+        `task ${taskId} ${status}${detail ? `: ${detail}` : ''}${status === 'failed' || status === 'cancelled' ? ` (${refundNote})` : ''}`, EXIT.TASK_FAILED);
         this.taskId = taskId;
         this.status = status;
     }
@@ -61,8 +74,5 @@ export class TaskFailedError extends CliError {
 /** Decorate insufficient-balance errors with the topup path and the gap. */
 export function balanceSuggestion(needed, balance) {
     const gap = needed !== undefined && balance !== undefined ? Math.max(0, needed - balance) : undefined;
-    return t({
-        zh: `运行 tripo topup 充值${gap !== undefined ? `(还差约 ${gap} 积分)` : ''}`,
-        en: `run "tripo topup" to add credits${gap !== undefined ? ` (about ${gap} more needed)` : ''}`,
-    });
+    return `run "tripo topup" to add credits${gap !== undefined ? ` (about ${gap} more needed)` : ''}`;
 }

package/dist/core/output.js

@@ -66,7 +66,3 @@ export function emitResult(data, human) {
         process.stdout.write((human ?? JSON.stringify(data, null, 2)) + '\n');
     }
 }
-/** Stream one NDJSON event to stdout (used by watch-style streaming output). */
-export function emitNdjson(event) {
-    process.stdout.write(JSON.stringify(event) + '\n');
-}