@helixlife-ai/xiantao 0.1.10 → 0.1.12

package/README.md

@@ -21,7 +21,7 @@ xt tool inspect violin_flat
 xt tool run violin_flat ./data.xlsx
 ```
 
-`xt login` is the recommended first-use entrypoint. It refreshes both the upload token and the Xiantao web token for the current profile. `xt tool login` is kept as an equivalent entrypoint under the `tool` topic.
+`xt login` is the recommended first-use entrypoint. It authorizes and stores the profile token in one step. `xt tool login` is kept as an equivalent entrypoint under the `tool` topic.
 
 ### Interactive Tool Run
 
@@ -34,10 +34,13 @@ This starts a menu-driven path for choosing a tool, selecting demo data or a loc
 ### Agent Automation
 
 ```bash
+xt tool prepare violin_flat --file ./data.xlsx --profile opencode --json
 xt tool exec violin_flat --file ./data.xlsx --profile opencode --json
 ```
 
-For machine callers, use `xt tool exec`, keep `--json`, pass an explicit profile with `--profile`, and avoid interactive-only flows.
+For machine callers, use `xt tool prepare` to fetch the upload-dependent final schema, then `xt tool exec` to submit. Keep `--json`, pass an explicit profile with `--profile`, and avoid interactive-only flows.
+
+`xt login --json` now returns the authorization link immediately and defaults to `authorized: false` until the browser step completes. Use `xt login --json --wait` when you explicitly want the command to block until authorization is confirmed. `xt status` is a probe-style check and returns `authorized: true` or `authorized: false` together with a reason such as `missing_token` or `expired_token`.
 
 ## Command Groups
 
@@ -52,6 +55,7 @@ For machine callers, use `xt tool exec`, keep `--json`, pass an explicit profile
 
 - `xt tool search`
 - `xt tool inspect`
+- `xt tool prepare`
 - `xt tool run`
 - `xt tool exec`
 - `xt tool download`
@@ -67,12 +71,10 @@ For machine callers, use `xt tool exec`, keep `--json`, pass an explicit profile
 
 For the common Xiantao tool product, `tool search`, `tool inspect`, `tool run`, `tool resolve`, and `tool menu` default `toolProductUuid` to `c0b6febb-52dd-4525-970a-61bbe9e263ff`. You can override it with `--toolProductUuid`, `XIANTAO_TOOL_PRODUCT_UUID`, or `~/.config/xtz/config.json` under `xiantao.toolProductUuid`.
 
-`xt tool search <keyword>` searches cached or remote tool menus by tool id, title, path, and route. `xt tool inspect <tool_id>` prints resolved metadata together with the dynamic `args_main` schema used by the tool. `xt tool run <tool_id>` runs a Xiantao bioinformatics tool. `xt tool resolve <tool_id>` remains available as the low-level UUID and route lookup. `--demo` reuses the demo file metadata returned by `tool fetch-all`; otherwise `tool run` uploads the local file first and therefore also needs upload auth. Run `xt login` first to refresh both tokens in one step. When a tool exposes multiple downloadable results, `--download <path>` uses the output file extension to select the matching artifact.
+`xt tool search <keyword>` searches remote tool menus by tool id, title, path, and route. `xt tool inspect <tool_id>` prints resolved metadata together with the dynamic `args_main` schema used by the tool. `xt tool run <tool_id>` runs a Xiantao bioinformatics tool. `xt tool resolve <tool_id>` remains available as the low-level UUID and route lookup. `--demo` reuses the demo file metadata returned by `tool fetch-all`; otherwise `tool run` uploads the local file first and therefore also needs token auth. Run `xt login` first to authorize the stored token. When a tool exposes multiple downloadable results, `--download <path>` uses the output file extension to select the matching artifact.
 
 `xt tool run <tool_id> ... --interactive` prompts for dynamic `args_main` values before the final submit, prints reusable `--set` flags, and supports `<` for the previous item plus `/skip` for the current section.
 
-When resolving tools from `--toolProductUuid`, the CLI caches the `/tool/menus?is_all=1` result locally for 12 hours per `profile + toolProductUuid` to avoid repeated full-menu fetches.
-
 ## Development
 
 ```bash

package/dist/base-command.js

@@ -1,21 +1,36 @@
 import { Command } from '@oclif/core';
+import { createErrorEnvelope, createSuccessEnvelope } from './lib/envelope.js';
 import { XtzError } from './lib/errors.js';
 import { resolveAgent } from './lib/storage.js';
+import { getUpdateReminder } from './lib/update.js';
 export class XtzCommand extends Command {
+    async init() {
+        await super.init();
+        await this.warnIfUpdateAvailable();
+    }
     async getProfile(profileFlag) {
         return resolveAgent(profileFlag);
     }
     async getAgent(agentFlag) {
         return this.getProfile(agentFlag);
     }
-    print(flags, data, text) {
+    print(flags, data, text, context) {
         if (flags.json) {
+            if (context) {
+                this.log(JSON.stringify(createSuccessEnvelope(context.profile, context.command ?? this.getCommandName(), data), null, 2));
+                return;
+            }
             this.log(JSON.stringify(data, null, 2));
             return;
         }
         this.log(text);
     }
     async catch(error) {
+        if (this.isJsonOutputRequested()) {
+            const profile = await this.getProfile(this.readProfileFlagFromArgv());
+            this.log(JSON.stringify(createErrorEnvelope(profile, this.getCommandName(), error), null, 2));
+            this.exit(1);
+        }
         if (error instanceof XtzError) {
             this.error(error.message, { exit: 1 });
         }
@@ -37,4 +52,52 @@ export class XtzCommand extends Command {
         const replacement = command.replace(/^auth /, '');
         this.warn(`\`xt ${command}\` 已兼容保留，建议改用 \`xt ${replacement}\``);
     }
+    async warnIfUpdateAvailable() {
+        if (this.argv.includes('--json') || !process.stdout.isTTY || this.shouldSkipUpdateReminder()) {
+            return;
+        }
+        const reminder = await getUpdateReminder(this.config.version);
+        if (!reminder) {
+            return;
+        }
+        this.warn(reminder);
+    }
+    getCommandName() {
+        return this.id?.replaceAll(':', ' ') ?? 'unknown';
+    }
+    isJsonOutputRequested() {
+        return this.argv.includes('--json');
+    }
+    readProfileFlagFromArgv() {
+        for (let index = 0; index < this.argv.length; index += 1) {
+            const token = this.argv[index];
+            if ((token === '--profile' || token === '--agent') && this.argv[index + 1]) {
+                return this.argv[index + 1];
+            }
+            if (token.startsWith('--profile=')) {
+                return token.slice('--profile='.length);
+            }
+            if (token.startsWith('--agent=')) {
+                return token.slice('--agent='.length);
+            }
+        }
+        return undefined;
+    }
+    shouldSkipUpdateReminder() {
+        const commandId = this.id ?? '';
+        return [
+            'login',
+            'logout',
+            'status',
+            'auth:login',
+            'auth:logout',
+            'auth:status',
+            'plot:login',
+            'plot:run',
+            'tool:exec',
+            'tool:login',
+            'tool:prepare',
+            'tool:run',
+        ].includes(commandId);
+    }
 }

package/dist/commands/auth/login.js

@@ -1,10 +1,11 @@
 import { Flags } from '@oclif/core';
 import { XtzCommand } from '../../base-command.js';
 import { globalFlags } from '../../lib/flags.js';
+import { loginAuth } from '../../lib/auth.js';
 import { loginAll } from '../../lib/login-flow.js';
-import { getTokenPath, getXiantaoTokenPath } from '../../lib/storage.js';
+import { getTokenPath } from '../../lib/storage.js';
 export default class AuthLogin extends XtzCommand {
-    static description = 'Sign in for the current profile and refresh both the upload token and the Xiantao web token';
+    static description = 'Authorize the current profile token';
     static flags = {
         ...globalFlags,
         open: Flags.boolean({
@@ -12,52 +13,64 @@ export default class AuthLogin extends XtzCommand {
             default: true,
             description: 'Open the authorization link in the browser',
         }),
+        wait: Flags.boolean({
+            allowNo: true,
+            default: true,
+            description: 'Wait until the browser authorization is confirmed before exiting',
+        }),
     };
     async run() {
         this.warnIfLegacyAuthCommand();
         const { flags } = await this.parse(AuthLogin);
         const agent = await this.getProfile(flags.profile);
-        const result = await loginAll(agent, flags.open, ({ auth, phase }) => {
-            if (flags.json) {
-                return;
-            }
-            if (phase === 'auth_started') {
-                if (auth.authorizedWithStoredXiantao) {
-                    this.log('已使用现有仙桃网页登录自动完成上传授权，等待确认...');
+        const waitForAuthorization = this.shouldWait(flags);
+        const result = waitForAuthorization
+            ? await loginAll(agent, flags.open, ({ auth, phase }) => {
+                if (flags.json) {
+                    return;
+                }
+                if (phase === 'auth_started') {
+                    this.log(auth.browserOpened ? '浏览器已打开授权链接，等待授权完成...' : `请先在浏览器中打开授权链接: ${auth.linkUrl}`);
                     return;
                 }
-                this.log(auth.browserOpened ? '浏览器已打开上传授权链接，等待授权完成...' : `请先在浏览器中打开上传授权链接: ${auth.linkUrl}`);
-                return;
-            }
-            this.log(auth.authorizedWithStoredXiantao ? '上传授权已确认，已复用现有仙桃网页登录。' : '上传授权已确认，继续仙桃网页登录...');
-        });
+                this.log('授权已确认。');
+            })
+            : { auth: await loginAuth(agent, flags.open) };
+        const authorized = waitForAuthorization;
         this.print(flags, {
             agent,
-            auto_authorized: result.auth.authorizedWithStoredXiantao,
+            authorization_pending: !authorized,
+            authorized,
             browser_opened: result.auth.browserOpened,
             link_url: result.auth.linkUrl,
             token_path: result.auth.tokenPath,
-            xiantao: {
-                browser_opened: result.xiantao.browserOpened,
-                callback_url: result.xiantao.callbackUrl,
-                jump_url: result.xiantao.jumpUrl,
-                reused: result.xiantao.reused,
-                token_path: result.xiantao.tokenPath,
-            },
-        }, [
-            `profile: ${agent}`,
-            `token: ${getTokenPath(agent)}`,
-            `xiantao_token: ${getXiantaoTokenPath(agent)}`,
-            result.xiantao.reused
-                ? '已复用现有仙桃网页登录 token。'
-                : result.xiantao.browserOpened
-                    ? '仙桃网页登录成功，token 已刷新。'
-                    : `请在浏览器中打开: ${result.xiantao.jumpUrl}`,
-            result.auth.authorizedWithStoredXiantao
-                ? '已使用现有仙桃网页登录自动完成授权。'
-                : result.auth.browserOpened
-                    ? '浏览器已打开授权链接，请完成授权后运行 `xt status`。'
-                    : `请在浏览器中打开: ${result.auth.linkUrl}`,
-        ].join('\n'));
+            wait: waitForAuthorization,
+        }, this.formatLoginText({
+            agent,
+            authorized,
+            browserOpened: result.auth.browserOpened,
+            linkUrl: result.auth.linkUrl,
+        }), { profile: agent });
+    }
+    shouldWait(flags) {
+        if (!this.hasExplicitWaitFlag()) {
+            return !flags.json;
+        }
+        return flags.wait;
+    }
+    hasExplicitWaitFlag() {
+        return this.argv.includes('--wait') || this.argv.includes('--no-wait');
+    }
+    formatLoginText(input) {
+        const lines = [
+            `profile: ${input.agent}`,
+            `token: ${getTokenPath(input.agent)}`,
+            `authorized: ${input.authorized}`,
+        ];
+        if (input.authorized) {
+            return lines.join('\n');
+        }
+        lines.push(input.browserOpened ? '浏览器已打开授权链接，请完成授权后运行 `xt status`。' : `请在浏览器中打开: ${input.linkUrl}`);
+        return lines.join('\n');
     }
 }

package/dist/commands/auth/logout.js

@@ -15,6 +15,6 @@ export default class AuthLogout extends XtzCommand {
             agent,
             removed,
             token_path: getTokenPath(agent),
-        }, removed ? `已删除 token: ${getTokenPath(agent)}` : `未找到 token: ${getTokenPath(agent)}`);
+        }, removed ? `已删除 token: ${getTokenPath(agent)}` : `未找到 token: ${getTokenPath(agent)}`, { profile: agent });
     }
 }

package/dist/commands/auth/status.js

@@ -1,9 +1,10 @@
 import { XtzCommand } from '../../base-command.js';
+import { XtzError } from '../../lib/errors.js';
 import { checkToken } from '../../lib/auth.js';
 import { globalFlags } from '../../lib/flags.js';
-import { getTokenPath, requireToken } from '../../lib/storage.js';
+import { getTokenPath, loadToken } from '../../lib/storage.js';
 export default class AuthStatus extends XtzCommand {
-    static description = 'Check whether the current profile token is authorized';
+    static description = 'Show token auth status for the current profile';
     static flags = {
         ...globalFlags,
     };
@@ -11,12 +12,49 @@ export default class AuthStatus extends XtzCommand {
         this.warnIfLegacyAuthCommand();
         const { flags } = await this.parse(AuthStatus);
         const agent = await this.getProfile(flags.profile);
-        const token = await requireToken(agent);
-        await checkToken(agent, token);
+        const tokenPath = getTokenPath(agent);
+        const token = await loadToken(agent);
+        const status = !token
+            ? {
+                authorized: false,
+                reason: 'missing_token',
+            }
+            : await this.resolveAuthorization(agent, token);
         this.print(flags, {
             agent,
-            authorized: true,
-            token_path: getTokenPath(agent),
-        }, `profile: ${agent}\nauthorized: true\ntoken: ${getTokenPath(agent)}`);
+            authorized: status.authorized,
+            reason: status.reason,
+            token_path: tokenPath,
+        }, this.formatStatusText(agent, tokenPath, status), { profile: agent });
+    }
+    async resolveAuthorization(agent, token) {
+        try {
+            await checkToken(agent, token);
+            return {
+                authorized: true,
+                reason: null,
+            };
+        }
+        catch (error) {
+            if (!(error instanceof XtzError) || !error.message.includes('授权已过期')) {
+                throw error;
+            }
+            return {
+                authorized: false,
+                reason: 'expired_token',
+            };
+        }
+    }
+    formatStatusText(agent, tokenPath, status) {
+        const lines = [
+            `profile: ${agent}`,
+            `authorized: ${status.authorized}`,
+            `token: ${tokenPath}`,
+        ];
+        if (!status.authorized && status.reason) {
+            lines.push(`reason: ${status.reason}`);
+            lines.push(`run: xt login --profile ${agent}`);
+        }
+        return lines.join('\n');
     }
 }

package/dist/commands/plot/fetch-all.js

@@ -1,8 +1,8 @@
 import { Args, Flags } from '@oclif/core';
 import { XtzCommand } from '../../base-command.js';
+import { getAuthContext } from '../../lib/auth.js';
 import { globalFlags } from '../../lib/flags.js';
 import { buildArgsMainFromSchema } from '../../lib/plot-schema.js';
-import { getXiantaoAuthContext } from '../../lib/xiantao-auth.js';
 import { fetchAllPlotArgs } from '../../lib/xiantao.js';
 export default class PlotFetchAll extends XtzCommand {
     static description = 'Fetch raw dynamic args for a Xiantao tool via public.args.fetch-all';
@@ -15,7 +15,7 @@ export default class PlotFetchAll extends XtzCommand {
     static flags = {
         ...globalFlags,
         token: Flags.string({
-            description: 'Bearer token for api.helixlife.net xiantao APIs; falls back to XIANTAO_TOKEN or the stored Xiantao web token',
+            description: 'Bearer token for agent.helixlife.net xiantao APIs; falls back to the stored agent token',
         }),
         uuid: Flags.string({
             description: 'Tool UUID used in the public.args.fetch-all payload',
@@ -26,7 +26,7 @@ export default class PlotFetchAll extends XtzCommand {
         this.warnIfLegacyPlotCommand();
         const { args, flags } = await this.parse(PlotFetchAll);
         const agent = await this.getProfile(flags.profile);
-        const auth = await getXiantaoAuthContext(agent, flags.token);
+        const auth = await getAuthContext(agent, flags.token);
         const result = await fetchAllPlotArgs(auth, {
             moduleId: args.moduleId,
             uuid: flags.uuid,
@@ -42,6 +42,6 @@ export default class PlotFetchAll extends XtzCommand {
             notice: result.notice ?? '',
             uuid: flags.uuid,
         };
-        this.print(flags, output, JSON.stringify(output, null, 2));
+        this.print(flags, output, JSON.stringify(output, null, 2), { profile: agent });
     }
 }

package/dist/commands/plot/login.js

@@ -1,10 +1,11 @@
 import { Flags } from '@oclif/core';
 import { XtzCommand } from '../../base-command.js';
+import { loginAuth } from '../../lib/auth.js';
 import { globalFlags } from '../../lib/flags.js';
 import { loginAll } from '../../lib/login-flow.js';
-import { getTokenPath, getXiantaoTokenPath } from '../../lib/storage.js';
+import { getTokenPath } from '../../lib/storage.js';
 export default class PlotLogin extends XtzCommand {
-    static description = 'Sign in for the current profile and refresh both the upload token and the Xiantao web token';
+    static description = 'Authorize the current profile token';
     static flags = {
         ...globalFlags,
         open: Flags.boolean({
@@ -12,52 +13,64 @@ export default class PlotLogin extends XtzCommand {
             default: true,
             description: 'Open the authorization link in the browser',
         }),
+        wait: Flags.boolean({
+            allowNo: true,
+            default: true,
+            description: 'Wait until the browser authorization is confirmed before exiting',
+        }),
     };
     async run() {
         this.warnIfLegacyPlotCommand();
         const { flags } = await this.parse(PlotLogin);
         const agent = await this.getProfile(flags.profile);
-        const result = await loginAll(agent, flags.open, ({ auth, phase }) => {
-            if (flags.json) {
-                return;
-            }
-            if (phase === 'auth_started') {
-                if (auth.authorizedWithStoredXiantao) {
-                    this.log('已使用现有仙桃网页登录自动完成上传授权，等待确认...');
+        const waitForAuthorization = this.shouldWait(flags);
+        const result = waitForAuthorization
+            ? await loginAll(agent, flags.open, ({ auth, phase }) => {
+                if (flags.json) {
+                    return;
+                }
+                if (phase === 'auth_started') {
+                    this.log(auth.browserOpened ? '浏览器已打开授权链接，等待授权完成...' : `请先在浏览器中打开授权链接: ${auth.linkUrl}`);
                     return;
                 }
-                this.log(auth.browserOpened ? '浏览器已打开上传授权链接，等待授权完成...' : `请先在浏览器中打开上传授权链接: ${auth.linkUrl}`);
-                return;
-            }
-            this.log(auth.authorizedWithStoredXiantao ? '上传授权已确认，已复用现有仙桃网页登录。' : '上传授权已确认，继续仙桃网页登录...');
-        });
+                this.log('授权已确认。');
+            })
+            : { auth: await loginAuth(agent, flags.open) };
+        const authorized = waitForAuthorization;
         this.print(flags, {
             agent,
-            auto_authorized: result.auth.authorizedWithStoredXiantao,
+            authorization_pending: !authorized,
+            authorized,
             browser_opened: result.auth.browserOpened,
             link_url: result.auth.linkUrl,
             token_path: result.auth.tokenPath,
-            xiantao: {
-                browser_opened: result.xiantao.browserOpened,
-                callback_url: result.xiantao.callbackUrl,
-                jump_url: result.xiantao.jumpUrl,
-                reused: result.xiantao.reused,
-                token_path: result.xiantao.tokenPath,
-            },
-        }, [
-            `profile: ${agent}`,
-            `token: ${getTokenPath(agent)}`,
-            `xiantao_token: ${getXiantaoTokenPath(agent)}`,
-            result.xiantao.reused
-                ? '已复用现有仙桃网页登录 token。'
-                : result.xiantao.browserOpened
-                    ? '仙桃网页登录成功，token 已刷新。'
-                    : `请在浏览器中打开: ${result.xiantao.jumpUrl}`,
-            result.auth.authorizedWithStoredXiantao
-                ? '已使用现有仙桃网页登录自动完成授权。'
-                : result.auth.browserOpened
-                    ? '浏览器已打开授权链接，请完成授权后运行 `xt status`。'
-                    : `请在浏览器中打开: ${result.auth.linkUrl}`,
-        ].join('\n'));
+            wait: waitForAuthorization,
+        }, this.formatLoginText({
+            agent,
+            authorized,
+            browserOpened: result.auth.browserOpened,
+            linkUrl: result.auth.linkUrl,
+        }), { profile: agent });
+    }
+    shouldWait(flags) {
+        if (!this.hasExplicitWaitFlag()) {
+            return !flags.json;
+        }
+        return flags.wait;
+    }
+    hasExplicitWaitFlag() {
+        return this.argv.includes('--wait') || this.argv.includes('--no-wait');
+    }
+    formatLoginText(input) {
+        const lines = [
+            `profile: ${input.agent}`,
+            `token: ${getTokenPath(input.agent)}`,
+            `authorized: ${input.authorized}`,
+        ];
+        if (input.authorized) {
+            return lines.join('\n');
+        }
+        lines.push(input.browserOpened ? '浏览器已打开授权链接，请完成授权后运行 `xt status`。' : `请在浏览器中打开: ${input.linkUrl}`);
+        return lines.join('\n');
     }
 }

package/dist/commands/plot/menu.js

@@ -1,8 +1,8 @@
 import { Args, Flags } from '@oclif/core';
 import { XtzCommand } from '../../base-command.js';
+import { getAuthContext } from '../../lib/auth.js';
 import { globalFlags } from '../../lib/flags.js';
 import { resolveXiantaoToolProductUuid } from '../../lib/storage.js';
-import { getXiantaoAuthContext } from '../../lib/xiantao-auth.js';
 import { fetchToolMenu } from '../../lib/xiantao.js';
 export default class PlotMenu extends XtzCommand {
     static description = 'Fetch Xiantao menu metadata for a tool menu UUID';
@@ -15,7 +15,7 @@ export default class PlotMenu extends XtzCommand {
     static flags = {
         ...globalFlags,
         token: Flags.string({
-            description: 'Bearer token for api.helixlife.net xiantao APIs; falls back to XIANTAO_TOKEN or the stored Xiantao web token',
+            description: 'Bearer token for agent.helixlife.net xiantao APIs; falls back to the stored agent token',
         }),
         toolProductUuid: Flags.string({
             description: 'tool_product_uuid used in the menu filter payload; defaults to the main Xiantao product UUID',
@@ -25,13 +25,13 @@ export default class PlotMenu extends XtzCommand {
         this.warnIfLegacyPlotCommand();
         const { args, flags } = await this.parse(PlotMenu);
         const agent = await this.getProfile(flags.profile);
-        const auth = await getXiantaoAuthContext(agent, flags.token);
+        const auth = await getAuthContext(agent, flags.token);
         const toolProductUuid = await resolveXiantaoToolProductUuid(flags.toolProductUuid);
         const menu = await fetchToolMenu(auth, args.menuUuid, toolProductUuid);
         this.print(flags, {
             agent,
             menu,
             tool_product_uuid: toolProductUuid,
-        }, JSON.stringify(menu, null, 2));
+        }, JSON.stringify(menu, null, 2), { profile: agent });
     }
 }

package/dist/commands/plot/menus.js

@@ -1,15 +1,15 @@
 import { Flags } from '@oclif/core';
 import { XtzCommand } from '../../base-command.js';
+import { getAuthContext } from '../../lib/auth.js';
 import { globalFlags } from '../../lib/flags.js';
 import { resolveXiantaoToolProductUuid } from '../../lib/storage.js';
-import { getXiantaoAuthContext } from '../../lib/xiantao-auth.js';
 import { fetchToolMenus } from '../../lib/xiantao.js';
 export default class PlotMenus extends XtzCommand {
     static description = 'Fetch all Xiantao menu metadata for a tool product';
     static flags = {
         ...globalFlags,
         token: Flags.string({
-            description: 'Bearer token for api.helixlife.net xiantao APIs; falls back to XIANTAO_TOKEN or the stored Xiantao web token',
+            description: 'Bearer token for agent.helixlife.net xiantao APIs; falls back to the stored agent token',
         }),
         toolProductUuid: Flags.string({
             description: 'tool_product_uuid used in the menu filter payload; defaults to the main Xiantao product UUID',
@@ -19,13 +19,13 @@ export default class PlotMenus extends XtzCommand {
         this.warnIfLegacyPlotCommand();
         const { flags } = await this.parse(PlotMenus);
         const agent = await this.getProfile(flags.profile);
-        const auth = await getXiantaoAuthContext(agent, flags.token);
+        const auth = await getAuthContext(agent, flags.token);
         const toolProductUuid = await resolveXiantaoToolProductUuid(flags.toolProductUuid);
         const menus = await fetchToolMenus(auth, toolProductUuid);
         this.print(flags, {
             agent,
             menus,
             tool_product_uuid: toolProductUuid,
-        }, JSON.stringify(menus, null, 2));
+        }, JSON.stringify(menus, null, 2), { profile: agent });
     }
 }

package/dist/commands/plot/resolve.js

@@ -1,8 +1,8 @@
 import { Args, Flags } from '@oclif/core';
 import { XtzCommand } from '../../base-command.js';
+import { getAuthContext } from '../../lib/auth.js';
 import { globalFlags } from '../../lib/flags.js';
 import { resolveXiantaoToolProductUuid } from '../../lib/storage.js';
-import { getXiantaoAuthContext } from '../../lib/xiantao-auth.js';
 import { resolveToolMenuByCode } from '../../lib/xiantao.js';
 export default class PlotResolve extends XtzCommand {
     static description = 'Resolve a Xiantao tool id to its UUID and route';
@@ -15,7 +15,7 @@ export default class PlotResolve extends XtzCommand {
     static flags = {
         ...globalFlags,
         token: Flags.string({
-            description: 'Bearer token for api.helixlife.net xiantao APIs; falls back to XIANTAO_TOKEN or the stored Xiantao web token',
+            description: 'Bearer token for agent.helixlife.net xiantao APIs; falls back to the stored agent token',
         }),
         toolProductUuid: Flags.string({
             description: 'tool_product_uuid from the /products/apply/:uuid URL; defaults to the main Xiantao product UUID',
@@ -25,7 +25,7 @@ export default class PlotResolve extends XtzCommand {
         this.warnIfLegacyPlotCommand();
         const { args, flags } = await this.parse(PlotResolve);
         const agent = await this.getProfile(flags.profile);
-        const auth = await getXiantaoAuthContext(agent, flags.token);
+        const auth = await getAuthContext(agent, flags.token);
         const toolProductUuid = await resolveXiantaoToolProductUuid(flags.toolProductUuid);
         const resolved = await resolveToolMenuByCode(auth, toolProductUuid, args.moduleId);
         this.print(flags, {
@@ -43,6 +43,6 @@ export default class PlotResolve extends XtzCommand {
             title: resolved.title,
             tool_product_uuid: toolProductUuid,
             uuid: resolved.uuid,
-        }, null, 2));
+        }, null, 2), { profile: agent });
     }
 }

package/dist/commands/plot/run.js

@@ -11,15 +11,14 @@ import { parseSetOverrides, plotOverrideFlags } from '../../lib/plot-options.js'
 import { buildArgsMainFromSchema } from '../../lib/plot-schema.js';
 import { loadPlotArgsMainConfig, resolveXiantaoToolProductUuid } from '../../lib/storage.js';
 import { resolveXiantaoDownload, submitXiantaoPlot, verifyXiantaoPlotUpload } from '../../lib/xiantao-plot.js';
-import { getXiantaoAuthContext } from '../../lib/xiantao-auth.js';
 import { fetchAllPlotArgs, fetchToolMenu, fetchToolMenus, resolveToolMenuByCode } from '../../lib/xiantao.js';
 export class ToolRunCommandBase extends XtzCommand {
     async prepareToolRun(requestedModuleId, filePath, flags) {
         const agent = await this.getProfile(flags.profile);
-        const xiantaoAuth = await getXiantaoAuthContext(agent, flags.token);
-        const resolved = await this.resolveModule(requestedModuleId, flags, xiantaoAuth);
+        const auth = await getAuthContext(agent, flags.token);
+        const resolved = await this.resolveModule(requestedModuleId, flags, auth);
         const { moduleId, route, toolProductUuid, uuid } = resolved;
-        const fetchAllResult = await fetchAllPlotArgs(xiantaoAuth, { moduleId, uuid });
+        const fetchAllResult = await fetchAllPlotArgs(auth, { moduleId, uuid });
         const inputMode = await this.resolveInputMode(fetchAllResult, {
             demo: flags.demo,
             filePath,
@@ -35,7 +34,7 @@ export class ToolRunCommandBase extends XtzCommand {
                 argsMain,
                 moduleId,
                 uuid,
-            }, xiantaoAuth);
+            }, auth);
         if (verifiedSchema.length) {
             schema = verifiedSchema;
             argsMain = deepMerge(buildArgsMainFromSchema(schema), overrides);
@@ -43,7 +42,7 @@ export class ToolRunCommandBase extends XtzCommand {
         return {
             agent,
             argsMain,
-            auth: xiantaoAuth,
+            auth,
             duid,
             inputMode: inputMode.mode,
             moduleId,
@@ -409,7 +408,7 @@ export default class PlotRun extends ToolRunCommandBase {
             description: 'Tool route like app1.violin_flat in generic mode',
         }),
         token: Flags.string({
-            description: 'Bearer token for api.helixlife.net xiantao APIs; falls back to XIANTAO_TOKEN or the stored Xiantao web token',
+            description: 'Bearer token for agent.helixlife.net xiantao APIs; falls back to the stored agent token',
         }),
         toolProductUuid: Flags.string({
             description: 'tool_product_uuid used to auto-resolve module UUID and route in generic mode; defaults to the main Xiantao product UUID',
@@ -428,6 +427,6 @@ export default class PlotRun extends ToolRunCommandBase {
             throw new XtzError('FILE 与 `--file` 不能同时使用。');
         }
         const result = await this.executeToolRun(args.tool, args.file ?? flags.file, flags);
-        this.print(flags, result.data, result.text);
+        this.print(flags, result.data, result.text, { profile: result.data.agent });
     }
 }

package/dist/commands/tool/exec.js

@@ -40,7 +40,7 @@ export default class ToolExec extends ToolRunCommandBase {
             description: 'Tool route like app1.violin_flat in generic mode',
         }),
         token: Flags.string({
-            description: 'Bearer token for api.helixlife.net xiantao APIs; falls back to XIANTAO_TOKEN or the stored Xiantao web token',
+            description: 'Bearer token for agent.helixlife.net xiantao APIs; falls back to the stored agent token',
         }),
         toolProductUuid: Flags.string({
             description: 'tool_product_uuid used to auto-resolve module UUID and route in generic mode; defaults to the main Xiantao product UUID',