tyc-cli 0.3.4 → 0.3.5

package/dist/commands/category.js

@@ -1,5 +1,6 @@
 import { getCategories, getToolsByGroup } from "../registry.js";
 import { resolveConfig } from "../config.js";
+import { callCoreTool } from "../coreClient.js";
 import { callTool } from "../mcpClient.js";
 import { jsonToMarkdown } from "../utils/jsonToMarkdown.js";
 import { applyTruncation, resolveOptionalInt, TRUNCATE_DEFAULTS, } from "../utils/truncate.js";
@@ -53,7 +54,9 @@ function bindMethod(catCmd, tool, program) {
         const opts = program.opts();
         const verbose = !!opts.verbose;
         try {
-            const result = await callTool(cfg, tool.name, args, { verbose });
+            const result = cfg.transport === "mcp"
+                ? await callTool(cfg, tool.name, args, { verbose })
+                : await callCoreTool(cfg, tool.name, args, { verbose });
             emit(result, opts, tool.name);
         }
         catch (err) {

package/dist/commands/init.js

@@ -1,12 +1,23 @@
-import { DEFAULT_MCP_URL, loadConfig, resolveConfig, saveConfig } from "../config.js";
+import { DEFAULT_MCP_URL, defaultCoreURL, loadConfig, resolveConfig, saveConfig, } from "../config.js";
+import { verifyCoreEndpoint } from "../coreClient.js";
 import { clearSession } from "../session.js";
 import { ensureSession } from "../mcpClient.js";
+function parseTransport(raw) {
+    if (!raw)
+        return undefined;
+    const v = raw.trim().toLowerCase();
+    if (v === "core" || v === "mcp")
+        return v;
+    throw new Error(`invalid --transport: ${raw} (expected core or mcp)`);
+}
 export function registerInitCommand(program) {
     program
         .command("init")
         .description("配置 MCP endpoint / Authorization（保存到 ~/.tyc/config.json，并校验连通性）")
         .option("--authorization <token>", "tyc OpenAPI Authorization（写入 headers.Authorization）")
         .option("--url <url>", `MCP endpoint（默认 ${DEFAULT_MCP_URL}）`)
+        .option("--core-url <url>", "Shared Core HTTP endpoint（默认从 --url 推导 /v1/core/tools/call）")
+        .option("--transport <core|mcp>", "默认调用通道（默认 core；mcp 保留旧 session 链路）")
         .option("--header <kv...>", "自定义 header，格式 K=V，可重复；留空清除该 key")
         .option("--clear-session", "仅清除本地 MCP session 缓存（~/.tyc/session.json）")
         .option("--no-verify", "跳过连通性校验（不发 initialize）")
@@ -18,6 +29,15 @@ export function registerInitCommand(program) {
             cfg.url = opts.url;
         if (!cfg.url)
             cfg.url = DEFAULT_MCP_URL;
+        const transport = parseTransport(opts.transport);
+        if (transport)
+            cfg.transport = transport;
+        if (!cfg.transport)
+            cfg.transport = "core";
+        if (opts.coreUrl)
+            cfg.coreUrl = opts.coreUrl;
+        if (!cfg.coreUrl)
+            cfg.coreUrl = defaultCoreURL(cfg.url);
         if (opts.authorization)
             cfg.headers.Authorization = opts.authorization;
         if (opts.header && opts.header.length > 0) {
@@ -43,20 +63,26 @@ export function registerInitCommand(program) {
         if (opts.clearSession) {
             console.log("已清除 ~/.tyc/session.json");
         }
-        console.log(`已保存 ~/.tyc/config.json  (url=${cfg.url})`);
+        console.log(`已保存 ~/.tyc/config.json  (transport=${cfg.transport}, url=${cfg.url}, coreUrl=${cfg.coreUrl})`);
         if (opts.verify === false) {
             return;
         }
-        // 立即发 initialize，拿到 Mcp-Session-Id 落盘；失败则非 0 退出
+        // core 模式只探活 stateless endpoint；mcp 模式才 initialize 并缓存 session。
         try {
             const resolved = resolveConfig();
             const verbose = !!program.opts().verbose;
-            const sess = await ensureSession(resolved, { verbose });
-            console.log(`已建立 MCP session（sessionId=${sess.sessionId.slice(0, 16)}…）`);
+            if (resolved.transport === "mcp") {
+                const sess = await ensureSession(resolved, { verbose });
+                console.log(`已建立 MCP session（sessionId=${sess.sessionId.slice(0, 16)}…）`);
+            }
+            else {
+                await verifyCoreEndpoint(resolved, verbose);
+                console.log("Shared Core endpoint 校验通过");
+            }
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            console.error(`MCP 连通性校验失败：${msg}`);
+            console.error(`连通性校验失败：${msg}`);
             console.error("配置已保存；确认 --url 可达后重新运行 tyc init，或加 --no-verify 跳过校验。");
             process.exit(1);
         }

package/dist/commands/login.js

@@ -0,0 +1,210 @@
+import { DEFAULT_MCP_URL, defaultCoreURL, loadConfig, resolveConfig, saveConfig, } from "../config.js";
+import { verifyCoreAuthEndpoint } from "../coreClient.js";
+import { clearSession } from "../session.js";
+import { ensureSession } from "../mcpClient.js";
+import { buildAuthorizationURL, createPKCE, discoverAuthorizationServer, discoverProtectedResourceMetadata, exchangeAuthorizationCode, knownOAuthDefaultsForMcpURL, openBrowser, randomState, registerDynamicOAuthClient, startCallbackServer, } from "../oauth.js";
+import { printLoginSuccessBanner } from "../logo.js";
+function parsePort(raw) {
+    if (!raw)
+        return 0;
+    const n = Number(raw);
+    if (!Number.isInteger(n) || n < 0 || n > 65535) {
+        throw new Error(`invalid --redirect-port: ${raw}`);
+    }
+    return n;
+}
+function normalizeTokenType(raw) {
+    if (!raw)
+        return "Bearer";
+    return raw.toLowerCase() === "bearer" ? "Bearer" : raw;
+}
+export function registerLoginCommand(program) {
+    program
+        .command("login")
+        .description("通过 OAuth 浏览器登录并自动写入 ~/.tyc/config.json")
+        .option("--url <url>", `MCP endpoint（默认 ${DEFAULT_MCP_URL}，或沿用当前配置）`)
+        .option("--issuer <url>", "OAuth authorization server issuer（默认从 MCP metadata 发现）")
+        .option("--client-id <id>", "OAuth client_id（默认通过 DCR 自动注册）")
+        .option("--client-secret <secret>", "OAuth client_secret（默认 TYC_OAUTH_CLIENT_SECRET；公共 CLI 通常不需要）")
+        .option("--scope <scope>", "OAuth scope（默认 mcp:tools.call）")
+        .option("--resource <url>", "OAuth resource/audience（默认从 MCP metadata 发现）")
+        .option("--resource-metadata-url <url>", "手动指定 MCP protected resource metadata URL")
+        .option("--authorization-endpoint <url>", "手动指定 OAuth authorization endpoint")
+        .option("--token-endpoint <url>", "手动指定 OAuth token endpoint")
+        .option("--redirect-host <host>", "本地回调 host（默认 localhost）")
+        .option("--redirect-port <port>", "本地回调端口（默认 7078）")
+        .option("--callback-path <path>", "本地回调路径（默认 /oauth/callback）")
+        .option("--no-open", "不自动打开浏览器，只打印授权 URL")
+        .option("--no-verify", "保存 token 后跳过 initialize 连通性校验")
+        .action(async (opts) => {
+        const current = loadConfig() || {};
+        const mcpURL = opts.url || process.env.TYC_MCP_ENDPOINT || current.url || DEFAULT_MCP_URL;
+        const knownDefaults = knownOAuthDefaultsForMcpURL(mcpURL);
+        let clientId = opts.clientId || process.env.TYC_OAUTH_CLIENT_ID || "";
+        let clientSecret = opts.clientSecret || process.env.TYC_OAUTH_CLIENT_SECRET;
+        const scope = opts.scope || "mcp:tools.call";
+        const redirectHost = opts.redirectHost || "localhost";
+        const redirectPort = parsePort(opts.redirectPort || "7078");
+        const callbackPath = opts.callbackPath || "/oauth/callback";
+        const verbose = !!program.opts().verbose;
+        let issuer = opts.issuer || "";
+        let resource = opts.resource || "";
+        if (!opts.issuer || !opts.resource) {
+            if (verbose) {
+                console.error(`> discovering MCP OAuth metadata: ${mcpURL}`);
+            }
+            try {
+                const protectedResource = await discoverProtectedResourceMetadata(mcpURL, opts.resourceMetadataUrl);
+                if (verbose) {
+                    console.error(`> protected resource metadata: ${protectedResource.metadataURL}`);
+                }
+                const metadataIssuer = protectedResource.metadata.authorization_servers?.[0];
+                if (!issuer && metadataIssuer) {
+                    issuer = metadataIssuer;
+                }
+                resource ||= protectedResource.metadata.resource || mcpURL;
+            }
+            catch (err) {
+                issuer ||= knownDefaults.issuer || "";
+                resource ||= knownDefaults.resource || "";
+                if (!issuer || !resource) {
+                    throw err;
+                }
+                if (verbose) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    console.error(`> metadata discovery failed, using known defaults: ${msg}`);
+                }
+            }
+        }
+        else if (verbose) {
+            console.error("> using explicit --issuer and --resource; skip protected resource metadata discovery");
+        }
+        if (!issuer) {
+            throw new Error("MCP metadata 未提供 authorization_servers，请用 --issuer 指定。");
+        }
+        // 双端点都手动指定时跳过自动发现；否则 metadata 发现失败会直接报错
+        // （discovery 不再猜测端点，见 discoverAuthorizationServer）。
+        let endpoints;
+        if (opts.authorizationEndpoint && opts.tokenEndpoint) {
+            endpoints = {
+                authorizationEndpoint: opts.authorizationEndpoint,
+                tokenEndpoint: opts.tokenEndpoint,
+                issuer,
+            };
+        }
+        else {
+            endpoints = await discoverAuthorizationServer(issuer);
+            endpoints.authorizationEndpoint =
+                opts.authorizationEndpoint || endpoints.authorizationEndpoint;
+            endpoints.tokenEndpoint = opts.tokenEndpoint || endpoints.tokenEndpoint;
+        }
+        resource ||= endpoints.resourceDocumentation || mcpURL;
+        if (verbose) {
+            console.error(`> authorization endpoint: ${endpoints.authorizationEndpoint}`);
+            console.error(`> token endpoint: ${endpoints.tokenEndpoint}`);
+            if (endpoints.registrationEndpoint) {
+                console.error(`> registration endpoint: ${endpoints.registrationEndpoint}`);
+            }
+        }
+        const state = randomState();
+        const pkce = createPKCE();
+        const callback = await startCallbackServer({
+            host: redirectHost,
+            port: redirectPort,
+            path: callbackPath.startsWith("/") ? callbackPath : `/${callbackPath}`,
+            state,
+            timeoutMs: 5 * 60 * 1000,
+        });
+        if (!clientId) {
+            if (!endpoints.registrationEndpoint) {
+                callback.close();
+                throw new Error("OAuth metadata 未提供 registration_endpoint，请用 --client-id 指定预注册客户端。");
+            }
+            if (verbose) {
+                console.error("> registering OAuth client via Dynamic Client Registration");
+            }
+            let registeredClient;
+            try {
+                registeredClient = await registerDynamicOAuthClient({
+                    registrationEndpoint: endpoints.registrationEndpoint,
+                    clientName: "tyc-cli",
+                    redirectUris: [callback.redirectUri],
+                    tokenEndpointAuthMethod: "none",
+                });
+            }
+            catch (err) {
+                callback.close();
+                throw err;
+            }
+            clientId = registeredClient.clientId;
+            clientSecret ||= registeredClient.clientSecret;
+            if (verbose) {
+                console.error(`> registered client_id: ${clientId}`);
+            }
+        }
+        const authorizationURL = buildAuthorizationURL({
+            authorizationEndpoint: endpoints.authorizationEndpoint,
+            clientId,
+            redirectUri: callback.redirectUri,
+            scope,
+            state,
+            codeChallenge: pkce.codeChallenge,
+            resource,
+        });
+        if (verbose) {
+            console.error(`> OAuth callback: ${callback.redirectUri}`);
+        }
+        if (opts.open === false) {
+            console.error("请在浏览器打开以下 URL 完成登录：");
+            console.error(authorizationURL);
+        }
+        else {
+            console.error("正在打开浏览器完成 OAuth 登录...");
+            openBrowser(authorizationURL);
+        }
+        const code = await callback.waitForCode();
+        if (verbose) {
+            console.error("> authorization code received; exchanging access token");
+        }
+        const token = await exchangeAuthorizationCode({
+            tokenEndpoint: endpoints.tokenEndpoint,
+            clientId,
+            clientSecret,
+            code,
+            redirectUri: callback.redirectUri,
+            codeVerifier: pkce.codeVerifier,
+            resource,
+        });
+        const cfg = loadConfig() || {};
+        cfg.url = mcpURL;
+        if (!cfg.transport)
+            cfg.transport = "core";
+        if (!cfg.coreUrl)
+            cfg.coreUrl = defaultCoreURL(mcpURL);
+        cfg.headers = { ...(cfg.headers || {}) };
+        cfg.headers.Authorization = `${normalizeTokenType(token.token_type)} ${token.access_token}`;
+        saveConfig(cfg);
+        clearSession();
+        if (verbose) {
+            console.error(`> OAuth login state saved to ~/.tyc/config.json (url=${cfg.url})`);
+        }
+        if (opts.verify === false) {
+            printLoginSuccessBanner();
+            return;
+        }
+        const resolved = resolveConfig();
+        if (resolved.transport === "mcp") {
+            const sess = await ensureSession(resolved, { verbose });
+            if (verbose) {
+                console.error(`> MCP session initialized (sessionId=${sess.sessionId.slice(0, 16)}...)`);
+            }
+        }
+        else {
+            await verifyCoreAuthEndpoint(resolved, verbose);
+            if (verbose) {
+                console.error("> Shared Core auth check passed");
+            }
+        }
+        printLoginSuccessBanner();
+    });
+}

package/dist/config.js

@@ -1,17 +1,20 @@
 // ~/.tyc/config.json 读写
 //
 // 配置文件格式与通用 MCP 客户端保持一致：
-//   { "url": "https://mcp.tianyancha.com/v1",
-//     "headers": { "Authorization": "xxxx" } }
+//   { "url": "https://mcp.tianyancha.com/mcp",
+//     "headers": { "Authorization": "xxxx" },
+//     "transport": "core",
+//     "coreUrl": "https://mcp.tianyancha.com/v1/core/tools/call" }
 //
-// 默认端点指向天眼查公网 MCP Server；连接本地或私有环境可通过
-//   tyc init --url http://localhost:8080/v1 或 TYC_MCP_ENDPOINT 环境变量覆盖。
+// 默认端点指向天眼查公网 MCP Server 的 canonical 入口 /mcp（/v1 是兼容别名，
+// coreUrl 的 REST 端点仍只挂在 /v1/core 下）；连接本地或私有环境可通过
+//   tyc init --url http://localhost:8080/mcp 或 TYC_MCP_ENDPOINT 环境变量覆盖。
 import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 const CONFIG_DIR = join(homedir(), ".tyc");
 const CONFIG_FILE = join(CONFIG_DIR, "config.json");
-export const DEFAULT_MCP_URL = "https://mcp.tianyancha.com/v1";
+export const DEFAULT_MCP_URL = "https://mcp.tianyancha.com/mcp";
 export function loadConfig() {
     if (!existsSync(CONFIG_FILE))
         return null;
@@ -32,9 +35,30 @@ export function saveConfig(config) {
     }
     catch { /* best effort */ }
 }
+function normalizeTransport(raw) {
+    const v = (raw || "").trim().toLowerCase();
+    if (v === "mcp")
+        return "mcp";
+    return "core";
+}
+export function defaultCoreURL(mcpURL) {
+    const u = new URL(mcpURL);
+    const path = u.pathname.replace(/\/+$/, "");
+    if (path === "" || path === "/v1" || path === "/mcp") {
+        u.pathname = "/v1/core/tools/call";
+    }
+    else if (!path.endsWith("/core/tools/call")) {
+        u.pathname = `${path}/core/tools/call`;
+    }
+    u.search = "";
+    u.hash = "";
+    return u.toString();
+}
 export function resolveConfig() {
     const cfg = loadConfig() || {};
     const url = process.env.TYC_MCP_ENDPOINT || cfg.url || DEFAULT_MCP_URL;
+    const transport = normalizeTransport(process.env.TYC_TRANSPORT || cfg.transport);
+    const coreUrl = process.env.TYC_CORE_ENDPOINT || cfg.coreUrl || defaultCoreURL(url);
     const headers = { ...(cfg.headers || {}) };
     if (!headers.Authorization && process.env.TYC_AUTHORIZATION) {
         headers.Authorization = process.env.TYC_AUTHORIZATION;
@@ -43,5 +67,5 @@ export function resolveConfig() {
         console.error("未配置 Authorization。请先运行：tyc init --authorization YOUR_API_KEY");
         process.exit(1);
     }
-    return { url, headers };
+    return { url, coreUrl, transport, headers };
 }

package/dist/coreClient.js

@@ -0,0 +1,121 @@
+function maskToken(v) {
+    if (!v)
+        return "";
+    if (v.length <= 8)
+        return "****";
+    return v.slice(0, 4) + "****" + v.slice(-4);
+}
+function coreSiblingURL(coreUrl, siblingPath) {
+    const u = new URL(coreUrl);
+    const path = u.pathname.replace(/\/+$/, "");
+    if (path.endsWith("/tools/call")) {
+        u.pathname = path.slice(0, -"/tools/call".length) + siblingPath;
+    }
+    else {
+        u.pathname = path + siblingPath;
+    }
+    u.search = "";
+    u.hash = "";
+    return u.toString();
+}
+function readyURL(coreUrl) {
+    return coreSiblingURL(coreUrl, "/ready");
+}
+function authReadyURL(coreUrl) {
+    return coreSiblingURL(coreUrl, "/auth/ready");
+}
+export async function verifyCoreEndpoint(cfg, verbose = false) {
+    const url = readyURL(cfg.coreUrl);
+    if (verbose)
+        console.error(`> GET ${url}`);
+    const resp = await fetch(url, {
+        method: "GET",
+        headers: { Accept: "text/plain" },
+    });
+    const text = await resp.text();
+    if (verbose) {
+        console.error(`< ${resp.status} ${resp.statusText}`);
+        console.error(`< body: ${text.slice(0, 500)}`);
+    }
+    if (resp.status < 200 || resp.status >= 300) {
+        throw new Error(`core endpoint 校验失败：HTTP ${resp.status}\n${text.slice(0, 500)}`);
+    }
+}
+export async function verifyCoreAuthEndpoint(cfg, verbose = false) {
+    const url = authReadyURL(cfg.coreUrl);
+    if (verbose)
+        console.error(`> GET ${url}`);
+    const headers = {
+        Accept: "application/json, text/plain",
+        ...cfg.headers,
+    };
+    const resp = await fetch(url, {
+        method: "GET",
+        headers,
+    });
+    const text = await resp.text();
+    if (verbose) {
+        console.error(`< ${resp.status} ${resp.statusText}`);
+        console.error(`< body: ${text.slice(0, 500)}`);
+    }
+    if (resp.status < 200 || resp.status >= 300) {
+        let desc = text.slice(0, 500);
+        try {
+            const parsed = JSON.parse(text);
+            desc = String(parsed.error_description || parsed.error || desc);
+        }
+        catch {
+            // keep raw text
+        }
+        throw new Error(`core/auth/ready HTTP ${resp.status}\n${desc}`);
+    }
+}
+export async function callCoreTool(cfg, name, args, opts) {
+    const verbose = !!opts?.verbose;
+    const headers = {
+        "Content-Type": "application/json",
+        Accept: "application/json",
+        ...cfg.headers,
+    };
+    const body = {
+        tool_name: name,
+        arguments: args,
+        format: "json",
+    };
+    if (verbose) {
+        const masked = {};
+        for (const [k, v] of Object.entries(headers)) {
+            masked[k] = k.toLowerCase() === "authorization" ? maskToken(v) : v;
+        }
+        console.error(`> POST ${cfg.coreUrl}`);
+        console.error(`> transport: core`);
+        console.error(`> headers: ${JSON.stringify(masked)}`);
+        console.error(`> body: ${JSON.stringify(body)}`);
+    }
+    const resp = await fetch(cfg.coreUrl, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+    });
+    const text = await resp.text();
+    if (verbose) {
+        console.error(`< ${resp.status} ${resp.statusText}`);
+        console.error(`< body: ${text.slice(0, 2000)}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        throw new Error(`core 响应不是 JSON：HTTP ${resp.status}\n${text.slice(0, 500)}`);
+    }
+    if (resp.status < 200 || resp.status >= 300) {
+        const desc = parsed.error_description || parsed.error || text.slice(0, 500);
+        throw new Error(`core/tools/call HTTP ${resp.status}\n${desc}`);
+    }
+    const content = parsed.content;
+    const contentText = typeof content === "string" ? content : JSON.stringify(content ?? {});
+    return {
+        content: [{ type: "text", text: contentText }],
+    };
+}

package/dist/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import { Command } from "commander";
 import { registerInitCommand } from "./commands/init.js";
+import { registerLoginCommand } from "./commands/login.js";
 import { registerCategoryCommands } from "./commands/category.js";
 import { registerLayerCommands } from "./commands/layers.js";
 import { getCategories, getLayerCount, getPriorityTools, getTotalCount, } from "./registry.js";
@@ -67,7 +68,7 @@ OUTPUT FORMATS (mutually exclusive, priority: --md > --compact > --pretty / defa
   --pretty     same as default (kept for backward compatibility / explicit intent)
   --compact    compact single-line JSON (pipe / jq friendly; old default behavior)
   --md         Markdown tables (human + agent on-screen)
-  --verbose    also print MCP request details to stderr (orthogonal to above)
+  --verbose    also print core/MCP request details to stderr (orthogonal to above)
 
 OUTPUT TRUNCATION & DUMP  (orthogonal — apply to any sub-command)
 
@@ -87,8 +88,11 @@ OUTPUT TRUNCATION & DUMP  (orthogonal — apply to any sub-command)
 
 SETUP
 
-  tyc init --authorization <KEY>                        default https://mcp.tianyancha.com/v1
-  tyc init --url <MCP_URL> --authorization <KEY>        local / self-hosted
+  tyc login                                             OAuth browser login
+  tyc login --url <MCP_URL>                             OAuth for local / pre / self-hosted
+  tyc init --authorization <KEY>                        API-key compatibility path (default transport: core)
+  tyc init --transport mcp --authorization <KEY>        legacy MCP session transport
+  tyc init --url <MCP_URL> --authorization <KEY>        local / self-hosted service
 
 Every tool returns tyc OpenAPI native English keys verbatim. The MCP Server
 handles multi-source merge, Asia/Shanghai timestamp formatting, _summary
@@ -120,7 +124,7 @@ const program = new Command()
     .option("--pretty", "缩进 JSON 输出（默认行为，flag 保留以保持向后兼容）")
     .option("--md", "Markdown 表格化输出（适合人类阅读 / Agent 上屏）")
     .option("--compact", "紧凑单行 JSON（管道 / jq 场景；为旧默认行为）")
-    .option("--verbose", "打印 MCP 请求详情到 stderr")
+    .option("--verbose", "打印 core/MCP 请求详情到 stderr")
     .option("--head [n]", "仅输出前 N 行（不传值默认 50；与 --tail 同时给则同时输出两端）")
     .option("--tail [m]", "仅输出后 M 行（不传值默认 20；与 --head 同时给则同时输出两端）")
     .option("--full", "强制输出完整内容（最高优先级，覆盖 --head/--tail/--threshold）")
@@ -128,6 +132,7 @@ const program = new Command()
     .option("--threshold <bytes>", "字节截断主开关：超过该字节数则从头按字节截断；不传则永不截断")
     .addHelpText("after", helpText);
 registerInitCommand(program);
+registerLoginCommand(program);
 registerLayerCommands(program);
 registerCategoryCommands(program);
 program.parseAsync(process.argv).catch((err) => {

package/dist/logo.js

@@ -0,0 +1,24 @@
+export const TY_LOGO = `\x1b[38;2;22;135;245m           ▄▄▄████████▄▄▄
+       ▄▄█████████▀▀▀▀▀▀▀▀▀
+     ▄████████▀▀▄▄▄▄██████▄▄▄▄
+   ▄████████████████████████████▄
+  ▄███████████████████▀▀▀▀▀▀▀████▄
+ ▄██████████████▀▀             ███
+ ████████████▀▀ ▄▄▀             █▀
+███████████▀ ▄▄██▀
+█████████▀ ▄█████                  ▄
+███████▀ ▄██████▀                 ▄█
+██████▀ ▄███████  █             ▄███
+ ████  █████████  █▄ ▄▄▄▄▄▄▄▄▄█████
+ ▀██  ██████████  ██▄ ▀▀██████████▀
+  ▀  ███████████▄ ████▄   ▀▀▀▀▀▀▀▀
+    █████████████  ██████▄▄▄
+     ▀███████████▄ ▀██████████▀
+       ▀▀█████████▄ ▀██████▀▀
+           ▀▀▀██████  ▀▀▀\x1b[0m`;
+export const LOGIN_SUCCESS_BANNER = `登录成功
+${TY_LOGO}
+公平看清世界`;
+export function printLoginSuccessBanner() {
+    console.log(LOGIN_SUCCESS_BANNER);
+}