tripo-cli 0.1.0 → 0.2.0

package/README.md

@@ -31,7 +31,7 @@ Works with both Tripo regions from the same install — international (`openapi.
 | `tripo ai [description]` | plan with a wizard (no LLM needed) or multi-expert conversation (BYO LLM), confirm a plan card, execute |
 | `tripo view [task\|file]` | interactive 3D preview in your browser (local server, model-viewer) |
 | `tripo redo [task]` | re-run with a fresh seed |
-| `tripo login / logout / whoami` | device flow: browser approves, key arrives automatically (paste fallback); stored 0600 in `~/.tripo/config.json` |
+| `tripo login / logout / whoami / use` | device flow: browser approves, key arrives automatically (paste fallback); stored 0600 in `~/.tripo/config.json`; `use` switches accounts |
 | `tripo topup / balance / usage` | open the billing page + detect the credits arriving; check spend |
 | `tripo generate <endpoint>` | deterministic access to all 8 generation endpoints |
 | `tripo model / anim / mesh <step>` | refine, texture, stylize, convert, import, rig-check, rig, retarget, segment, complete, decimate, smartsegment |
@@ -43,7 +43,22 @@ Works with both Tripo regions from the same install — international (`openapi.
 | `tripo mcp` | run as an MCP server (Cursor / Claude Desktop) |
 | `tripo completion <shell>` | bash/zsh/fish completion |
 
-Every task-producing command supports `-o/--out`, `--no-wait`, `--no-download`, `--name`, `--timeout`, `--notify`, and repeatable `--param key=value` passthrough. Global flags: `--json`, `--yes`, `--quiet`, `--no-open`.
+Every task-producing command supports `-o/--out`, `--no-wait`, `--no-download`, `--name`, `--timeout`, `--notify`, and repeatable `--param key=value` passthrough. Global flags: `--json`, `--yes`, `--quiet`, `--no-open`, `--profile`.
+
+## Multiple accounts
+
+Credentials live in named profiles (one per account — e.g. a cn account and an ov account, or personal + work). Logging in never overwrites another profile's key:
+
+```bash
+tripo login                     # first account → profile "default"
+tripo login --profile work-cn   # second account, kept separately, becomes active
+tripo use                       # switch interactively (or: tripo use default)
+tripo whoami                    # shows the active profile and lists the others
+tripo make "a fox" --profile work-cn   # one-shot override, nothing sticky
+tripo logout                    # removes the *active* profile only
+```
+
+Each profile carries its own key + region, so switching accounts switches regions automatically. `TRIPO_PROFILE=work-cn` does the same as `--profile work-cn`; `TRIPO_API_KEY` bypasses profiles entirely (CI/agents). Configs written by older versions are read as the `default` profile — no migration step, nothing breaks.
 
 ## Scenario presets
 
@@ -81,7 +96,8 @@ tripo batch run assets.yaml --concurrency 2
 
 | var | meaning |
 | --- | --- |
-| `TRIPO_API_KEY` | API key (`tsk_...`), highest precedence |
+| `TRIPO_API_KEY` | API key (`tsk_...`), highest precedence (bypasses profiles) |
+| `TRIPO_PROFILE` | account profile to use, same as the global `--profile` flag |
 | `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`) |

package/dist/commands/completion.js

@@ -1,7 +1,7 @@
 /** `tripo completion <shell>` — static shell completion scripts. */
 import { UsageError } from '../core/errors.js';
 const COMMANDS = [
-    'login', 'logout', 'whoami', 'balance', 'usage', 'topup',
+    'login', 'logout', 'whoami', 'use', 'balance', 'usage', 'topup',
     'make', 'view', 'redo', 'ai',
     'generate', 'model', 'anim', 'mesh', 'task', 'files', 'batch', 'history',
     'config', 'doctor', 'docs', 'completion', 'mcp',

package/dist/commands/config-cmd.js

@@ -1,40 +1,46 @@
 /** `tripo config` — global config + directory context management. */
-import { loadConfig, maskKey, saveConfig } from '../config/config.js';
+import { activeProfileName, loadConfig, maskKey, saveConfig, updateProfile, } from '../config/config.js';
 import { findContextFile, loadContext, updateContext } from '../config/context.js';
 import { UsageError } from '../core/errors.js';
 import { emitResult, success } from '../core/output.js';
 import { coerceValue } from './shared.js';
-const SETTABLE = new Set([
-    'region',
-    'api_base_url',
-    'platform_base_url',
-    'language',
-    'default_output_dir',
-    'llm.base_url',
-    'llm.api_key',
-    'llm.model',
-]);
+/** Account-bound settings — these live in the *active profile*. */
+const PROFILE_SETTABLE = new Set(['region', 'api_base_url', 'platform_base_url']);
+/** User preferences — top-level, shared by all profiles. */
+const GLOBAL_SETTABLE = new Set(['language', 'default_output_dir', 'llm.base_url', 'llm.api_key', 'llm.model']);
+const SETTABLE = [...PROFILE_SETTABLE, ...GLOBAL_SETTABLE];
 export function registerConfigCommands(program) {
     const config = program.command('config').description('global config (~/.tripo) and directory context (.tripo)');
     config
         .command('list')
-        .description('show effective config (key masked)')
+        .description('show effective config (keys masked)')
         .action(() => {
         const cfg = loadConfig();
         const shown = {
             ...cfg,
-            api_key: cfg.api_key ? maskKey(cfg.api_key) : undefined,
+            profiles: cfg.profiles
+                ? Object.fromEntries(Object.entries(cfg.profiles).map(([name, prof]) => [
+                    name,
+                    { ...prof, api_key: prof.api_key ? maskKey(prof.api_key) : undefined },
+                ]))
+                : undefined,
             llm: cfg.llm ? { ...cfg.llm, api_key: cfg.llm.api_key ? maskKey(cfg.llm.api_key) : undefined } : undefined,
         };
         const context = loadContext();
-        emitResult({ config: shown, context, context_file: findContextFile() }, JSON.stringify({ config: shown, context }, null, 2));
+        emitResult({ config: shown, active_profile: activeProfileName(cfg), context, context_file: findContextFile() }, JSON.stringify({ config: shown, active_profile: activeProfileName(cfg), context }, null, 2));
     });
     config
         .command('set <key> <value>')
-        .description(`set a config value (${[...SETTABLE].join(', ')})`)
+        .description(`set a config value (${SETTABLE.join(', ')})`)
         .action((key, value) => {
-        if (!SETTABLE.has(key)) {
-            throw new UsageError(`unknown config key "${key}" (valid: ${[...SETTABLE].join(', ')})`);
+        if (PROFILE_SETTABLE.has(key)) {
+            const profile = activeProfileName();
+            updateProfile(profile, { [key]: coerceValue(value) }, { activate: false });
+            success(`${key} = ${value} (profile "${profile}")`);
+            return;
+        }
+        if (!GLOBAL_SETTABLE.has(key)) {
+            throw new UsageError(`unknown config key "${key}" (valid: ${SETTABLE.join(', ')})`);
         }
         const cfg = loadConfig();
         applyPath(cfg, key.split('.'), coerceValue(value));
@@ -45,6 +51,15 @@ export function registerConfigCommands(program) {
         .command('unset <key>')
         .description('remove a config value')
         .action((key) => {
+        if (PROFILE_SETTABLE.has(key)) {
+            const cfg = loadConfig();
+            const profile = activeProfileName(cfg);
+            const prof = { ...cfg.profiles?.[profile] };
+            delete prof[key];
+            saveConfig({ ...cfg, profiles: { ...cfg.profiles, [profile]: prof } });
+            success(`${key} removed (profile "${profile}")`);
+            return;
+        }
         const cfg = loadConfig();
         const parts = key.split('.');
         const parent = parts.slice(0, -1).reduce((acc, part) => (acc && typeof acc[part] === 'object' ? acc[part] : undefined), cfg);

package/dist/commands/doctor.js

@@ -2,7 +2,7 @@
 import { statSync } from 'node:fs';
 import { join } from 'node:path';
 import pc from 'picocolors';
-import { configFileExists, loadConfig, resolveApiBaseUrl, resolveApiKey, resolveRegion, tripoHome } from '../config/config.js';
+import { configFileExists, describeKeySource, listProfiles, loadConfig, resolveApiBaseUrl, resolveApiKey, resolveRegion, tripoHome } from '../config/config.js';
 import { TripoClient } from '../core/client.js';
 import { CliError } from '../core/errors.js';
 import { detectRegionForKey } from '../core/region.js';
@@ -24,14 +24,15 @@ export function registerDoctorCommand(program) {
             critical: true,
         });
         const key = resolveApiKey();
+        const profiles = listProfiles();
         checks.push({
             name: 'api key',
             ok: Boolean(key),
             detail: key
-                ? process.env.TRIPO_API_KEY
-                    ? 'from TRIPO_API_KEY env'
-                    : 'from ~/.tripo/config.json'
-                : 'missing — run "tripo login"',
+                ? `from ${describeKeySource()}${profiles.length > 1 ? ` (${profiles.length} profiles: ${profiles.map((x) => x.name).join(', ')})` : ''}`
+                : profiles.length > 0
+                    ? `active profile has no key — profiles: ${profiles.map((x) => x.name).join(', ')}; run "tripo use"`
+                    : 'missing — run "tripo login"',
             critical: true,
         });
         if (configFileExists()) {

package/dist/commands/home.js

@@ -1,7 +1,7 @@
 /** Bare `tripo` — interactive home: status, quick actions, continue last task. */
 import * as p from '@clack/prompts';
 import pc from 'picocolors';
-import { loadConfig, resolveApiKey } from '../config/config.js';
+import { activeProfileName, listProfiles, loadConfig, resolveApiKey } from '../config/config.js';
 import { readHistory } from '../config/history.js';
 import { TripoClient } from '../core/client.js';
 import { isInteractive, log } from '../core/output.js';
@@ -29,7 +29,9 @@ export function registerHomeAction(program) {
             balanceLine = t({ zh: '余额获取失败', en: 'balance unavailable' });
         }
         const last = readHistory().filter((e) => e.status === 'success').pop();
-        log(`${balanceLine}${last ? t({ zh: ` · 上次任务 @${last.name}`, en: ` · last task @${last.name}` }) : ''}`);
+        const config = loadConfig();
+        const profileNote = listProfiles(config).length > 1 ? t({ zh: ` · 账号 ${activeProfileName(config)}`, en: ` · profile ${activeProfileName(config)}` }) : '';
+        log(`${balanceLine}${profileNote}${last ? t({ zh: ` · 上次任务 @${last.name}`, en: ` · last task @${last.name}` }) : ''}`);
         const action = await p.select({
             message: t({ zh: '想做什么?', en: 'What do you want to do?' }),
             options: [

package/dist/commands/login.js

@@ -1,10 +1,15 @@
 /**
  * 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.
+ * `tripo whoami`, `tripo use` (switch between named profiles).
+ *
+ * Multi-account: every login lands in a profile (default: the active one).
+ * `tripo login --profile work` adds a second account without touching the
+ * first; `tripo use work` switches. Key precedence stays:
+ * TRIPO_API_KEY env > active profile in ~/.tripo/config.json.
  */
 import * as p from '@clack/prompts';
-import { deleteApiKey, loadConfig, maskKey, REGION_DEFAULTS, resolveApiKey, resolvePlatformBaseUrl, resolveRegion, updateConfig, } from '../config/config.js';
+import { activeProfileName, DEFAULT_PROFILE, deleteProfile, describeKeySource, isValidProfileName, listProfiles, loadConfig, maskKey, REGION_DEFAULTS, resolveApiKey, resolvePlatformBaseUrl, resolveRegion, setActiveProfile, updateProfile, } 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';
@@ -22,20 +27,28 @@ export function registerAuthCommands(program) {
         .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')
+        .option('--profile <name>', 'save into a named profile (for a second account); becomes the active profile')
         .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' }));
+        .description('remove the locally stored API key (current profile only)')
+        .option('--profile <name>', 'log out a specific profile instead of the active one')
+        .action((opts) => {
+        const name = opts.profile ?? activeProfileName();
+        if (!deleteProfile(name)) {
+            log(t({ zh: `Profile「${name}」本地没有存储 API Key`, en: `no API key stored locally for profile "${name}"` }));
         }
         else {
-            deleteApiKey();
-            success(t({ zh: '已删除本地 API Key', en: 'local API key removed' }));
+            success(t({ zh: `已删除 profile「${name}」的本地 API Key`, en: `local API key removed (profile "${name}")` }));
+            const rest = listProfiles();
+            if (rest.length > 0) {
+                log(t({
+                    zh: `其余账号仍在: ${rest.map((x) => x.name).join(', ')}(tripo use 切换)`,
+                    en: `remaining profiles: ${rest.map((x) => x.name).join(', ')} (switch with "tripo use")`,
+                }));
+            }
         }
         log(t({
             zh: `如需吊销 Key 本身,请前往 ${resolvePlatformBaseUrl()} 的 API Keys 页面`,
@@ -44,36 +57,115 @@ export function registerAuthCommands(program) {
     });
     program
         .command('whoami')
-        .description('show the active key (masked), region, and balance')
+        .description('show the active key (masked), region, balance, and other profiles')
         .action(async () => {
         const config = loadConfig();
+        // TripoClient's constructor is the single authority on "no key": it
+        // distinguishes a mistyped profile from not being logged in at all.
+        const client = new TripoClient();
         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 source = describeKeySource(config);
         const region = resolveRegion(config);
-        const client = new TripoClient();
         const balance = await client.getBalance();
+        const others = listProfiles(config).filter((x) => !x.active);
+        const lines = [
+            `key      ${maskKey(key)} (${source})`,
+            `region   ${region}`,
+            `api      ${client.baseUrl}`,
+            t({ zh: `余额     ${balance.balance} 积分(冻结 ${balance.frozen})`, en: `balance  ${balance.balance} credits (${balance.frozen} frozen)` }),
+        ];
+        if (others.length > 0) {
+            lines.push(t({
+                zh: `其它账号 ${others.map((x) => profileLabel(x.name, x.profile.region)).join(', ')}(tripo use 切换)`,
+                en: `others   ${others.map((x) => profileLabel(x.name, x.profile.region)).join(', ')} (switch with "tripo use")`,
+            }));
+        }
         emitResult({
             key: maskKey(key),
             source,
+            profile: activeProfileName(config),
             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'));
+            profiles: listProfiles(config).map((x) => ({ name: x.name, region: x.profile.region, active: x.active })),
+        }, lines.join('\n'));
     });
+    program
+        .command('use [profile]')
+        .description('switch the active account profile (no argument: pick interactively)')
+        .action(async (name) => {
+        await runUse(name);
+    });
+}
+function profileLabel(name, region) {
+    return region ? `${name} (${region})` : name;
+}
+async function runUse(name) {
+    const profiles = listProfiles();
+    if (profiles.length === 0) {
+        throw new AuthError(t({ zh: '还没有任何账号', en: 'no profiles yet' }), t({ zh: '先运行 tripo login 登录', en: 'run "tripo login" first' }));
+    }
+    if (!name) {
+        if (!isInteractive()) {
+            throw new UsageError(t({
+                zh: `非交互环境请指定名字: tripo use <${profiles.map((x) => x.name).join('|')}>`,
+                en: `specify a profile in non-interactive mode: tripo use <${profiles.map((x) => x.name).join('|')}>`,
+            }));
+        }
+        const answer = await p.select({
+            message: t({ zh: '切换到哪个账号?', en: 'Switch to which account?' }),
+            initialValue: profiles.find((x) => x.active)?.name,
+            options: profiles.map((x) => ({
+                value: x.name,
+                label: profileLabel(x.name, x.profile.region) + (x.active ? t({ zh: '(当前)', en: ' (current)' }) : ''),
+                hint: x.profile.api_key ? maskKey(x.profile.api_key) : undefined,
+            })),
+        });
+        if (p.isCancel(answer))
+            throw new CliError('cancelled', EXIT.FATAL);
+        name = answer;
+    }
+    const match = profiles.find((x) => x.name === name);
+    if (!match) {
+        throw new UsageError(t({
+            zh: `没有叫「${name}」的 profile(现有: ${profiles.map((x) => x.name).join(', ')})`,
+            en: `no profile named "${name}" (have: ${profiles.map((x) => x.name).join(', ')})`,
+        }), t({ zh: `新账号用 tripo login --profile ${name} 登录`, en: `log a new account in with: tripo login --profile ${name}` }));
+    }
+    setActiveProfile(name);
+    success(t({
+        zh: `已切换到「${name}」${match.profile.region ? `(region=${match.profile.region})` : ''}`,
+        en: `switched to "${name}"${match.profile.region ? ` (region=${match.profile.region})` : ''}`,
+    }));
+    if (process.env.TRIPO_API_KEY) {
+        warn(t({
+            zh: '注意:环境变量 TRIPO_API_KEY 仍然优先于 profile,如需使用 profile 请先 unset',
+            en: 'note: TRIPO_API_KEY env var still overrides the profile — unset it to use the profile key',
+        }));
+    }
 }
 export async function runLogin(opts) {
     let region = normalizeRegion(opts.region);
+    // No --profile → the *active* profile: `tripo use work && tripo login`
+    // re-authenticates work, it does not silently overwrite default.
+    const profile = opts.profile ?? activeProfileName();
+    if (!isValidProfileName(profile)) {
+        throw new UsageError(t({
+            zh: `profile 名「${profile}」不合法(小写字母/数字开头,可含 - _,最长 32)`,
+            en: `invalid profile name "${profile}" (lowercase alphanumeric start, may contain - _, max 32 chars)`,
+        }));
+    }
+    const replacing = loadConfig().profiles?.[profile]?.api_key;
+    if (replacing) {
+        log(t({
+            zh: `将替换 profile「${profile}」现有的 Key ${maskKey(replacing)}(新账号请用 tripo login --profile 名字)`,
+            en: `this will replace the key ${maskKey(replacing)} in profile "${profile}" (for a second account use: tripo login --profile <name>)`,
+        }));
+    }
     if (opts.key) {
         // Key in hand → region is detected, not asked (a key lives in exactly one region).
-        await validateAndSave(opts.key, region);
+        await validateAndSave(opts.key, region, profile);
         return;
     }
     if (!isInteractive()) {
@@ -105,8 +197,8 @@ export async function runLogin(opts) {
             throw new CliError('cancelled', EXIT.FATAL);
         region = answer;
     }
-    const key = opts.paste ? await keyFromConsole(region, false) : await deviceFlowWithFallback(region);
-    await validateAndSave(key, region);
+    const key = opts.paste ? await keyFromConsole(region, false) : await deviceFlowWithFallback(region, profile);
+    await validateAndSave(key, region, profile);
     p.outro(t({
         zh: '登录完成!试试: tripo make "一只可爱的机器人"',
         en: 'logged in! try: tripo make "a cute robot"',
@@ -119,10 +211,12 @@ export async function runLogin(opts) {
  * 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) {
+async function deviceFlowWithFallback(region, profile) {
     let grant;
     try {
-        grant = await requestDeviceCode(region);
+        // The backend rotates keys by name; scoping the name by profile keeps two
+        // profiles of the same account from revoking each other's key.
+        grant = await requestDeviceCode(region, profile === DEFAULT_PROFILE ? undefined : profile);
     }
     catch (err) {
         if (err instanceof DeviceAuthUnavailableError) {
@@ -258,12 +352,12 @@ async function keyFromConsole(region, openBrowser) {
  * 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) {
+async function validateAndSave(key, selectedRegion, profile) {
     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);
+            finishSave(key, selectedRegion ?? 'ov', balance.balance, profile);
         }
         catch (err) {
             throw asAuthError(err);
@@ -283,13 +377,16 @@ async function validateAndSave(key, selectedRegion) {
             en: `this key belongs to the ${detected.region} region — auto-switched (your choice "${selectedRegion}" was wrong)`,
         }));
     }
-    finishSave(key, detected.region, detected.balance.balance);
+    finishSave(key, detected.region, detected.balance.balance, profile);
 }
-function finishSave(key, region, balance) {
-    updateConfig({ api_key: key, region });
+function finishSave(key, region, balance, profile) {
+    // Saving activates the profile: "the account I just logged into is the
+    // account I am using" — no second command needed for the common case.
+    updateProfile(profile, { api_key: key, region });
+    const where = profile === DEFAULT_PROFILE ? '~/.tripo/config.json' : `~/.tripo/config.json · profile "${profile}"`;
     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)`,
+        zh: `Key 验证通过(region=${region}),当前余额 ${balance} 积分(已保存到 ${where},权限 0600)`,
+        en: `key verified (region=${region}); balance ${balance} credits (saved to ${where}, mode 0600)`,
     }));
     if (Number(balance) === 0) {
         warn(t({

package/dist/config/config.js

@@ -1,10 +1,25 @@
 /**
- * Global config at ~/.tripo/config.json (mode 0600 — it holds the API key).
+ * Global config at ~/.tripo/config.json (mode 0600 — it holds API keys).
+ *
+ * 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.
+ *
+ * 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
+ * untouched and the rest of the codebase only ever sees one shape. Writes
+ * always persist the normalized form, so any write migrates the file.
+ *
  * Precedence for every setting: env var > directory context > global config.
+ * Profile selection: TRIPO_PROFILE env (set by the global --profile flag
+ * too) > active_profile > "default". TRIPO_API_KEY bypasses profiles
+ * entirely — agent/CI setups never touch the profile machinery.
  */
 import { chmodSync, existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+export const DEFAULT_PROFILE = 'default';
 /**
  * Everything region-specific reduces to these three URLs: the generation API
  * (`api`), the console website (`platform`), and the console's own backend
@@ -35,9 +50,33 @@ export function tripoHome() {
 function configPath() {
     return join(tripoHome(), 'config.json');
 }
+/**
+ * Fold v0.1.0 top-level credential fields into `profiles.default`, so no
+ * other code ever branches on "old format vs new format". If a default
+ * profile already exists its fields win (the file was already migrated;
+ * stray top-level leftovers must not resurrect a replaced key).
+ */
+export function normalizeConfig(raw) {
+    const { api_key, region, api_base_url, platform_base_url, ...rest } = raw;
+    const legacy = {};
+    if (api_key)
+        legacy.api_key = api_key;
+    if (region)
+        legacy.region = region;
+    if (api_base_url)
+        legacy.api_base_url = api_base_url;
+    if (platform_base_url)
+        legacy.platform_base_url = platform_base_url;
+    if (Object.keys(legacy).length === 0)
+        return rest;
+    return {
+        ...rest,
+        profiles: { ...rest.profiles, [DEFAULT_PROFILE]: { ...legacy, ...rest.profiles?.[DEFAULT_PROFILE] } },
+    };
+}
 export function loadConfig() {
     try {
-        return JSON.parse(readFileSync(configPath(), 'utf8'));
+        return normalizeConfig(JSON.parse(readFileSync(configPath(), 'utf8')));
     }
     catch {
         return {};
@@ -47,7 +86,9 @@ export function saveConfig(config) {
     const dir = tripoHome();
     mkdirSync(dir, { recursive: true, mode: 0o700 });
     const file = configPath();
-    writeFileSync(file, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
+    // Writes always persist the normalized shape — this is what migrates
+    // legacy files, and it keeps a single on-disk format going forward.
+    writeFileSync(file, JSON.stringify(normalizeConfig(config), null, 2) + '\n', { mode: 0o600 });
     // writeFileSync mode only applies on creation; enforce on every save.
     chmodSync(file, 0o600);
 }
@@ -56,37 +97,85 @@ export function updateConfig(patch) {
     saveConfig(next);
     return next;
 }
-export function deleteApiKey() {
+/** Names are shell-friendly and short — they appear in key names and flags. */
+export function isValidProfileName(name) {
+    return /^[a-z0-9][a-z0-9_-]{0,31}$/.test(name);
+}
+/** Selected profile name: TRIPO_PROFILE (or --profile) > config > default. */
+export function activeProfileName(config = loadConfig()) {
+    return process.env.TRIPO_PROFILE || config.active_profile || DEFAULT_PROFILE;
+}
+/** The selected profile's data; {} when it does not exist (yet). */
+export function activeProfile(config = loadConfig()) {
+    return config.profiles?.[activeProfileName(config)] ?? {};
+}
+export function listProfiles(config = loadConfig()) {
+    const active = activeProfileName(config);
+    return Object.entries(config.profiles ?? {}).map(([name, profile]) => ({
+        name,
+        profile,
+        active: name === active,
+    }));
+}
+/** Create/update one profile and (by default) make it the active one. */
+export function updateProfile(name, patch, opts = {}) {
     const config = loadConfig();
-    delete config.api_key;
-    if (Object.keys(config).length === 0) {
+    const profiles = { ...config.profiles, [name]: { ...config.profiles?.[name], ...patch } };
+    saveConfig({ ...config, profiles, ...(opts.activate !== false ? { active_profile: name } : {}) });
+}
+export function setActiveProfile(name) {
+    updateConfig({ active_profile: name });
+}
+/** Remove a profile (logout). Active pointer falls back to default. */
+export function deleteProfile(name) {
+    const config = loadConfig();
+    if (!config.profiles?.[name])
+        return false;
+    const profiles = { ...config.profiles };
+    delete profiles[name];
+    const next = { ...config, profiles };
+    if (Object.keys(profiles).length === 0)
+        delete next.profiles;
+    if (next.active_profile === name)
+        delete next.active_profile;
+    if (Object.keys(next).length === 0) {
         try {
             unlinkSync(configPath());
         }
         catch { }
+        return true;
     }
-    else {
-        saveConfig(config);
-    }
+    saveConfig(next);
+    return true;
 }
-/** Resolve the API key: env wins, then global config. */
+/** Resolve the API key: env wins, then the active profile. */
 export function resolveApiKey(config = loadConfig()) {
-    return process.env.TRIPO_API_KEY || config.api_key;
+    return process.env.TRIPO_API_KEY || activeProfile(config).api_key;
+}
+/**
+ * Where the effective key comes from, for whoami/doctor and for the
+ * "no key" error message — so a mistyped --profile says "profile not
+ * found", never a misleading "you are not logged in".
+ */
+export function describeKeySource(config = loadConfig()) {
+    if (process.env.TRIPO_API_KEY)
+        return 'env:TRIPO_API_KEY';
+    return `profile:${activeProfileName(config)}`;
 }
 export function resolveRegion(config = loadConfig()) {
     const env = process.env.TRIPO_REGION;
     if (env === 'cn' || env === 'ov')
         return env;
-    return config.region ?? 'ov';
+    return activeProfile(config).region ?? 'ov';
 }
 export function resolveApiBaseUrl(config = loadConfig()) {
     return (process.env.TRIPO_API_BASE_URL ||
-        config.api_base_url ||
+        activeProfile(config).api_base_url ||
         REGION_DEFAULTS[resolveRegion(config)].api);
 }
 export function resolvePlatformBaseUrl(config = loadConfig()) {
     return (process.env.TRIPO_PLATFORM_BASE_URL ||
-        config.platform_base_url ||
+        activeProfile(config).platform_base_url ||
         REGION_DEFAULTS[resolveRegion(config)].platform);
 }
 export function configFileExists() {

package/dist/core/client.js

@@ -3,7 +3,8 @@
  * Handles the response envelope, error translation, timeouts, and
  * exponential-backoff retries for transient failures (429/5xx/network).
  */
-import { loadConfig, resolveApiBaseUrl, resolveApiKey } from '../config/config.js';
+import { activeProfileName, DEFAULT_PROFILE, listProfiles, loadConfig, resolveApiBaseUrl, resolveApiKey } from '../config/config.js';
+import { t } from '../i18n.js';
 import { ApiError, AuthError, NetworkError } from './errors.js';
 export class TripoClient {
     baseUrl;
@@ -16,7 +17,20 @@ export class TripoClient {
         this.baseUrl = (options.baseUrl ?? resolveApiBaseUrl(config)).replace(/\/$/, '');
         const key = options.apiKey ?? resolveApiKey(config);
         if (!key) {
-            throw new AuthError('no API key configured');
+            // A mistyped --profile must say so — "not logged in" would send the
+            // user to re-login while their key sits in another profile.
+            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(t({ zh: '未配置 API Key', en: 'no API key configured' }));
         }
         this.apiKey = key;
         this.timeoutMs = options.timeoutMs ?? 60_000;