tyc-cli 0.3.4 → 0.3.6

package/dist/commands/capabilities.js

@@ -0,0 +1,32 @@
+import { callCoreToolWithOAuthRefresh } from "./coreCall.js";
+import { emitToolResult } from "./output.js";
+const TOOL_NAME = "get_company_capabilities";
+export function registerCompanyCapabilitiesCommand(companyCmd, program) {
+    companyCmd
+        .command("capabilities")
+        .description("[DISCOVER] 输入 search_companies 候选表 company_id，返回该企业可直接执行的 tyc CLI 工具清单")
+        .argument("<company_id>", "search_companies 候选表 items[*].id 中的数字企业 ID")
+        .option("--company-name <value>", "企业名称（可选，仅用于展示和后续主体参数示例）")
+        .action(async (companyID, options) => {
+        const args = {
+            company_id: companyID,
+        };
+        if (options.companyName !== undefined) {
+            args.company_name = options.companyName;
+        }
+        const opts = program.opts();
+        const verbose = !!opts.verbose;
+        try {
+            const result = await callCoreToolWithOAuthRefresh(TOOL_NAME, args, {
+                verbose,
+                format: "markdown",
+            });
+            emitToolResult(result, opts, TOOL_NAME);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.error(`请求失败: ${msg}`);
+            process.exit(1);
+        }
+    });
+}

package/dist/commands/category.js

@@ -1,8 +1,10 @@
 import { getCategories, getToolsByGroup } from "../registry.js";
-import { resolveConfig } from "../config.js";
-import { callTool } from "../mcpClient.js";
-import { jsonToMarkdown } from "../utils/jsonToMarkdown.js";
-import { applyTruncation, resolveOptionalInt, TRUNCATE_DEFAULTS, } from "../utils/truncate.js";
+import { registerCompanyCapabilitiesCommand } from "./capabilities.js";
+import { callCoreToolWithOAuthRefresh } from "./coreCall.js";
+import { emitToolResult } from "./output.js";
+const GLOBAL_OUTPUT_HELP = `
+全局输出选项：所有工具命令均支持 --md / --compact / --pretty / --head / --tail / --full / --threshold / --output-file / --verbose；完整说明见 tyc --help。
+`;
 export function registerCategoryCommands(program) {
     for (const cat of getCategories()) {
         const tools = getToolsByGroup(cat.group);
@@ -10,6 +12,9 @@ export function registerCategoryCommands(program) {
         const catCmd = program
             .command(cat.group)
             .description(`${cat.name_zh}（${cat.tool_count} 个 · L0=${layerCounts.L0} L1=${layerCounts.L1} L2=${layerCounts.L2} L3=${layerCounts.L3}）`);
+        if (cat.group === "company") {
+            registerCompanyCapabilitiesCommand(catCmd, program);
+        }
         for (const tool of tools) {
             bindMethod(catCmd, tool, program);
         }
@@ -36,11 +41,12 @@ function bindMethod(catCmd, tool, program) {
         methodCmd = methodCmd.argument(`<${positional.name}>`, positional.description);
     }
     for (const p of remainingRequired) {
-        methodCmd = methodCmd.requiredOption(`--${p.name} <value>`, p.description);
+        methodCmd = methodCmd.requiredOption(`--${p.name} <value>`, `必填；${p.description}`);
     }
     for (const p of optionalParams) {
         methodCmd = methodCmd.option(`--${p.name} <value>`, p.description);
     }
+    methodCmd.addHelpText("after", GLOBAL_OUTPUT_HELP);
     methodCmd.action(async (posVal, options) => {
         const args = {};
         if (positional && posVal)
@@ -49,12 +55,11 @@ function bindMethod(catCmd, tool, program) {
             if (options[p.name] !== undefined)
                 args[p.name] = options[p.name];
         }
-        const cfg = resolveConfig();
         const opts = program.opts();
         const verbose = !!opts.verbose;
         try {
-            const result = await callTool(cfg, tool.name, args, { verbose });
-            emit(result, opts, tool.name);
+            const result = await callToolWithOAuthRefresh(tool.name, args, verbose);
+            emitToolResult(result, opts, tool.name);
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
@@ -63,68 +68,6 @@ function bindMethod(catCmd, tool, program) {
         }
     });
 }
-function emit(result, opts, toolName) {
-    // MCP 业务错误：isError + content[0].text = 错误描述
-    if (result.isError) {
-        const errText = extractText(result) || "未知业务错误";
-        console.error(errText);
-        process.exit(1);
-    }
-    const text = extractText(result);
-    if (text === null) {
-        console.error("tools/call 返回无可解析内容");
-        process.exit(1);
-    }
-    // MCP Server 返回的是 JSON 字符串（已完成多源合并 / 时间戳格式化 /
-    // _summary / _empty / _warnings 注入）。CLI 只做呈现格式化。
-    let payload;
-    try {
-        payload = JSON.parse(text);
-    }
-    catch {
-        // 非 JSON 文本：直接原样输出（仍走截断 / 落盘）
-        emitWithTruncation(text.endsWith("\n") ? text.slice(0, -1) : text, opts);
-        return;
-    }
-    // 输出模式选择（互斥优先级 --md > --compact > --pretty / 默认 = pretty）
-    let rendered;
-    if (opts.md) {
-        rendered = jsonToMarkdown(payload, toolName);
-    }
-    else if (opts.compact) {
-        rendered = JSON.stringify(payload);
-    }
-    else {
-        // 默认 = pretty（含 --pretty 显式情况）
-        rendered = JSON.stringify(payload, null, 2);
-    }
-    emitWithTruncation(rendered, opts);
-}
-function emitWithTruncation(rendered, opts) {
-    // 解析 head / tail / threshold：commander 对 `[n]` 在未传值时给 true
-    const head = resolveOptionalInt(opts.head, TRUNCATE_DEFAULTS.HEAD);
-    const tail = resolveOptionalInt(opts.tail, TRUNCATE_DEFAULTS.TAIL);
-    const threshold = resolveOptionalInt(opts.threshold, TRUNCATE_DEFAULTS.THRESHOLD);
-    const outputFile = typeof opts.outputFile === "string" && opts.outputFile.length > 0
-        ? opts.outputFile
-        : undefined;
-    const r = applyTruncation(rendered, {
-        full: !!opts.full,
-        head,
-        tail,
-        threshold,
-        outputFile,
-    });
-    console.log(r.rendered);
-    for (const n of r.notices) {
-        process.stderr.write(n + "\n");
-    }
-}
-function extractText(result) {
-    const content = result.content || [];
-    for (const c of content) {
-        if (typeof c.text === "string" && c.text.length > 0)
-            return c.text;
-    }
-    return null;
+async function callToolWithOAuthRefresh(name, args, verbose) {
+    return callCoreToolWithOAuthRefresh(name, args, { verbose });
 }

package/dist/commands/coreCall.js

@@ -0,0 +1,23 @@
+import { refreshResolvedConfigOAuth, resolveConfigWithFreshOAuth, } from "../config.js";
+import { callCoreTool } from "../coreClient.js";
+function isUnauthorizedError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return /\bHTTP 401\b/i.test(msg) || /invalid_token|expired_token|token expired/i.test(msg);
+}
+export async function callCoreToolWithOAuthRefresh(name, args, opts) {
+    let refreshResult = await resolveConfigWithFreshOAuth({ verbose: !!opts?.verbose });
+    try {
+        return await callCoreTool(refreshResult.config, name, args, opts);
+    }
+    catch (err) {
+        if (!isUnauthorizedError(err))
+            throw err;
+        refreshResult = await refreshResolvedConfigOAuth(refreshResult.config, {
+            force: true,
+            verbose: !!opts?.verbose,
+        });
+        if (!refreshResult.refreshed)
+            throw err;
+        return callCoreTool(refreshResult.config, name, args, opts);
+    }
+}

package/dist/commands/init.js

@@ -1,25 +1,36 @@
-import { DEFAULT_MCP_URL, loadConfig, resolveConfig, saveConfig } from "../config.js";
-import { clearSession } from "../session.js";
-import { ensureSession } from "../mcpClient.js";
+import { DEFAULT_MCP_URL, defaultCoreURL, loadConfig, resolveConfig, saveConfig, } from "../config.js";
+import { verifyCoreEndpoint } from "../coreClient.js";
 export function registerInitCommand(program) {
     program
         .command("init")
-        .description("配置 MCP endpoint / Authorization（保存到 ~/.tyc/config.json，并校验连通性）")
+        .description("配置 endpoint / Authorization（保存到 ~/.tyc/config.json，并校验 shared core 连通性）")
         .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("--header <kv...>", "自定义 header，格式 K=V，可重复；留空清除该 key")
-        .option("--clear-session", "仅清除本地 MCP session 缓存（~/.tyc/session.json）")
-        .option("--no-verify", "跳过连通性校验（不发 initialize）")
+        .option("--no-verify", "跳过 shared core 连通性校验")
         .action(async (opts) => {
         const cfg = loadConfig() || {};
         if (!cfg.headers)
             cfg.headers = {};
-        if (opts.url)
+        let resetOAuth = false;
+        if (opts.url) {
             cfg.url = opts.url;
+            resetOAuth = true;
+        }
         if (!cfg.url)
             cfg.url = DEFAULT_MCP_URL;
-        if (opts.authorization)
+        delete cfg.transport;
+        if (opts.coreUrl) {
+            cfg.coreUrl = opts.coreUrl;
+        }
+        else if (opts.url || !cfg.coreUrl) {
+            cfg.coreUrl = defaultCoreURL(cfg.url);
+        }
+        if (opts.authorization) {
             cfg.headers.Authorization = opts.authorization;
+            resetOAuth = true;
+        }
         if (opts.header && opts.header.length > 0) {
             for (const kv of opts.header) {
                 const idx = kv.indexOf("=");
@@ -31,32 +42,30 @@ export function registerInitCommand(program) {
                 const v = kv.slice(idx + 1);
                 if (!k)
                     continue;
+                if (k.toLowerCase() === "authorization")
+                    resetOAuth = true;
                 if (v === "")
                     delete cfg.headers[k];
                 else
                     cfg.headers[k] = v;
             }
         }
+        if (resetOAuth)
+            delete cfg.oauth;
         saveConfig(cfg);
-        // 任何配置变更都清掉 session 缓存，避免 endpoint/鉴权切换后复用旧 sessionId
-        clearSession();
-        if (opts.clearSession) {
-            console.log("已清除 ~/.tyc/session.json");
-        }
-        console.log(`已保存 ~/.tyc/config.json  (url=${cfg.url})`);
+        console.log(`已保存 ~/.tyc/config.json  (url=${cfg.url}, coreUrl=${cfg.coreUrl})`);
         if (opts.verify === false) {
             return;
         }
-        // 立即发 initialize，拿到 Mcp-Session-Id 落盘；失败则非 0 退出
         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)}…）`);
+            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/layers.js

@@ -82,7 +82,7 @@ function registerLayerCmd(program, spec) {
     const layer = spec.layer;
     const cmd = program
         .command(layer)
-        .description(`${spec.title}（${getLayerCount(layer)} 个）— ${spec.summary}`);
+        .description(layerCommandDescription(spec));
     cmd
         .command("list")
         .description(`列出 ${layer} 全部 ${getLayerCount(layer)} 个工具（默认按分类分组文本表格）`)
@@ -120,6 +120,18 @@ function registerLayerCmd(program, spec) {
         console.log(renderLayerListText(spec, tools));
     });
 }
+function layerCommandDescription(spec) {
+    switch (spec.layer) {
+        case "L0":
+            return `实体锚定层（${getLayerCount("L0")} 个）— 把简称、曾用名或模糊指代解析成精确企业。`;
+        case "L1":
+            return `概要总览层（${getLayerCount("L1")} 个）— 每个业务面 1 个总览工具，用 _summary 指引下一跳。`;
+        case "L2":
+            return `维度下钻层（${getLayerCount("L2")} 个）— 股权、诉讼、招投标、年报、知识产权等明细维度。`;
+        case "L3":
+            return `专项工具层（${getLayerCount("L3")} 个）— id 详情、search_*、垂直场景和专业查询。`;
+    }
+}
 // ─────────────────────────── 渲染：tyc layers ───────────────────────────
 function renderLayersText() {
     const total = getTotalCount();

package/dist/commands/login.js

@@ -0,0 +1,290 @@
+import { DEFAULT_MCP_URL, applyOAuthTokenToConfig, defaultCoreURL, loadConfig, resolveConfig, saveConfig, } from "../config.js";
+import { verifyCoreAuthEndpoint } from "../coreClient.js";
+import { buildAuthorizationURL, createPKCE, discoverAuthorizationServer, discoverProtectedResourceMetadata, exchangeAuthorizationCode, knownOAuthDefaultsForMcpURL, openBrowser, parseAuthorizationCallbackCode, randomState, registerDynamicOAuthClient, startCallbackServer, } from "../oauth.js";
+import { clearPendingOAuthLogin, loadPendingOAuthLogin, savePendingOAuthLogin, } from "../oauthPending.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 normalizeCallbackPath(raw) {
+    const path = raw || "/oauth/callback";
+    return path.startsWith("/") ? path : `/${path}`;
+}
+function buildLoopbackRedirectUri(host, port, path) {
+    if (port === 0) {
+        throw new Error("--no-block 不能与 --redirect-port 0 同时使用，请指定固定回调端口。");
+    }
+    return `http://${host}:${port}${path}`;
+}
+function pickCallbackToken(opts) {
+    if (opts.callbackToken && opts.token) {
+        throw new Error("--callback-token 和 --token 只能指定一个。");
+    }
+    return opts.callbackToken || opts.token;
+}
+function saveOAuthTokenConfig(mcpURL, token, oauth, verbose) {
+    const cfg = loadConfig() || {};
+    cfg.url = mcpURL;
+    delete cfg.transport;
+    cfg.coreUrl = defaultCoreURL(mcpURL);
+    applyOAuthTokenToConfig(cfg, token, oauth);
+    saveConfig(cfg);
+    if (verbose) {
+        console.error(`> OAuth login state saved to ~/.tyc/config.json (url=${cfg.url})`);
+    }
+}
+async function verifySavedOAuthLogin(verify, verbose) {
+    if (!verify) {
+        printLoginSuccessBanner();
+        return;
+    }
+    const resolved = resolveConfig();
+    await verifyCoreAuthEndpoint(resolved, verbose);
+    if (verbose) {
+        console.error("> Shared Core auth check passed");
+    }
+    printLoginSuccessBanner();
+}
+async function completePendingOAuthLogin(pending, callbackToken, verify, verbose) {
+    const code = parseAuthorizationCallbackCode(callbackToken, pending.state);
+    if (verbose) {
+        console.error("> authorization code provided; exchanging access token");
+    }
+    const token = await exchangeAuthorizationCode({
+        tokenEndpoint: pending.tokenEndpoint,
+        clientId: pending.clientId,
+        clientSecret: pending.clientSecret,
+        code,
+        redirectUri: pending.redirectUri,
+        codeVerifier: pending.codeVerifier,
+        resource: pending.resource,
+    });
+    saveOAuthTokenConfig(pending.mcpURL, token, {
+        tokenEndpoint: pending.tokenEndpoint,
+        clientId: pending.clientId,
+        clientSecret: pending.clientSecret,
+        resource: pending.resource,
+    }, verbose);
+    clearPendingOAuthLogin(verbose);
+    await verifySavedOAuthLogin(verify, verbose);
+}
+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("--callback-token <code-or-url>", "继续非阻塞登录：传入授权回调 code 或包含 code 的完整 callback URL")
+        .option("--token <code-or-url>", "同 --callback-token（兼容别名；仍需传授权回调 code）")
+        .option("--no-open", "不自动打开浏览器，只打印授权 URL")
+        .option("--no-block", "配合 --no-open：打印授权 URL 并保存 pending 状态后立即退出")
+        .option("--no-verify", "保存 token 后跳过 shared core 鉴权校验")
+        .action(async (opts) => {
+        const verbose = !!program.opts().verbose;
+        const callbackToken = pickCallbackToken(opts);
+        if (callbackToken) {
+            const pending = loadPendingOAuthLogin();
+            if (!pending) {
+                throw new Error("未找到待完成的 OAuth 登录状态。请先运行 tyc login --no-open --no-block。");
+            }
+            if (verbose) {
+                console.error(`> loaded pending OAuth login from ~/.tyc/oauth_pending.json (url=${pending.mcpURL})`);
+            }
+            await completePendingOAuthLogin(pending, callbackToken, opts.verify !== false && pending.verify !== false, verbose);
+            return;
+        }
+        const noBlock = opts.block === false;
+        if (noBlock && opts.open !== false) {
+            throw new Error("--no-block 需要与 --no-open 一起使用。");
+        }
+        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 = normalizeCallbackPath(opts.callbackPath);
+        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();
+        let callback;
+        const redirectUri = noBlock
+            ? buildLoopbackRedirectUri(redirectHost, redirectPort, callbackPath)
+            : (callback = await startCallbackServer({
+                host: redirectHost,
+                port: redirectPort,
+                path: callbackPath,
+                state,
+                timeoutMs: 5 * 60 * 1000,
+            })).redirectUri;
+        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: [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,
+            scope,
+            state,
+            codeChallenge: pkce.codeChallenge,
+            resource,
+        });
+        if (verbose) {
+            console.error(`> OAuth callback: ${redirectUri}`);
+        }
+        if (noBlock) {
+            savePendingOAuthLogin({
+                version: 1,
+                createdAt: Date.now(),
+                mcpURL,
+                tokenEndpoint: endpoints.tokenEndpoint,
+                clientId,
+                clientSecret,
+                redirectUri,
+                codeVerifier: pkce.codeVerifier,
+                resource,
+                state,
+                verify: opts.verify !== false,
+            });
+            console.error("请在浏览器打开以下 URL 完成登录：");
+            console.error(authorizationURL);
+            console.error("");
+            console.error("完成授权后，复制回调 URL 中的 code 参数，然后运行：");
+            console.error("tyc login --callback-token <code_or_callback_url>");
+            console.error("也可以传完整 callback URL：tyc login --callback-token \"http://localhost:7078/oauth/callback?code=...&state=...\"");
+            return;
+        }
+        if (opts.open === false) {
+            console.error("请在浏览器打开以下 URL 完成登录：");
+            console.error(authorizationURL);
+        }
+        else {
+            console.error("正在打开浏览器完成 OAuth 登录...");
+            openBrowser(authorizationURL);
+        }
+        if (!callback) {
+            throw new Error("OAuth callback server not initialized");
+        }
+        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,
+            codeVerifier: pkce.codeVerifier,
+            resource,
+        });
+        saveOAuthTokenConfig(mcpURL, token, {
+            tokenEndpoint: endpoints.tokenEndpoint,
+            clientId,
+            clientSecret,
+            resource,
+        }, verbose);
+        clearPendingOAuthLogin(verbose);
+        await verifySavedOAuthLogin(opts.verify !== false, verbose);
+    });
+}

package/dist/commands/output.js

@@ -0,0 +1,60 @@
+import { jsonToMarkdown } from "../utils/jsonToMarkdown.js";
+import { applyTruncation, resolveOptionalInt, TRUNCATE_DEFAULTS, } from "../utils/truncate.js";
+export function emitToolResult(result, opts, toolName) {
+    if (result.isError) {
+        const errText = extractText(result) || "未知业务错误";
+        console.error(errText);
+        process.exit(1);
+    }
+    const text = extractText(result);
+    if (text === null) {
+        console.error("tools/call 返回无可解析内容");
+        process.exit(1);
+    }
+    let payload;
+    try {
+        payload = JSON.parse(text);
+    }
+    catch {
+        emitWithTruncation(text.endsWith("\n") ? text.slice(0, -1) : text, opts);
+        return;
+    }
+    let rendered;
+    if (opts.md) {
+        rendered = jsonToMarkdown(payload, toolName);
+    }
+    else if (opts.compact) {
+        rendered = JSON.stringify(payload);
+    }
+    else {
+        rendered = JSON.stringify(payload, null, 2);
+    }
+    emitWithTruncation(rendered, opts);
+}
+function emitWithTruncation(rendered, opts) {
+    const head = resolveOptionalInt(opts.head, TRUNCATE_DEFAULTS.HEAD);
+    const tail = resolveOptionalInt(opts.tail, TRUNCATE_DEFAULTS.TAIL);
+    const threshold = resolveOptionalInt(opts.threshold, TRUNCATE_DEFAULTS.THRESHOLD);
+    const outputFile = typeof opts.outputFile === "string" && opts.outputFile.length > 0
+        ? opts.outputFile
+        : undefined;
+    const r = applyTruncation(rendered, {
+        full: !!opts.full,
+        head,
+        tail,
+        threshold,
+        outputFile,
+    });
+    console.log(r.rendered);
+    for (const n of r.notices) {
+        process.stderr.write(n + "\n");
+    }
+}
+function extractText(result) {
+    const content = result.content || [];
+    for (const c of content) {
+        if (typeof c.text === "string" && c.text.length > 0)
+            return c.text;
+    }
+    return null;
+}