@helixlife-ai/xiantao 0.1.9 → 0.1.11

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
 
@@ -67,12 +67,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,7 +1,12 @@
 import { Command } from '@oclif/core';
 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);
     }
@@ -37,4 +42,14 @@ 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) {
+            return;
+        }
+        const reminder = await getUpdateReminder(this.config.version);
+        if (!reminder) {
+            return;
+        }
+        this.warn(reminder);
+    }
 }

package/dist/commands/auth/login.js

@@ -2,9 +2,9 @@ import { Flags } from '@oclif/core';
 import { XtzCommand } from '../../base-command.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 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({
@@ -22,42 +22,22 @@ export default class AuthLogin extends XtzCommand {
                 return;
             }
             if (phase === 'auth_started') {
-                if (auth.authorizedWithStoredXiantao) {
-                    this.log('已使用现有仙桃网页登录自动完成上传授权，等待确认...');
-                    return;
-                }
-                this.log(auth.browserOpened ? '浏览器已打开上传授权链接，等待授权完成...' : `请先在浏览器中打开上传授权链接: ${auth.linkUrl}`);
+                this.log(auth.browserOpened ? '浏览器已打开授权链接，等待授权完成...' : `请先在浏览器中打开授权链接: ${auth.linkUrl}`);
                 return;
             }
-            this.log(auth.authorizedWithStoredXiantao ? '上传授权已确认，已复用现有仙桃网页登录。' : '上传授权已确认，继续仙桃网页登录...');
+            this.log('授权已确认。');
         });
         this.print(flags, {
             agent,
-            auto_authorized: result.auth.authorizedWithStoredXiantao,
             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}`,
+            result.auth.browserOpened
+                ? '浏览器已打开授权链接，请完成授权后运行 `xt status`。'
+                : `请在浏览器中打开: ${result.auth.linkUrl}`,
         ].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,

package/dist/commands/plot/login.js

@@ -2,9 +2,9 @@ import { Flags } from '@oclif/core';
 import { XtzCommand } from '../../base-command.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({
@@ -22,42 +22,22 @@ export default class PlotLogin extends XtzCommand {
                 return;
             }
             if (phase === 'auth_started') {
-                if (auth.authorizedWithStoredXiantao) {
-                    this.log('已使用现有仙桃网页登录自动完成上传授权，等待确认...');
-                    return;
-                }
-                this.log(auth.browserOpened ? '浏览器已打开上传授权链接，等待授权完成...' : `请先在浏览器中打开上传授权链接: ${auth.linkUrl}`);
+                this.log(auth.browserOpened ? '浏览器已打开授权链接，等待授权完成...' : `请先在浏览器中打开授权链接: ${auth.linkUrl}`);
                 return;
             }
-            this.log(auth.authorizedWithStoredXiantao ? '上传授权已确认，已复用现有仙桃网页登录。' : '上传授权已确认，继续仙桃网页登录...');
+            this.log('授权已确认。');
         });
         this.print(flags, {
             agent,
-            auto_authorized: result.auth.authorizedWithStoredXiantao,
             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}`,
+            result.auth.browserOpened
+                ? '浏览器已打开授权链接，请完成授权后运行 `xt status`。'
+                : `请在浏览器中打开: ${result.auth.linkUrl}`,
         ].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,7 +25,7 @@ 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, {

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,7 +19,7 @@ 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, {

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, {

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',

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',

package/dist/commands/tool/inspect.js

@@ -1,10 +1,10 @@
 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 { isJsonObject } from '../../lib/json.js';
 import { resolveXiantaoToolProductUuid } from '../../lib/storage.js';
-import { getXiantaoAuthContext } from '../../lib/xiantao-auth.js';
 import { fetchAllPlotArgs, resolveToolMenuByCode } from '../../lib/xiantao.js';
 export default class ToolInspect extends XtzCommand {
     static description = 'Inspect a Xiantao tool and its dynamic inputs';
@@ -17,7 +17,7 @@ export default class ToolInspect 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',
@@ -26,7 +26,7 @@ export default class ToolInspect extends XtzCommand {
     async run() {
         const { args, flags } = await this.parse(ToolInspect);
         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.tool);
         const fetchAllResult = await fetchAllPlotArgs(auth, {

package/dist/commands/tool/prepare.js

@@ -38,7 +38,7 @@ export default class ToolPrepare 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',

package/dist/commands/tool/search.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 { fetchToolMenus, searchResolvedToolMenus } from '../../lib/xiantao.js';
 export default class ToolSearch extends XtzCommand {
     static description = 'Search Xiantao tools by keyword';
@@ -15,7 +15,7 @@ export default class ToolSearch 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',
@@ -24,7 +24,7 @@ export default class ToolSearch extends XtzCommand {
     async run() {
         const { args, flags } = await this.parse(ToolSearch);
         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 tools = searchResolvedToolMenus(await fetchToolMenus(auth, toolProductUuid), args.keyword);
         const output = {

package/dist/lib/auth.js

@@ -2,39 +2,41 @@ import { AUTH_URL_ENDPOINT, CHECK_TOKEN_ENDPOINT } from './constants.js';
 import { XtzError } from './errors.js';
 import { openUrl } from './open-url.js';
 import { requestJson } from './http.js';
-import { requireToken, saveToken } from './storage.js';
+import { loadToken, requireToken, saveToken } from './storage.js';
 export async function fetchAuthLink(agent) {
-    const response = await requestJson(AUTH_URL_ENDPOINT);
+    const token = await loadToken(agent);
+    const response = await requestJson(AUTH_URL_ENDPOINT, {
+        headers: buildAgentHeaders(token),
+    }, { agent });
     const link = new URL(response.data.link_url);
     link.searchParams.set('source', agent);
     return {
-        authKey: response.data.auth_key,
         linkUrl: link.toString(),
         tokenKey: response.data.token_key,
     };
 }
 export async function loginAuth(agent, openBrowser = true) {
-    const { authKey, linkUrl, tokenKey } = await fetchAuthLink(agent);
+    const { linkUrl, tokenKey } = await fetchAuthLink(agent);
     const tokenPath = await saveToken(agent, tokenKey);
     const browserOpened = openBrowser ? await openUrl(linkUrl) : false;
     return {
-        authKey,
-        authorizedWithStoredXiantao: false,
         browserOpened,
         linkUrl,
         token: tokenKey,
         tokenPath,
     };
 }
-export async function getAuthContext(agent) {
-    const token = await requireToken(agent);
+export async function getAuthContext(agent, tokenOverride) {
+    const token = tokenOverride?.trim() || await requireToken(agent);
     return { agent, token };
 }
 export async function checkToken(agent, token) {
     const targetToken = token ?? await requireToken(agent);
     const url = new URL(CHECK_TOKEN_ENDPOINT);
     url.searchParams.set('token_key', targetToken);
-    const response = await requestJson(url.toString(), {}, { agent });
+    const response = await requestJson(url.toString(), {
+        headers: buildAgentHeaders(targetToken),
+    }, { agent });
     return response.data;
 }
 export async function waitForAuthorizedToken(token, options = {}) {
@@ -50,14 +52,16 @@ export async function waitForAuthorizedToken(token, options = {}) {
         lastMessage = result.message?.trim() || lastMessage;
         await new Promise((resolve) => setTimeout(resolve, intervalMs));
     }
-    throw new XtzError(lastMessage ? `等待上传授权完成超时: ${lastMessage}` : '等待上传授权完成超时，请重新运行 `xt login`。');
+    throw new XtzError(lastMessage ? `等待授权完成超时: ${lastMessage}` : '等待授权完成超时，请重新运行 `xt login`。');
 }
 async function pollAuthorizedToken(token) {
     const url = new URL(CHECK_TOKEN_ENDPOINT);
     url.searchParams.set('token_key', token);
     let response;
     try {
-        response = await fetch(url.toString());
+        response = await fetch(url.toString(), {
+            headers: buildAgentHeaders(token),
+        });
     }
     catch {
         throw new XtzError('网络请求失败，请稍后重试。');
@@ -74,3 +78,13 @@ async function pollAuthorizedToken(token) {
         throw new XtzError('服务返回了无法解析的响应。');
     }
 }
+function buildAgentHeaders(token) {
+    const headers = {
+        platform: 'pc',
+        source: 'PC',
+    };
+    if (token?.trim()) {
+        headers.Authorization = `Bearer ${token.trim()}`;
+    }
+    return headers;
+}

package/dist/lib/constants.js

@@ -1,11 +1,9 @@
 export const DEFAULT_AGENT = 'opencode';
 export const XTZ_CONFIG_PATH = '.config/xtz/config.json';
-export const AUTH_URL_ENDPOINT = 'https://api.helixlife.net/api/v1/user/skills/auth_url';
-export const AUTH_BIND_ENDPOINT = 'https://api.helixlife.net/api/v1/user/skills/bind_user';
-export const PASSPORT_JUMP_ENDPOINT = 'https://passport.helixlife.net/jump';
-export const XIANTAO_BIO_API_ENDPOINT = 'https://api.helixlife.net/api/v1/xiantaozi/bio-api';
-export const XIANTAO_TOOL_MENUS_ENDPOINT = 'https://api.helixlife.net/api/v1/xiantaozi/tool/menus';
-export const XIANTAO_MENU_CACHE_MAX_AGE_MS = 12 * 60 * 60 * 1000;
+export const XTZ_UPDATE_CHECK_PATH = '.config/xtz/update-check.json';
+export const AUTH_URL_ENDPOINT = 'https://agent.helixlife.net/api/v1/agent/skills/auth-url';
+export const XIANTAO_BIO_API_ENDPOINT = 'https://agent.helixlife.net/api/v1/agent/bio-api';
+export const XIANTAO_TOOL_MENUS_ENDPOINT = 'https://agent.helixlife.net/api/v1/agent/tool/menus';
 export const DEFAULT_XIANTAO_TOOL_PRODUCT_UUID = 'c0b6febb-52dd-4525-970a-61bbe9e263ff';
 export const CHECK_TOKEN_ENDPOINT = 'https://agent.helixlife.net/api/v1/agent/skills/check-token';
 export const UPLOAD_CONFIG_ENDPOINT = 'https://agent.helixlife.net/api/v1/agent/upload/config?type=bio&oss_type=bio';

package/dist/lib/errors.js

@@ -1,4 +1,4 @@
-import { deleteToken, deleteXiantaoToken } from './storage.js';
+import { deleteToken } from './storage.js';
 export class XtzError extends Error {
     constructor(message) {
         super(message);
@@ -14,20 +14,11 @@ function isAuthExpiredMessage(message) {
 export async function raiseApiError(payload, options = {}) {
     const message = payload.message ?? '请求失败';
     const code = String(payload.code ?? '');
-    const tokenKind = options.tokenKind ?? 'agent';
     if (isAuthExpiredMessage(message)) {
         if (options.agent) {
-            if (tokenKind === 'xiantao') {
-                await deleteXiantaoToken(options.agent);
-            }
-            else {
-                await deleteToken(options.agent);
-            }
+            await deleteToken(options.agent);
         }
-        if (tokenKind === 'xiantao') {
-            throw new XtzError('您的仙桃网页授权已过期或无效，请重新运行 `xt login`。');
-        }
-        throw new XtzError('您的授权已过期或无效，请重新运行 `xt login`。');
+        throw new XtzError('您的授权已过期或无效，请重新完成授权。');
     }
     if (message.includes('无权限') || message.includes('权限')) {
         throw new XtzError('需购买仙桃高级版 https://www.xiantaozi.com/');
@@ -38,6 +29,9 @@ export async function raiseApiError(payload, options = {}) {
     if (code === '4000020101' || code === '400008') {
         throw new XtzError('您的账号状态异常，请联系 https://www.helixlife.cn');
     }
+    if (code === '400004') {
+        throw new XtzError('该菜单或商品已下架，请更换 tool_product_uuid 或 menu uuid。');
+    }
     if (code === '50000' || code === '40000' || code === '40004') {
         throw new XtzError('请前往 https://www.helixlife.cn 联系客服');
     }

package/dist/lib/login-flow.js

@@ -1,19 +1,10 @@
 import { loginAuth, waitForAuthorizedToken } from './auth.js';
-import { openUrl } from './open-url.js';
-import { bindUserWithStoredXiantaoToken, loginXiantao } from './xiantao-auth.js';
 export async function loginAll(agent, openAuthBrowser = true, onProgress) {
-    const auth = await loginAuth(agent, false);
-    const reusedXiantao = await bindUserWithStoredXiantaoToken(agent, auth.authKey);
-    auth.authorizedWithStoredXiantao = Boolean(reusedXiantao);
-    if (!reusedXiantao && openAuthBrowser) {
-        auth.browserOpened = await openUrl(auth.linkUrl);
-    }
+    const auth = await loginAuth(agent, openAuthBrowser);
     onProgress?.({ auth, phase: 'auth_started' });
     await waitForAuthorizedToken(auth.token);
     onProgress?.({ auth, phase: 'auth_confirmed' });
-    const xiantao = reusedXiantao ?? await loginXiantao(agent);
     return {
         auth,
-        xiantao,
     };
 }

package/dist/lib/storage.js

@@ -8,24 +8,12 @@ import { isJsonObject } from './json.js';
 export function getTokenPath(agent) {
     return path.join(os.homedir(), '.config', 'helix', agent, 'token-key.txt');
 }
-export function getXiantaoTokenPath(agent) {
-    return path.join(os.homedir(), '.config', 'helix', agent, 'xiantao-token.txt');
-}
-function getXiantaoMenuCachePath(agent, toolProductUuid) {
-    return path.join(os.homedir(), '.config', 'xtz', 'menus', agent, `${toolProductUuid}.json`);
-}
 export async function saveToken(agent, token) {
     const tokenPath = getTokenPath(agent);
     await mkdir(path.dirname(tokenPath), { recursive: true });
     await writeFile(tokenPath, `${token.trim()}\n`, 'utf8');
     return tokenPath;
 }
-export async function saveXiantaoToken(agent, token) {
-    const tokenPath = getXiantaoTokenPath(agent);
-    await mkdir(path.dirname(tokenPath), { recursive: true });
-    await writeFile(tokenPath, `${token.trim()}\n`, 'utf8');
-    return tokenPath;
-}
 export async function loadToken(agent) {
     const tokenPath = getTokenPath(agent);
     try {
@@ -39,19 +27,6 @@ export async function loadToken(agent) {
         throw error;
     }
 }
-export async function loadXiantaoToken(agent) {
-    const tokenPath = getXiantaoTokenPath(agent);
-    try {
-        const token = await readFile(tokenPath, 'utf8');
-        return token.trim() || undefined;
-    }
-    catch (error) {
-        if (isNodeError(error) && error.code === 'ENOENT') {
-            return undefined;
-        }
-        throw error;
-    }
-}
 export async function requireToken(agent) {
     const token = await loadToken(agent);
     if (token) {
@@ -59,13 +34,6 @@ export async function requireToken(agent) {
     }
     throw new XtzError(`未找到 ${agent} 的 token，请先运行 \`xt login --profile ${agent}\``);
 }
-export async function requireXiantaoToken(agent) {
-    const token = await loadXiantaoToken(agent);
-    if (token) {
-        return token;
-    }
-    throw new XtzError(`未找到 ${agent} 的仙桃网页 token，请先运行 \`xt login --profile ${agent}\``);
-}
 export async function deleteToken(agent) {
     const tokenPath = getTokenPath(agent);
     try {
@@ -79,44 +47,6 @@ export async function deleteToken(agent) {
         throw error;
     }
 }
-export async function deleteXiantaoToken(agent) {
-    const tokenPath = getXiantaoTokenPath(agent);
-    try {
-        await rm(tokenPath);
-        return true;
-    }
-    catch (error) {
-        if (isNodeError(error) && error.code === 'ENOENT') {
-            return false;
-        }
-        throw error;
-    }
-}
-export async function loadXiantaoMenuCache(agent, toolProductUuid, maxAgeMs) {
-    const cachePath = getXiantaoMenuCachePath(agent, toolProductUuid);
-    try {
-        const content = await readFile(cachePath, 'utf8');
-        const parsed = JSON.parse(content);
-        if (typeof parsed.cachedAt !== 'number' || Date.now() - parsed.cachedAt > maxAgeMs) {
-            return undefined;
-        }
-        return parsed.data;
-    }
-    catch (error) {
-        if (isNodeError(error) && error.code === 'ENOENT') {
-            return undefined;
-        }
-        throw error;
-    }
-}
-export async function saveXiantaoMenuCache(agent, toolProductUuid, data) {
-    const cachePath = getXiantaoMenuCachePath(agent, toolProductUuid);
-    await mkdir(path.dirname(cachePath), { recursive: true });
-    await writeFile(cachePath, JSON.stringify({
-        cachedAt: Date.now(),
-        data,
-    }), 'utf8');
-}
 export async function readXtzConfig() {
     const configPath = path.join(os.homedir(), XTZ_CONFIG_PATH);
     try {

package/dist/lib/update.js

@@ -0,0 +1,151 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { XTZ_UPDATE_CHECK_PATH } from './constants.js';
+import { isJsonObject } from './json.js';
+const NPM_PACKAGE_NAME = '@helixlife-ai/xiantao';
+const NPM_LATEST_VERSION_URL = `https://registry.npmjs.org/${encodeURIComponent(NPM_PACKAGE_NAME)}/latest`;
+const UPDATE_CHECK_INTERVAL_MS = 12 * 60 * 60 * 1000;
+const UPDATE_CHECK_TIMEOUT_MS = 1200;
+export async function getUpdateReminder(currentVersion) {
+    try {
+        const state = await readUpdateCheckState();
+        const latestVersion = await resolveLatestVersion(state);
+        if (!latestVersion || compareVersions(latestVersion, currentVersion) <= 0) {
+            return;
+        }
+        return `检测到新版本 ${latestVersion}（当前 ${currentVersion}），可运行 \`npm install -g ${NPM_PACKAGE_NAME}@latest\` 更新。`;
+    }
+    catch {
+        return;
+    }
+}
+async function resolveLatestVersion(state) {
+    const now = Date.now();
+    const lastCheckedAt = state.lastCheckedAt ? Date.parse(state.lastCheckedAt) : Number.NaN;
+    if (Number.isFinite(lastCheckedAt) && now - lastCheckedAt < UPDATE_CHECK_INTERVAL_MS) {
+        return state.latestVersion?.trim() || undefined;
+    }
+    const latestVersion = await fetchLatestVersion();
+    await writeUpdateCheckState({
+        lastCheckedAt: new Date(now).toISOString(),
+        latestVersion: latestVersion ?? state.latestVersion,
+    });
+    return latestVersion ?? (state.latestVersion?.trim() || undefined);
+}
+async function fetchLatestVersion() {
+    const response = await fetch(NPM_LATEST_VERSION_URL, {
+        headers: {
+            accept: 'application/json',
+        },
+        signal: AbortSignal.timeout(UPDATE_CHECK_TIMEOUT_MS),
+    });
+    if (!response.ok) {
+        return;
+    }
+    const payload = JSON.parse(await response.text());
+    if (!isJsonObject(payload) || typeof payload.version !== 'string') {
+        return;
+    }
+    return payload.version.trim() || undefined;
+}
+async function readUpdateCheckState() {
+    const filePath = getUpdateCheckPath();
+    try {
+        const content = await readFile(filePath, 'utf8');
+        const parsed = JSON.parse(content);
+        if (!isJsonObject(parsed)) {
+            return {};
+        }
+        return {
+            lastCheckedAt: typeof parsed.lastCheckedAt === 'string' ? parsed.lastCheckedAt : undefined,
+            latestVersion: typeof parsed.latestVersion === 'string' ? parsed.latestVersion : undefined,
+        };
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === 'ENOENT') {
+            return {};
+        }
+        throw error;
+    }
+}
+async function writeUpdateCheckState(state) {
+    const filePath = getUpdateCheckPath();
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+}
+function compareVersions(left, right) {
+    const parsedLeft = parseVersion(left);
+    const parsedRight = parseVersion(right);
+    if (!parsedLeft || !parsedRight) {
+        return left.localeCompare(right);
+    }
+    const coreLength = Math.max(parsedLeft.core.length, parsedRight.core.length);
+    for (let index = 0; index < coreLength; index += 1) {
+        const delta = (parsedLeft.core[index] ?? 0) - (parsedRight.core[index] ?? 0);
+        if (delta !== 0) {
+            return delta;
+        }
+    }
+    if (parsedLeft.prerelease.length === 0 && parsedRight.prerelease.length === 0) {
+        return 0;
+    }
+    if (parsedLeft.prerelease.length === 0) {
+        return 1;
+    }
+    if (parsedRight.prerelease.length === 0) {
+        return -1;
+    }
+    const prereleaseLength = Math.max(parsedLeft.prerelease.length, parsedRight.prerelease.length);
+    for (let index = 0; index < prereleaseLength; index += 1) {
+        const leftPart = parsedLeft.prerelease[index];
+        const rightPart = parsedRight.prerelease[index];
+        if (leftPart === undefined) {
+            return -1;
+        }
+        if (rightPart === undefined) {
+            return 1;
+        }
+        const leftIsNumber = /^[0-9]+$/.test(leftPart);
+        const rightIsNumber = /^[0-9]+$/.test(rightPart);
+        if (leftIsNumber && rightIsNumber) {
+            const delta = Number(leftPart) - Number(rightPart);
+            if (delta !== 0) {
+                return delta;
+            }
+            continue;
+        }
+        if (leftIsNumber) {
+            return -1;
+        }
+        if (rightIsNumber) {
+            return 1;
+        }
+        const delta = leftPart.localeCompare(rightPart);
+        if (delta !== 0) {
+            return delta;
+        }
+    }
+    return 0;
+}
+function parseVersion(version) {
+    const normalized = version.trim().replace(/^v/, '');
+    if (!normalized) {
+        return;
+    }
+    const [corePart, prereleasePart] = normalized.split('-', 2);
+    const core = corePart.split('.').map((part) => Number.parseInt(part, 10));
+    if (core.some((part) => Number.isNaN(part))) {
+        return;
+    }
+    return {
+        core,
+        prerelease: prereleasePart ? prereleasePart.split('.').filter(Boolean) : [],
+    };
+}
+function getUpdateCheckPath() {
+    return path.join(os.homedir(), XTZ_UPDATE_CHECK_PATH);
+}
+function isNodeError(error) {
+    return error instanceof Error && 'code' in error;
+}

package/dist/lib/xiantao-plot.js

@@ -28,7 +28,7 @@ export async function verifyXiantaoPlotUpload(auth, input) {
         }),
         headers: buildXiantaoHeaders(auth, true),
         method: 'POST',
-    }, { agent: auth.agent, tokenKind: 'xiantao' });
+    }, { agent: auth.agent });
     const duid = response.data.id?.duid;
     if (!duid) {
         throw new XtzError(response.message ?? '未获取到 duid');
@@ -68,7 +68,7 @@ export async function submitXiantaoPlot(auth, input) {
         }),
         headers: buildXiantaoHeaders(auth, true),
         method: 'POST',
-    }, { agent: auth.agent, tokenKind: 'xiantao' });
+    }, { agent: auth.agent });
     const downloads = collectDownloadItems(response.data.data);
     const file = typeof response.data.file === 'string' && response.data.file.trim()
         ? response.data.file.trim()
@@ -105,7 +105,7 @@ export async function resolveXiantaoDownload(auth, input) {
         }),
         headers: buildXiantaoHeaders(auth, true),
         method: 'POST',
-    }, { agent: auth.agent, tokenKind: 'xiantao' });
+    }, { agent: auth.agent });
     const url = response.data.url?.trim();
     if (!url) {
         throw new XtzError(response.message ?? '未获取到下载链接');

package/dist/lib/xiantao.js

@@ -1,21 +1,28 @@
-import { XIANTAO_BIO_API_ENDPOINT, XIANTAO_MENU_CACHE_MAX_AGE_MS, XIANTAO_TOOL_MENUS_ENDPOINT } from './constants.js';
+import { XIANTAO_BIO_API_ENDPOINT, XIANTAO_TOOL_MENUS_ENDPOINT } from './constants.js';
 import { XtzError } from './errors.js';
 import { requestJson } from './http.js';
-import { loadXiantaoMenuCache, saveXiantaoMenuCache } from './storage.js';
 export async function fetchToolMenu(auth, menuUuid, toolProductUuid) {
     const url = new URL(`${XIANTAO_TOOL_MENUS_ENDPOINT}/${menuUuid}`);
     url.searchParams.set('f', encodeMenuFilter({ tool_product_uuid: toolProductUuid }));
-    const response = await requestJson(url.toString(), {
-        headers: buildXiantaoHeaders(auth),
-        method: 'GET',
-    }, { agent: auth.agent, tokenKind: 'xiantao' });
-    return response.data;
+    try {
+        const response = await requestJson(url.toString(), {
+            headers: buildXiantaoHeaders(auth),
+            method: 'GET',
+        }, { agent: auth.agent });
+        return response.data;
+    }
+    catch (error) {
+        if (!(error instanceof XtzError) || !error.message.includes('已下架')) {
+            throw error;
+        }
+        const fallback = findToolMenu(await fetchToolMenus(auth, toolProductUuid), menuUuid);
+        if (fallback) {
+            return fallback;
+        }
+        throw error;
+    }
 }
 export async function fetchToolMenus(auth, toolProductUuid) {
-    const cached = await loadXiantaoMenuCache(auth.agent, toolProductUuid, XIANTAO_MENU_CACHE_MAX_AGE_MS);
-    if (cached) {
-        return cached;
-    }
     const url = new URL(XIANTAO_TOOL_MENUS_ENDPOINT);
     url.searchParams.set('f', encodeMenuFilter({
         is_all: 1,
@@ -24,8 +31,7 @@ export async function fetchToolMenus(auth, toolProductUuid) {
     const response = await requestJson(url.toString(), {
         headers: buildXiantaoHeaders(auth),
         method: 'GET',
-    }, { agent: auth.agent, tokenKind: 'xiantao' });
-    await saveXiantaoMenuCache(auth.agent, toolProductUuid, response.data);
+    }, { agent: auth.agent });
     return response.data;
 }
 export async function resolveToolMenuByCode(auth, toolProductUuid, code) {
@@ -70,7 +76,7 @@ export async function fetchAllPlotArgs(auth, input) {
         }),
         headers: buildXiantaoHeaders(auth, true),
         method: 'POST',
-    }, { agent: auth.agent, tokenKind: 'xiantao' });
+    }, { agent: auth.agent });
     return response.data;
 }
 function collectToolMenuMatches(menus, code) {
@@ -97,6 +103,21 @@ function collectToolMenuMatches(menus, code) {
     }
     return matches;
 }
+function findToolMenu(menus, target) {
+    const normalizedTarget = target.trim();
+    for (const menu of menus) {
+        if (menu.uuid?.trim() === normalizedTarget || String(menu.id ?? '').trim() === normalizedTarget) {
+            return menu;
+        }
+        if (menu.children?.length) {
+            const nested = findToolMenu(menu.children, normalizedTarget);
+            if (nested) {
+                return nested;
+            }
+        }
+    }
+    return undefined;
+}
 function scoreToolMenuMatch(menu, keyword) {
     let score = 0;
     const code = menu.code.toLowerCase();
@@ -130,15 +151,14 @@ function scoreToolMenuMatch(menu, keyword) {
     return score;
 }
 function encodeMenuFilter(filter) {
-    const encoded = encodeURIComponent(JSON.stringify(filter));
-    return Buffer.from(encoded, 'utf8').toString('base64');
+    return encodeURIComponent(JSON.stringify(filter));
 }
 export function buildXiantaoHeaders(auth, hasJsonBody = false) {
     const headers = {
         Authorization: `Bearer ${auth.token}`,
-        origin: 'https://www.xiantao.xyz',
+        origin: 'https://agent.helixlife.net',
         platform: 'pc',
-        referer: 'https://www.xiantao.xyz/',
+        referer: 'https://agent.helixlife.net',
         source: 'PC',
     };
     if (hasJsonBody) {

package/dist/xtz-help.js

@@ -11,15 +11,15 @@ export default class XtzHelp extends Help {
         this.log('');
         this.log(this.section('COMMON COMMANDS', this.renderCommandItems([
             {
-                description: 'Sign in for the current profile and refresh both auth tokens',
+                description: 'Authorize the current profile token',
                 id: 'login',
             },
             {
-                description: 'Show upload auth status for the current profile',
+                description: 'Show token auth status for the current profile',
                 id: 'status',
             },
             {
-                description: 'Delete the stored upload token for the current profile',
+                description: 'Delete the stored token for the current profile',
                 id: 'logout',
             },
             {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@helixlife-ai/xiantao",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "description": "CLI for Xiantao bioinformatics tools",
   "type": "module",
   "main": "dist/index.js",

package/dist/commands/auth/bind.js

@@ -1,53 +0,0 @@
-import { Flags } from '@oclif/core';
-import { XtzCommand } from '../../base-command.js';
-import { loginAuth, waitForAuthorizedToken } from '../../lib/auth.js';
-import { globalFlags } from '../../lib/flags.js';
-import { bindUserWithXiantaoToken } from '../../lib/xiantao-auth.js';
-import { getTokenPath, getXiantaoTokenPath, loadXiantaoToken, saveToken } from '../../lib/storage.js';
-export default class AuthBind extends XtzCommand {
-    static description = 'Bind login remotely with a Xiantao web token without the localhost callback flow';
-    static flags = {
-        ...globalFlags,
-        'auth-key': Flags.string({
-            char: 'k',
-            description: 'Existing auth key returned by the upload authorization flow',
-        }),
-        'token-key': Flags.string({
-            description: 'Existing upload token key paired with --auth-key',
-        }),
-        'xiantao-token': Flags.string({
-            description: 'Bearer token for api.helixlife.net xiantao APIs; falls back to XIANTAO_TOKEN or the stored Xiantao web token',
-        }),
-    };
-    async run() {
-        this.warnIfLegacyAuthCommand();
-        const { flags } = await this.parse(AuthBind);
-        const agent = await this.getProfile(flags.profile);
-        const token = flags['xiantao-token']?.trim() || process.env.XIANTAO_TOKEN?.trim() || await loadXiantaoToken(agent);
-        if (!token) {
-            this.error(`未找到 ${agent} 的仙桃网页 token，请传 --xiantao-token、设置 XIANTAO_TOKEN，或先准备 ${getXiantaoTokenPath(agent)}`, { exit: 1 });
-        }
-        const auth = flags['auth-key']
-            ? {
-                authKey: flags['auth-key'],
-                token: flags['token-key']?.trim(),
-                tokenPath: getTokenPath(agent),
-            }
-            : await loginAuth(agent, false);
-        if (!auth.token) {
-            this.error('传 --auth-key 时必须同时传 --token-key', { exit: 1 });
-        }
-        if (flags['auth-key']) {
-            await saveToken(agent, auth.token);
-        }
-        const result = await bindUserWithXiantaoToken(agent, auth.authKey, token);
-        await waitForAuthorizedToken(auth.token);
-        this.print(flags, {
-            agent,
-            auth_key: auth.authKey,
-            bound: true,
-            token_path: auth.tokenPath,
-            xiantao_token_path: result.tokenPath,
-        }, `profile: ${agent}\nbound: true\nauth_key: ${auth.authKey}\ntoken: ${auth.tokenPath}\nxiantao_token: ${result.tokenPath}`);
-    }
-}

package/dist/commands/bind.js

@@ -1,3 +0,0 @@
-import AuthBind from './auth/bind.js';
-export default class Bind extends AuthBind {
-}