tripo-cli 0.5.0 → 0.5.1

package/README.md

@@ -40,6 +40,7 @@ Works with both Tripo regions from the same install — international (`openapi.
 | `tripo files upload` | upload a file, print the `file_token` |
 | `tripo batch run <manifest.yaml>` | bulk pipelines with concurrency, retries, and resume |
 | `tripo config / doctor` | settings (global + per-directory `.tripo/context.json`) and self-diagnosis |
+| `tripo update [--check]` | upgrade to the latest release (`npm install -g tripo-cli@latest`); every command also hints when a newer version exists |
 | `tripo docs [--topic t]` | print the bundled agent/skill docs (`--topic commands/generate` has the model versions / P series table) |
 | `tripo mcp` | run as an MCP server (Cursor / Claude Desktop) |
 | `tripo completion <shell>` | bash/zsh/fish completion |
@@ -103,6 +104,8 @@ tripo batch run assets.yaml --concurrency 2
 | `TRIPO_REGION` | `ov` or `cn` — normally unnecessary: `tripo login` probes both regions with your key and stores the right one automatically |
 | `TRIPO_API_BASE_URL` / `TRIPO_PLATFORM_BASE_URL` | endpoint overrides |
 | `TRIPO_HOME` | config/history directory (default `~/.tripo`) |
+| `TRIPO_NO_UPDATE_CHECK` | disable the startup "new version available" hint (also off when `CI` is set, headless, or `--json`) |
+| `TRIPO_NPM_REGISTRY` | npm registry used by `tripo update` and the version check (default `https://registry.npmjs.org`; e.g. a mirror) |
 | `HTTPS_PROXY` / `HTTP_PROXY` / `NO_PROXY` | standard proxy variables, honored for all CLI traffic (plain Node fetch ignores them) |
 | `TRIPO_LLM_BASE_URL` / `TRIPO_LLM_API_KEY` / `TRIPO_LLM_MODEL` | optional OpenAI-compatible LLM for `tripo ai` conversation mode |
 

package/dist/commands/completion.js

@@ -5,7 +5,7 @@ const COMMANDS = [
     'login', 'logout', 'whoami', 'use', 'balance', 'usage', 'topup',
     'make', 'view', 'redo', 'ai',
     'generate', 'model', 'anim', 'mesh', 'task', 'files', 'batch', 'history',
-    'config', 'doctor', 'docs', 'completion', 'mcp',
+    'config', 'doctor', 'update', 'docs', 'completion', 'mcp',
 ];
 const SUBS = {
     generate: ['text-to-model', 'image-to-model', 'multiview-to-model', 'text-to-image', 'image-to-image', 'image-to-multiview', 'edit-multiview', 'image-to-splat'],

package/dist/commands/update.js

@@ -0,0 +1,138 @@
+/**
+ * `tripo update` — self-update via npm, plus the startup "new version
+ * available" hint (like Claude Code / Codex CLI).
+ *
+ * The startup check never blocks a command: it reads a 24h cache at
+ * ~/.tripo/update-check.json and only refreshes it in the background when
+ * stale. The hint is printed to stderr, TTY-only, and never in --json mode,
+ * so agents and pipes are unaffected.
+ */
+import { spawn } from 'node:child_process';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import pc from 'picocolors';
+import { tripoHome } from '../config/config.js';
+import { CliError, NetworkError } from '../core/errors.js';
+import { emitResult, isJsonMode, log, success } from '../core/output.js';
+import { t } from '../i18n.js';
+import { EXIT } from '../knowledge/error-catalog.js';
+import { cliVersion } from '../version.js';
+const PACKAGE_NAME = 'tripo-cli';
+const CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
+const FETCH_TIMEOUT_MS = 3000;
+function registryUrl() {
+    const base = process.env.TRIPO_NPM_REGISTRY || 'https://registry.npmjs.org';
+    return `${base.replace(/\/+$/, '')}/${PACKAGE_NAME}/latest`;
+}
+function cachePath() {
+    return join(tripoHome(), 'update-check.json');
+}
+function readCache() {
+    try {
+        const raw = JSON.parse(readFileSync(cachePath(), 'utf8'));
+        if (typeof raw.checked_at === 'number' && typeof raw.latest === 'string')
+            return raw;
+    }
+    catch { }
+    return undefined;
+}
+function writeCache(latest) {
+    try {
+        mkdirSync(tripoHome(), { recursive: true, mode: 0o700 });
+        writeFileSync(cachePath(), JSON.stringify({ checked_at: Date.now(), latest }) + '\n');
+    }
+    catch { }
+}
+/** Numeric major.minor.patch comparison; pre-release tags are ignored. */
+export function isNewerVersion(candidate, current) {
+    const parse = (v) => v.replace(/^v/, '').split('-')[0].split('.').map((x) => Number(x) || 0);
+    const a = parse(candidate);
+    const b = parse(current);
+    for (let i = 0; i < 3; i++) {
+        if ((a[i] ?? 0) !== (b[i] ?? 0))
+            return (a[i] ?? 0) > (b[i] ?? 0);
+    }
+    return false;
+}
+/** Ask the npm registry for the latest published version. */
+export async function fetchLatestVersion() {
+    const url = registryUrl();
+    let response;
+    try {
+        response = await fetch(url, { headers: { Accept: 'application/json' }, signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) });
+    }
+    catch (err) {
+        throw new NetworkError(`cannot reach the npm registry (${url}): ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (!response.ok)
+        throw new NetworkError(`npm registry answered HTTP ${response.status} for ${url}`);
+    const body = (await response.json());
+    if (typeof body.version !== 'string')
+        throw new NetworkError(`unexpected npm registry response for ${url}`);
+    writeCache(body.version);
+    return body.version;
+}
+/**
+ * Startup hook: print a one-line hint when a newer version is known.
+ * Cheap on every run (one small file read); refreshes the cache in the
+ * background at most once a day. Skipped headless, in --json mode, and when
+ * TRIPO_NO_UPDATE_CHECK is set.
+ */
+export function notifyIfOutdated() {
+    if (process.env.TRIPO_NO_UPDATE_CHECK || process.env.CI)
+        return;
+    if (isJsonMode() || !process.stderr.isTTY)
+        return;
+    const current = cliVersion();
+    const cache = readCache();
+    if (cache && isNewerVersion(cache.latest, current)) {
+        process.stderr.write(pc.yellow(t({
+            zh: `! 有新版本 tripo-cli ${cache.latest} 可用(当前 ${current}),运行 tripo update 升级`,
+            en: `! a new version of tripo-cli is available: ${cache.latest} (current ${current}) — run "tripo update" to upgrade`,
+        })) + '\n');
+    }
+    if (!cache || Date.now() - cache.checked_at > CHECK_INTERVAL_MS) {
+        // Fire-and-forget; the result shows up on the next run.
+        fetchLatestVersion().catch(() => { });
+    }
+}
+function runNpmInstall() {
+    return new Promise((resolve, reject) => {
+        const child = spawn('npm', ['install', '-g', `${PACKAGE_NAME}@latest`], {
+            stdio: 'inherit',
+            shell: process.platform === 'win32',
+        });
+        child.on('error', (err) => reject(new CliError(`failed to run npm: ${err.message}`, EXIT.FATAL)));
+        child.on('exit', (code) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new CliError(`npm install exited with code ${code}`, EXIT.FATAL, t({ zh: `手动执行: npm install -g ${PACKAGE_NAME}@latest`, en: `run manually: npm install -g ${PACKAGE_NAME}@latest` })));
+        });
+    });
+}
+export function registerUpdateCommand(program) {
+    program
+        .command('update')
+        .description('update tripo-cli to the latest version (npm install -g tripo-cli@latest)')
+        .option('--check', 'only check for a newer version; do not install')
+        .action(async (opts) => {
+        const current = cliVersion();
+        const latest = await fetchLatestVersion();
+        const available = isNewerVersion(latest, current);
+        if (!available) {
+            success(t({ zh: `已是最新版本 ${current}`, en: `already up to date (${current})` }));
+            emitResult({ current, latest, update_available: false, updated: false }, current);
+            return;
+        }
+        if (opts.check) {
+            log(t({ zh: `有新版本 ${latest} 可用(当前 ${current}),运行 tripo update 升级`, en: `new version ${latest} available (current ${current}); run "tripo update" to upgrade` }));
+            emitResult({ current, latest, update_available: true, updated: false }, `${current} → ${latest}`);
+            return;
+        }
+        log(t({ zh: `正在升级 ${current} → ${latest}…`, en: `updating ${current} → ${latest}…` }));
+        await runNpmInstall();
+        success(t({ zh: `已升级到 tripo-cli ${latest}`, en: `updated to tripo-cli ${latest}` }));
+        emitResult({ current, latest, update_available: true, updated: true }, `${current} → ${latest}`);
+    });
+}

package/dist/program.js

@@ -16,6 +16,7 @@ import { registerMcpCommand } from './commands/mcp.js';
 import { registerProcessCommands } from './commands/process-groups.js';
 import { registerTaskCommands } from './commands/task.js';
 import { registerTopupCommand } from './commands/topup.js';
+import { notifyIfOutdated, registerUpdateCommand } from './commands/update.js';
 import { registerViewCommands } from './commands/view.js';
 import { loadConfig } from './config/config.js';
 import { RefError } from './config/history.js';
@@ -55,6 +56,10 @@ export function buildProgram() {
         const lang = loadConfig().language;
         if (lang)
             setLocale(lang);
+        // Startup version hint (cached, non-blocking). `update` reports on its
+        // own; `mcp` speaks JSON-RPC over stdio and must stay silent.
+        if (actionCommand.name() !== 'update' && actionCommand.name() !== 'mcp')
+            notifyIfOutdated();
     });
     registerMakeCommand(program);
     registerAiCommand(program);
@@ -68,6 +73,7 @@ export function buildProgram() {
     registerBatchCommand(program);
     registerConfigCommands(program);
     registerDoctorCommand(program);
+    registerUpdateCommand(program);
     registerDocsCommand(program);
     registerCompletionCommand(program);
     registerMcpCommand(program);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tripo-cli",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Tripo 3D intelligent CLI — turn a prompt or an image into engine-ready 3D assets from your terminal (Tripo V3 API)",
   "keywords": [
     "tripo",