feiguazhitou-mcp-cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,952 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import process from "node:process";
+import { describeDocument, describeMarkdown } from "./agent-guide.js";
+import { CliError, errorDocument } from "./cli-error.js";
+import { APP_NAME, COMMAND_NAME, DEFAULT_TIMEOUT_MS, ENV, GENERATED_FAILURE_EXIT_POLICY_VERSION, INTERNAL_STORAGE_PROFILE, LAUNCHER_VERSION, MAX_TIMEOUT_MS, } from "./constants.js";
+import { outputLanguage, t } from "./i18n.js";
+import { discoverWithMcporter, mcporterDetails } from "./mcporter.js";
+import { createHeaderBindings, profilePaths, removeProfileCredentialHeader, removeProfileHeaderEnvironment, resolveProfile, setProfileCredentialHeader, setProfileEndpoint, setProfileHeaderEnvironment, setProfileTimeout, setProfileTokenEnvironment, } from "./profile.js";
+import { currentArtifact, refreshProfile } from "./refresh.js";
+import { listBundledSkills, showBundledSkill, skillProtocolDocument } from "./skills.js";
+import { TOOL_CATALOG_PROTOCOL, TOOL_CATALOG_PROTOCOL_VERSION, catalogFreshness, findTool, toolCatalog, toolCatalogText, toolInvocationTemplate, toolMarkdown, } from "./tool-catalog.js";
+const launcherCommands = new Set(["init", "refresh", "doctor", "config", "skills", "describe", "tools", "run", "help"]);
+function usage() {
+    if (outputLanguage() === "zh") {
+        return `${APP_NAME} ${LAUNCHER_VERSION}
+
+用法：
+  ${COMMAND_NAME} help
+  ${COMMAND_NAME} init [--endpoint URL]
+  ${COMMAND_NAME} refresh [--force] [--output json|text]
+  ${COMMAND_NAME} doctor [--output json|text]
+  ${COMMAND_NAME} config
+  ${COMMAND_NAME} config set endpoint URL
+  ${COMMAND_NAME} config set header HEADER --value-stdin
+  ${COMMAND_NAME} config unset header HEADER
+  ${COMMAND_NAME} config set header-env HEADER ENV_VAR
+  ${COMMAND_NAME} config unset header-env HEADER
+  ${COMMAND_NAME} config set token-env ENV_VAR
+  ${COMMAND_NAME} config set timeout MILLISECONDS
+  ${COMMAND_NAME} skills protocol
+  ${COMMAND_NAME} skills list [--output json]
+  ${COMMAND_NAME} skills show NAME [--output json|markdown]
+  ${COMMAND_NAME} describe [--output json|markdown]
+  ${COMMAND_NAME} tools list [--refresh] [--force] [--output json|text]
+  ${COMMAND_NAME} tools show NAME [--refresh] [--force] [--output json|markdown]
+  ${COMMAND_NAME} run COMMAND [...generated-command-args]
+
+运行时配置：
+  ${ENV.endpoint}         Streamable HTTP endpoint 覆盖值
+  ${ENV.apiKey}           api_key Header 的当前进程值
+  ${ENV.token}            Bearer Token 的当前进程值
+  ${ENV.headers}          自定义请求 Header 的当前进程 JSON 对象
+  ${ENV.autoApprove}      标记为自动批准的 MCP 工具或生成 command 的 JSON 数组
+  ${ENV.timeout}          MCP 超时毫秒数（默认：${DEFAULT_TIMEOUT_MS}；范围：1-${MAX_TIMEOUT_MS}）
+  ${ENV.dataDirectory}    覆盖跨平台用户数据目录
+  ${ENV.language}         设为 en 时输出英文（默认：中文）
+
+调用约束：
+  Agent、脚本和其他调用方不得直接连接本机 MCP endpoint；所有工具调用必须使用
+  ${COMMAND_NAME} run COMMAND ...。CLI 仅在内部连接 MCP。
+  飞瓜本机 MCP 按单会话使用：不要并发执行 run、refresh 或 doctor；必须等上一条
+  会连接 MCP 的命令完全结束后，再执行下一条。CLI 不会自动排队。
+
+Agent 发现：
+  1. ${COMMAND_NAME} describe --output json
+  2. ${COMMAND_NAME} tools list --output json
+  3. ${COMMAND_NAME} refresh --output json（仅在目录缺失或需要最新 schema 时）
+  4. ${COMMAND_NAME} tools show NAME --output json
+  5. ${COMMAND_NAME} skills show feiguazhitou-mcp-cli
+
+规范的 tools list/show/run 命令只读取本地生成状态，除非显式传入 --refresh
+或执行 refresh。动态生成的 command 名位于目录中，不是启动器顶层命令。
+
+默认超时为 ${DEFAULT_TIMEOUT_MS}ms；需要其他等待上限时，可使用 config set timeout MILLISECONDS，新值会在下一次 run 中生效。
+
+使用 "${COMMAND_NAME} run COMMAND --help" 查看生成 command 的帮助。
+`;
+    }
+    return `${APP_NAME} ${LAUNCHER_VERSION}
+
+Usage:
+  ${COMMAND_NAME} help
+  ${COMMAND_NAME} init [--endpoint URL]
+  ${COMMAND_NAME} refresh [--force] [--output json|text]
+  ${COMMAND_NAME} doctor [--output json|text]
+  ${COMMAND_NAME} config
+  ${COMMAND_NAME} config set endpoint URL
+  ${COMMAND_NAME} config set header HEADER --value-stdin
+  ${COMMAND_NAME} config unset header HEADER
+  ${COMMAND_NAME} config set header-env HEADER ENV_VAR
+  ${COMMAND_NAME} config unset header-env HEADER
+  ${COMMAND_NAME} config set token-env ENV_VAR
+  ${COMMAND_NAME} config set timeout MILLISECONDS
+  ${COMMAND_NAME} skills protocol
+  ${COMMAND_NAME} skills list [--output json]
+  ${COMMAND_NAME} skills show NAME [--output json|markdown]
+  ${COMMAND_NAME} describe [--output json|markdown]
+  ${COMMAND_NAME} tools list [--refresh] [--force] [--output json|text]
+  ${COMMAND_NAME} tools show NAME [--refresh] [--force] [--output json|markdown]
+  ${COMMAND_NAME} run COMMAND [...generated-command-args]
+
+Runtime configuration:
+  ${ENV.endpoint}         Streamable HTTP endpoint override
+  ${ENV.apiKey}           api_key header value for the current process
+  ${ENV.token}            Bearer token value for the current process
+  ${ENV.headers}          JSON object of custom request headers for the current process
+  ${ENV.autoApprove}      JSON array of MCP tool or generated command names marked auto-approved
+  ${ENV.timeout}          MCP timeout in milliseconds (default: ${DEFAULT_TIMEOUT_MS}; range: 1-${MAX_TIMEOUT_MS})
+  ${ENV.dataDirectory}    Override the cross-platform user data directory
+  ${ENV.language}         Set to en for English output (default: Chinese)
+
+Transport boundary:
+  Agents, scripts, and other callers must not connect to the local MCP endpoint directly;
+  every tool call must use ${COMMAND_NAME} run COMMAND .... The CLI connects to MCP internally.
+  Use the local Feiguazhitou MCP as a single session: do not run run, refresh, or doctor
+  concurrently. Wait for each MCP-connecting command to finish before starting the next one.
+  The CLI does not queue concurrent calls automatically.
+
+Agent discovery:
+  1. ${COMMAND_NAME} describe --output json
+  2. ${COMMAND_NAME} tools list --output json
+  3. ${COMMAND_NAME} refresh --output json (only when the catalog is missing or freshness is required)
+  4. ${COMMAND_NAME} tools show NAME --output json
+  5. ${COMMAND_NAME} skills show feiguazhitou-mcp-cli
+
+Canonical tools list/show/run commands only read local generated state unless --refresh
+or refresh is requested explicitly. Dynamic generated command names are catalog entries,
+not launcher commands.
+
+The default timeout is ${DEFAULT_TIMEOUT_MS}ms. To use a different limit, run config set timeout MILLISECONDS; it takes effect on the next run.
+
+Use "${COMMAND_NAME} run COMMAND --help" for generated-command help.
+`;
+}
+function valueAfter(args, index, flag) {
+    const value = args[index + 1];
+    if (!value || value.startsWith("--")) {
+        throw new Error(t(`${flag} 需要一个值。`, `${flag} requires a value.`));
+    }
+    return value;
+}
+function parseGlobalOptions(args) {
+    const rest = [];
+    let dataDirectory;
+    let endpoint;
+    let force = false;
+    let command;
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        const parseLauncherOption = command === undefined || (launcherCommands.has(command) && !(command === "run" && rest.length >= 2));
+        if (parseLauncherOption && (token === "--profile" || token.startsWith("--profile="))) {
+            throw new CliError("INVALID_ARGUMENT", t("--profile 不受支持；feiguazhitou-mcp-cli 只管理一个本地飞瓜智投 MCP 连接。", "--profile is not supported; feiguazhitou-mcp-cli manages one local MCP connection."));
+        }
+        if (parseLauncherOption && token === "--data-dir") {
+            dataDirectory = valueAfter(args, index, token);
+            index += 1;
+            continue;
+        }
+        if (parseLauncherOption && token.startsWith("--data-dir=")) {
+            dataDirectory = token.slice("--data-dir=".length);
+            continue;
+        }
+        if (parseLauncherOption && token === "--endpoint") {
+            endpoint = valueAfter(args, index, token);
+            index += 1;
+            continue;
+        }
+        if (parseLauncherOption && token.startsWith("--endpoint=")) {
+            endpoint = token.slice("--endpoint=".length);
+            continue;
+        }
+        if (parseLauncherOption && token === "--force") {
+            force = true;
+            continue;
+        }
+        rest.push(token);
+        if (command === undefined && !token.startsWith("-")) {
+            command = token;
+        }
+    }
+    return { dataDirectory, endpoint, force, rest };
+}
+function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+function rawInputUsage() {
+    return t(`复杂 JSON 输入：\n  ${COMMAND_NAME} run COMMAND --raw @INPUT.json --output json\n  cat INPUT.json | ${COMMAND_NAME} run COMMAND --raw - --output json\n`, `Complex JSON input:\n  ${COMMAND_NAME} run COMMAND --raw @INPUT.json --output json\n  cat INPUT.json | ${COMMAND_NAME} run COMMAND --raw - --output json\n`);
+}
+function rawInputError(message) {
+    return new CliError("INVALID_ARGUMENT", message, rawInputUsage().trim());
+}
+async function readRawStandardInput() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const value = Buffer.concat(chunks).toString("utf8").replace(/^\uFEFF/, "");
+    if (!value.trim()) {
+        throw rawInputError(t("--raw - 需要从标准输入提供非空 JSON。", "--raw - requires non-empty JSON on standard input."));
+    }
+    return value;
+}
+async function readRawFile(filePath) {
+    if (!filePath) {
+        throw rawInputError(t("--raw @FILE 需要一个文件路径。", "--raw @FILE requires a file path."));
+    }
+    try {
+        const value = (await readFile(filePath, "utf8")).replace(/^\uFEFF/, "");
+        if (!value.trim()) {
+            throw rawInputError(t(`--raw 文件 '${filePath}' 不包含 JSON。`, `The --raw file '${filePath}' does not contain JSON.`));
+        }
+        return value;
+    }
+    catch (error) {
+        if (error instanceof CliError) {
+            throw error;
+        }
+        const detail = error instanceof Error ? error.message : String(error);
+        throw rawInputError(t(`无法读取 --raw 文件 '${filePath}'：${detail}`, `Unable to read --raw file '${filePath}': ${detail}`));
+    }
+}
+async function resolveRawInput(value) {
+    if (value === "-") {
+        return await readRawStandardInput();
+    }
+    if (value.startsWith("@")) {
+        return await readRawFile(value.slice(1));
+    }
+    return value;
+}
+async function normalizeGeneratedRawInput(args) {
+    const normalized = [];
+    let hasRawInput = false;
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        let rawValue;
+        if (token === "--raw") {
+            rawValue = valueAfter(args, index, token);
+            index += 1;
+        }
+        else if (token.startsWith("--raw=")) {
+            rawValue = token.slice("--raw=".length);
+        }
+        if (rawValue === undefined) {
+            normalized.push(token);
+            continue;
+        }
+        if (hasRawInput) {
+            throw rawInputError(t("一次工具调用只能提供一个 --raw 输入。", "A tool invocation can provide only one --raw input."));
+        }
+        hasRawInput = true;
+        normalized.push("--raw", await resolveRawInput(rawValue));
+    }
+    return normalized;
+}
+async function runGeneratedCli(bundle, args, environment) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [bundle, ...args], {
+            env: { ...process.env, ...environment, FORCE_COLOR: "0", NO_COLOR: "1" },
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const stdout = [];
+        const stderr = [];
+        child.stdout.on("data", (chunk) => stdout.push(chunk));
+        child.stderr.on("data", (chunk) => stderr.push(chunk));
+        child.once("error", reject);
+        child.once("close", (code) => {
+            resolve({
+                code: code ?? 1,
+                stdout: Buffer.concat(stdout).toString("utf8"),
+                stderr: Buffer.concat(stderr).toString("utf8"),
+            });
+        });
+    });
+}
+function generatedCliFailureMessage(result) {
+    const message = result.stderr.trim();
+    if (message) {
+        return message;
+    }
+    return t(`生成的工具命令以退出码 ${result.code} 结束，且未输出错误信息。`, `Generated tool command exited with code ${result.code} without an error message.`);
+}
+function writeGeneratedCliResult(result, args) {
+    const hasOutput = result.stdout.trim().length > 0;
+    const jsonOutput = requestedJsonOutput(args);
+    if (hasOutput) {
+        process.stdout.write(result.stdout);
+    }
+    // A nonzero tool response can still be valid MCP JSON (for example ok:false).
+    // Preserve that output exactly; only synthesize an error document when nothing was returned.
+    if (result.code !== 0 && !hasOutput && jsonOutput) {
+        printJson(errorDocument(new CliError("COMMAND_FAILED", generatedCliFailureMessage(result), undefined, {
+            source: "generated-cli",
+            exitCode: result.code,
+            stderr: result.stderr,
+        })));
+        return result.code;
+    }
+    if (result.stderr) {
+        process.stderr.write(result.stderr);
+    }
+    return result.code;
+}
+function failureExitPolicyRemediation() {
+    return t(`执行 ${COMMAND_NAME} refresh --output json，生成包含当前失败退出码策略的本地 CLI。`, `Run ${COMMAND_NAME} refresh --output json to generate a local CLI with the current failure-exit policy.`);
+}
+function artifactCompatibility(manifest, currentTimeoutMs) {
+    if (!manifest) {
+        return {
+            status: "missing",
+            currentTimeoutMs,
+            artifactTimeoutMs: null,
+            remediation: t(`执行 ${COMMAND_NAME} refresh --output json 生成本地 CLI。`, `Run ${COMMAND_NAME} refresh --output json to generate a local CLI.`),
+        };
+    }
+    const failureExitPolicyMatches = manifest.failureExitPolicyVersion === GENERATED_FAILURE_EXIT_POLICY_VERSION;
+    if (!failureExitPolicyMatches) {
+        return {
+            status: "refresh-required",
+            currentTimeoutMs,
+            artifactTimeoutMs: manifest.timeoutMs,
+            failureExitPolicyVersion: manifest.failureExitPolicyVersion ?? null,
+            requiredFailureExitPolicyVersion: GENERATED_FAILURE_EXIT_POLICY_VERSION,
+            remediation: failureExitPolicyRemediation(),
+        };
+    }
+    return {
+        status: "ready",
+        currentTimeoutMs,
+        artifactTimeoutMs: manifest.timeoutMs,
+        runtimeTimeoutMs: currentTimeoutMs,
+        timeoutOverrideActive: manifest.timeoutMs !== currentTimeoutMs,
+        failureExitPolicyVersion: manifest.failureExitPolicyVersion,
+        requiredFailureExitPolicyVersion: GENERATED_FAILURE_EXIT_POLICY_VERSION,
+    };
+}
+async function resolveCurrentProfile(options) {
+    return await resolveProfile(INTERNAL_STORAGE_PROFILE, {
+        dataDirectory: options.dataDirectory,
+        endpoint: options.endpoint,
+    });
+}
+async function commandInit(options) {
+    const profile = await resolveCurrentProfile(options);
+    if (options.endpoint) {
+        await setProfileEndpoint(profile.paths, options.endpoint);
+    }
+    printJson({ endpoint: options.endpoint ?? profile.endpoint, dataDirectory: profile.paths.baseDirectory });
+}
+function configUsage() {
+    return t(`用法：
+  ${COMMAND_NAME} config
+  ${COMMAND_NAME} config set endpoint URL
+  ${COMMAND_NAME} config set header HEADER --value-stdin
+  ${COMMAND_NAME} config unset header HEADER
+  ${COMMAND_NAME} config set header-env HEADER ENV_VAR
+  ${COMMAND_NAME} config unset header-env HEADER
+  ${COMMAND_NAME} config set token-env ENV_VAR
+  ${COMMAND_NAME} config set timeout MILLISECONDS
+`, `Usage:
+  ${COMMAND_NAME} config
+  ${COMMAND_NAME} config set endpoint URL
+  ${COMMAND_NAME} config set header HEADER --value-stdin
+  ${COMMAND_NAME} config unset header HEADER
+  ${COMMAND_NAME} config set header-env HEADER ENV_VAR
+  ${COMMAND_NAME} config unset header-env HEADER
+  ${COMMAND_NAME} config set token-env ENV_VAR
+  ${COMMAND_NAME} config set timeout MILLISECONDS
+`);
+}
+function configInputError(message) {
+    return new CliError("INVALID_ARGUMENT", message, configUsage().trim());
+}
+async function readConfigValueFromStandardInput() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    const value = Buffer.concat(chunks).toString("utf8");
+    if (value.length === 0) {
+        throw configInputError(t("--value-stdin 需要从标准输入提供 Header 值。", "--value-stdin requires a Header value from standard input."));
+    }
+    return value.replace(/\r?\n$/, "");
+}
+async function commandConfig(options) {
+    const args = options.rest.slice(1);
+    if (args.length === 0) {
+        const profile = await resolveCurrentProfile(options);
+        printJson({
+            endpoint: profile.endpoint,
+            timeoutMs: profile.timeoutMs,
+            configuredTimeoutMs: profile.config.timeoutMs ?? null,
+            configuredHeaders: Object.fromEntries(Object.entries(profile.config.headers ?? {}).map(([name, reference]) => [name, { env: reference.env, prefix: reference.prefix ?? "" }])),
+            storedCredentialHeaderNames: profile.storedCredentialHeaderNames,
+            autoApprove: profile.autoApprove,
+            tokenEnv: profile.config.tokenEnv ?? ENV.token,
+            dataDirectory: profile.paths.baseDirectory,
+        });
+        return;
+    }
+    if (args.length === 1 && args[0] === "--help") {
+        process.stdout.write(configUsage());
+        return;
+    }
+    const [verb, key, ...values] = args;
+    const paths = profilePaths(INTERNAL_STORAGE_PROFILE, options.dataDirectory);
+    if (verb === "set" && key === "endpoint" && values.length === 1) {
+        await setProfileEndpoint(paths, values[0]);
+        process.stderr.write(`${t("已保存 endpoint。", "Saved endpoint.")}\n`);
+        return;
+    }
+    if (verb === "set" && key === "header") {
+        const [header, source, ...extra] = values;
+        if (!header || source !== "--value-stdin" || extra.length > 0) {
+            throw configInputError(t(`用法：${COMMAND_NAME} config set header HEADER --value-stdin`, `Usage: ${COMMAND_NAME} config set header HEADER --value-stdin`));
+        }
+        const value = await readConfigValueFromStandardInput();
+        await setProfileCredentialHeader(paths, header, value);
+        const removedEnvironmentReference = await removeProfileHeaderEnvironment(paths, header);
+        process.stderr.write(`${t(`已将 ${header} 保存到本机未加密凭据文件。`, `Saved ${header} to the local unencrypted credential file.`)}\n`);
+        if (removedEnvironmentReference) {
+            process.stderr.write(`${t(`已移除 ${header} 原有的运行时 Header 引用。`, `Removed the existing runtime Header reference for ${header}.`)}\n`);
+        }
+        return;
+    }
+    if (verb === "unset" && key === "header" && values.length === 1) {
+        const removed = await removeProfileCredentialHeader(paths, values[0]);
+        process.stderr.write(`${removed
+            ? t(`已清除 ${values[0]} 的本机保存 Header 值。`, `Cleared the locally saved Header value for ${values[0]}.`)
+            : t(`${values[0]} 没有本机保存的 Header 值。`, `${values[0]} has no locally saved Header value.`)}\n`);
+        return;
+    }
+    if (verb === "set" && key === "header-env" && values.length === 2) {
+        const [header, env] = values;
+        await setProfileHeaderEnvironment(paths, header, env);
+        process.stderr.write(`${t(`已保存 ${header} 的运行时 Header 引用。`, `Saved runtime Header reference for ${header}.`)}\n`);
+        return;
+    }
+    if (verb === "unset" && key === "header-env" && values.length === 1) {
+        const removed = await removeProfileHeaderEnvironment(paths, values[0]);
+        process.stderr.write(`${removed
+            ? t(`已移除 ${values[0]} 的运行时 Header 引用。`, `Removed the runtime Header reference for ${values[0]}.`)
+            : t(`${values[0]} 没有运行时 Header 引用。`, `${values[0]} has no runtime Header reference.`)}\n`);
+        return;
+    }
+    if (verb === "set" && key === "token-env" && values.length === 1) {
+        await setProfileTokenEnvironment(paths, values[0]);
+        process.stderr.write(`${t("已保存 Token 环境变量引用。", "Saved token environment variable reference.")}\n`);
+        return;
+    }
+    if (verb === "set" && key === "timeout" && values.length === 1) {
+        const config = await setProfileTimeout(paths, values[0]);
+        process.stderr.write(`${t(`已保存超时值 ${config.timeoutMs}ms。`, `Saved timeout ${config.timeoutMs}ms.`)}\n`);
+        return;
+    }
+    throw configInputError(t("支持的 config 操作：endpoint、header、header-env、token-env、timeout。", "Supported config actions: endpoint, header, header-env, token-env, timeout."));
+}
+function doctorUsage() {
+    return t(`用法：${COMMAND_NAME} doctor [--output json|text]\n`, `Usage: ${COMMAND_NAME} doctor [--output json|text]\n`);
+}
+function parseDoctorOutput(args) {
+    let output = "json";
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        let value;
+        if (token === "--output") {
+            value = valueAfter(args, index, token);
+            index += 1;
+        }
+        else if (token.startsWith("--output=")) {
+            value = token.slice("--output=".length);
+        }
+        else {
+            throw new CliError("INVALID_ARGUMENT", t(`不支持的 doctor 选项 '${token}'。`, `Unsupported doctor option '${token}'.`), doctorUsage().trim());
+        }
+        if (value !== "json" && value !== "text") {
+            throw new CliError("INVALID_ARGUMENT", t("doctor 的 output 必须为 json 或 text。", "doctor output must be json or text."), doctorUsage().trim());
+        }
+        output = value;
+    }
+    return output;
+}
+function doctorText(report) {
+    const connection = report.connection.status === "ok"
+        ? t(`MCP 连接：正常（${report.connection.toolCount} 个工具）`, `MCP connection: ready (${report.connection.toolCount} tools)`)
+        : t(`MCP 连接：失败（${report.connection.error}）`, `MCP connection: failed (${report.connection.error})`);
+    const compatibility = String(report.artifactCompatibility.status ?? "unknown");
+    const artifact = compatibility === "ready"
+        ? t("生成 CLI：可执行", "Generated CLI: ready")
+        : compatibility === "missing"
+            ? t("生成 CLI：未生成；请执行 refresh", "Generated CLI: missing; run refresh")
+            : t("生成 CLI：需要 refresh", "Generated CLI: refresh required");
+    const catalog = report.catalogFreshness.isStale
+        ? t(`工具目录：已超过 7 天未检查（上次：${report.catalogFreshness.lastCheckedAt ?? "未知"}）；执行 tools list --refresh 可检查最新 schema。`, `Tool catalog: not checked for over 7 days (last check: ${report.catalogFreshness.lastCheckedAt ?? "unknown"}); run tools list --refresh to check the latest schema.`)
+        : t(`工具目录：近期已检查（上次：${report.catalogFreshness.lastCheckedAt ?? "未知"}）`, `Tool catalog: checked recently (last check: ${report.catalogFreshness.lastCheckedAt ?? "unknown"})`);
+    return [
+        t("飞瓜智投 MCP CLI 诊断", "Feiguazhitou MCP CLI Doctor"),
+        t(`Endpoint：${report.endpoint}`, `Endpoint: ${report.endpoint}`),
+        connection,
+        artifact,
+        catalog,
+        t(`超时：${report.timeoutMs}ms。该值会在下一次 run 中立即生效；CLI 不会重试或改写第三方超时错误。`, `Timeout: ${report.timeoutMs}ms. This value takes effect on the next run; the CLI does not retry or rewrite third-party timeout errors.`),
+    ].join("\n") + "\n";
+}
+async function commandDoctor(options) {
+    const args = options.rest.slice(1);
+    if (args.includes("--help")) {
+        if (args.length !== 1) {
+            throw new CliError("INVALID_ARGUMENT", doctorUsage().trim());
+        }
+        process.stdout.write(doctorUsage());
+        return;
+    }
+    const output = parseDoctorOutput(args);
+    const profile = await resolveCurrentProfile(options);
+    const current = await currentArtifact(profile);
+    const { profile: _internalStorageProfile, ...state } = current.state;
+    let connection;
+    try {
+        const discovery = await discoverWithMcporter(profile, createHeaderBindings(profile.profile, profile.headers));
+        connection = {
+            status: "ok",
+            toolCount: discovery.tools.length,
+            server: discovery.server,
+        };
+    }
+    catch (error) {
+        connection = { status: "error", error: error instanceof Error ? error.message : String(error) };
+    }
+    const report = {
+        launcherVersion: LAUNCHER_VERSION,
+        node: process.version,
+        mcporter: mcporterDetails(),
+        endpoint: profile.endpoint,
+        timeoutMs: profile.timeoutMs,
+        configuredHeaderNames: Object.keys(profile.headers),
+        autoApprove: profile.autoApprove,
+        connection,
+        state,
+        catalogFreshness: catalogFreshness(current.state.lastCheckedAt),
+        artifactCompatibility: artifactCompatibility(current.manifest, profile.timeoutMs),
+        generated: current.manifest
+            ? {
+                artifactId: current.manifest.artifactId,
+                schemaHash: current.manifest.schemaHash,
+                timeoutMs: current.manifest.timeoutMs,
+                generatedAt: current.manifest.generatedAt,
+                server: current.manifest.server,
+            }
+            : null,
+    };
+    if (output === "json") {
+        printJson(report);
+        return;
+    }
+    process.stdout.write(doctorText(report));
+}
+function describeUsage() {
+    return t(`用法：${COMMAND_NAME} describe [--output json|markdown]\n`, `Usage: ${COMMAND_NAME} describe [--output json|markdown]\n`);
+}
+function toolsUsage() {
+    return t(`用法：
+  ${COMMAND_NAME} tools list [--refresh] [--force] [--output json|text]
+  ${COMMAND_NAME} tools show NAME [--refresh] [--force] [--output json|markdown]
+`, `Usage:
+  ${COMMAND_NAME} tools list [--refresh] [--force] [--output json|text]
+  ${COMMAND_NAME} tools show NAME [--refresh] [--force] [--output json|markdown]
+`);
+}
+function runUsage() {
+    return t(`用法：${COMMAND_NAME} run COMMAND [...generated-command-args]\n\n${rawInputUsage()}`, `Usage: ${COMMAND_NAME} run COMMAND [...generated-command-args]\n\n${rawInputUsage()}`);
+}
+function parseOutput(args, defaultOutput, command) {
+    let output = defaultOutput;
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        let value;
+        if (token === "--output") {
+            value = valueAfter(args, index, token);
+            index += 1;
+        }
+        else if (token.startsWith("--output=")) {
+            value = token.slice("--output=".length);
+        }
+        else {
+            throw new CliError("INVALID_ARGUMENT", t(`不支持的 ${command} 选项 '${token}'。`, `Unsupported ${command} option '${token}'.`));
+        }
+        if (value !== "json" && value !== "markdown") {
+            throw new CliError("INVALID_ARGUMENT", t(`${command} 的 output 必须为 json 或 markdown。`, `${command} output must be json or markdown.`));
+        }
+        output = value;
+    }
+    return output;
+}
+function parseToolsOptions(args) {
+    let refresh = false;
+    let output = "text";
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        if (token === "--refresh") {
+            refresh = true;
+            continue;
+        }
+        let value;
+        if (token === "--output") {
+            value = valueAfter(args, index, token);
+            index += 1;
+        }
+        else if (token.startsWith("--output=")) {
+            value = token.slice("--output=".length);
+        }
+        else {
+            throw new CliError("INVALID_ARGUMENT", t(`不支持的 tools 选项 '${token}'。`, `Unsupported tools option '${token}'.`));
+        }
+        if (value !== "json" && value !== "text") {
+            throw new CliError("INVALID_ARGUMENT", t("tools 的 output 必须为 json 或 text。", "tools output must be json or text."));
+        }
+        output = value;
+    }
+    return { refresh, output };
+}
+async function generatedToolCatalog(options, mode) {
+    const profile = await resolveCurrentProfile(options);
+    let artifact = await currentArtifact(profile);
+    if (mode === "refresh") {
+        try {
+            await refreshProfile(profile, options.force);
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            throw new CliError("DISCOVERY_FAILED", t(`工具发现失败：${detail}`, `Tool discovery failed: ${detail}`), t(`检查本地飞瓜智投客户端后，执行 ${COMMAND_NAME} refresh --output json。`, `Check the local Feiguazhitou client, then run ${COMMAND_NAME} refresh --output json.`));
+        }
+        artifact = await currentArtifact(profile);
+    }
+    if (!artifact.manifest) {
+        throw new CliError("ARTIFACT_MISSING", t("没有可用的生成工具目录。", "No generated tool catalog is available."), t(`执行 ${COMMAND_NAME} refresh --output json 后重试。`, `Run ${COMMAND_NAME} refresh --output json, then retry.`));
+    }
+    return { profile, artifact, catalog: toolCatalog(artifact.manifest, profile.timeoutMs, profile.autoApprove, artifact.state.lastCheckedAt) };
+}
+async function commandDescribe(options) {
+    const args = options.rest.slice(1);
+    if (args.includes("--help")) {
+        if (args.length !== 1) {
+            throw new CliError("INVALID_ARGUMENT", describeUsage().trim());
+        }
+        process.stdout.write(describeUsage());
+        return;
+    }
+    const output = parseOutput(args, "markdown", "describe");
+    if (output === "json") {
+        printJson(describeDocument());
+        return;
+    }
+    process.stdout.write(describeMarkdown());
+}
+function parseToolDetailOptions(args, command) {
+    let refresh = false;
+    const outputArgs = [];
+    for (const token of args) {
+        if (token === "--refresh") {
+            refresh = true;
+        }
+        else {
+            outputArgs.push(token);
+        }
+    }
+    return { refresh, output: parseOutput(outputArgs, "json", command) };
+}
+function writeToolDetail(catalog, name, output) {
+    const tool = findTool(catalog, name);
+    if (!tool) {
+        throw new CliError("TOOL_NOT_FOUND", t(`未知的生成工具 '${name}'。`, `Unknown generated tool '${name}'.`), t(`执行 ${COMMAND_NAME} tools list --output json，并选择其中一个 command 值。`, `Run ${COMMAND_NAME} tools list --output json and choose one of its command values.`));
+    }
+    if (output === "markdown") {
+        process.stdout.write(toolMarkdown(catalog, tool));
+        return;
+    }
+    printJson({
+        protocol: TOOL_CATALOG_PROTOCOL,
+        protocolVersion: TOOL_CATALOG_PROTOCOL_VERSION,
+        artifact: catalog.artifact,
+        tool,
+        invocationTemplate: toolInvocationTemplate(tool),
+        workflowSkill: "feiguazhitou-mcp-cli",
+    });
+}
+async function commandTools(options) {
+    const [action, ...args] = options.rest.slice(1);
+    if (action === "--help") {
+        process.stdout.write(toolsUsage());
+        return;
+    }
+    if (action === "list") {
+        if (args.includes("--help")) {
+            if (args.length !== 1) {
+                throw new CliError("INVALID_ARGUMENT", toolsUsage().trim());
+            }
+            process.stdout.write(toolsUsage());
+            return;
+        }
+        const parsed = parseToolsOptions(args);
+        const result = await generatedToolCatalog(options, parsed.refresh ? "refresh" : "cached");
+        if (parsed.output === "json") {
+            printJson(result.catalog);
+            return;
+        }
+        process.stdout.write(toolCatalogText(result.catalog));
+        return;
+    }
+    if (action === "show") {
+        const [name, ...flags] = args;
+        if (!name || name === "--help") {
+            if (name === "--help" && flags.length === 0) {
+                process.stdout.write(toolsUsage());
+                return;
+            }
+            throw new CliError("INVALID_ARGUMENT", toolsUsage().trim());
+        }
+        if (flags.includes("--help")) {
+            if (flags.length !== 1) {
+                throw new CliError("INVALID_ARGUMENT", toolsUsage().trim());
+            }
+            process.stdout.write(toolsUsage());
+            return;
+        }
+        const parsed = parseToolDetailOptions(flags, "tools show");
+        const result = await generatedToolCatalog(options, parsed.refresh ? "refresh" : "cached");
+        writeToolDetail(result.catalog, name, parsed.output);
+        return;
+    }
+    throw new CliError("INVALID_ARGUMENT", action ? t(`不支持的 tools 操作 '${action}'。`, `Unsupported tools action '${action}'.`) : t("tools 需要 list 或 show 操作。", "tools requires either the list or show action."), toolsUsage().trim());
+}
+function parseSkillsOutput(args, defaultOutput) {
+    let output = defaultOutput;
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        let value;
+        if (token === "--output") {
+            value = valueAfter(args, index, token);
+            index += 1;
+        }
+        else if (token.startsWith("--output=")) {
+            value = token.slice("--output=".length);
+        }
+        else {
+            throw new Error(t(`不支持的 skills 选项 '${token}'。`, `Unsupported skills option '${token}'.`));
+        }
+        if (value !== "json" && value !== "markdown") {
+            throw new Error(t("Skill 的 output 必须为 json 或 markdown。", "Skill output must be json or markdown."));
+        }
+        output = value;
+    }
+    return output;
+}
+async function commandSkills(options) {
+    const [action, ...args] = options.rest.slice(1);
+    if (action === "protocol") {
+        if (args.length > 0) {
+            throw new Error(t(`用法：${COMMAND_NAME} skills protocol`, `Usage: ${COMMAND_NAME} skills protocol`));
+        }
+        printJson(skillProtocolDocument());
+        return;
+    }
+    if (action === "list") {
+        const output = parseSkillsOutput(args, "json");
+        if (output !== "json") {
+            throw new Error(t(`${COMMAND_NAME} skills list 仅支持 --output json。`, `${COMMAND_NAME} skills list supports only --output json.`));
+        }
+        printJson({ ...skillProtocolDocument(), skills: await listBundledSkills() });
+        return;
+    }
+    if (action === "show") {
+        const [name, ...flags] = args;
+        if (!name || name.startsWith("-")) {
+            throw new Error(t(`用法：${COMMAND_NAME} skills show NAME [--output json|markdown]`, `Usage: ${COMMAND_NAME} skills show NAME [--output json|markdown]`));
+        }
+        const output = parseSkillsOutput(flags, "markdown");
+        const skill = await showBundledSkill(name);
+        if (output === "markdown") {
+            process.stdout.write(skill.markdown.endsWith("\n") ? skill.markdown : `${skill.markdown}\n`);
+            return;
+        }
+        printJson({ ...skillProtocolDocument(), skill });
+        return;
+    }
+    throw new Error(t("支持的 skill 操作：protocol、list、show。", "Supported skill actions: protocol, list, show."));
+}
+async function dispatchGeneratedCommand(options, commandArgs) {
+    const profile = await resolveCurrentProfile(options);
+    let artifact = await currentArtifact(profile);
+    const artifactMissing = !artifact.bundle || !artifact.manifest;
+    const failureExitPolicyRefreshRequired = artifact.manifest !== undefined && artifact.manifest.failureExitPolicyVersion !== GENERATED_FAILURE_EXIT_POLICY_VERSION;
+    if (artifactMissing || failureExitPolicyRefreshRequired) {
+        if (artifactMissing) {
+            throw new CliError("ARTIFACT_MISSING", t("没有可用的生成 CLI。", "No generated CLI is available."), t(`执行 ${COMMAND_NAME} refresh --output json 后重试。`, `Run ${COMMAND_NAME} refresh --output json, then retry.`));
+        }
+        if (failureExitPolicyRefreshRequired) {
+            throw new CliError("ARTIFACT_REFRESH_REQUIRED", t("生成的 CLI 不包含当前失败退出码策略。", "The generated CLI does not include the current failure-exit policy."), failureExitPolicyRemediation());
+        }
+    }
+    if (!artifact.bundle || !artifact.manifest) {
+        throw new CliError("ARTIFACT_MISSING", t("refresh 后仍没有可用的生成 CLI。", "No generated CLI is available after refresh."));
+    }
+    const catalog = toolCatalog(artifact.manifest, profile.timeoutMs, profile.autoApprove, artifact.state.lastCheckedAt);
+    const requestedTool = commandArgs[0];
+    const tool = requestedTool ? findTool(catalog, requestedTool) : undefined;
+    if (!tool) {
+        throw new CliError("TOOL_NOT_FOUND", requestedTool
+            ? t(`未知的生成工具 '${requestedTool}'。`, `Unknown generated tool '${requestedTool}'.`)
+            : t("需要提供一个生成工具 command。", "A generated tool command is required."), t(`执行 ${COMMAND_NAME} tools list --output json，并选择其中一个 command 值。`, `Run ${COMMAND_NAME} tools list --output json and choose one of its command values.`));
+    }
+    // MCPorter exposes a root --timeout flag. Supplying it at launch keeps the
+    // generated catalog reusable while making the current CLI timeout effective.
+    const generatedArgs = ["--timeout", String(profile.timeoutMs), tool.command, ...(await normalizeGeneratedRawInput(commandArgs.slice(1)))];
+    const bindings = createHeaderBindings(profile.profile, profile.headers);
+    const missingHeaders = Object.keys(artifact.manifest.headerBindings).filter((name) => !Object.keys(bindings.bindings).some((current) => current.toLowerCase() === name.toLowerCase()));
+    const addedHeaders = Object.keys(bindings.bindings).filter((name) => !Object.keys(artifact.manifest.headerBindings).some((current) => current.toLowerCase() === name.toLowerCase()));
+    if (missingHeaders.length > 0 || addedHeaders.length > 0) {
+        throw new CliError("ARTIFACT_REFRESH_REQUIRED", t("HTTP Header 名称已变更。", "HTTP header names changed."), t(`执行一次 ${COMMAND_NAME} refresh --force --output json；仅 Header 值变更不需要重新生成。`, `Run ${COMMAND_NAME} refresh --force --output json once; header values themselves never require regeneration.`));
+    }
+    const environment = { [ENV.runtimeEndpoint]: profile.endpoint };
+    for (const [name, generatedEnv] of Object.entries(artifact.manifest.headerBindings)) {
+        const currentName = Object.keys(profile.headers).find((candidate) => candidate.toLowerCase() === name.toLowerCase());
+        if (!currentName) {
+            throw new CliError("COMMAND_FAILED", t(`缺少生成 Header '${name}' 的运行时值。`, `Missing runtime value for generated header '${name}'.`));
+        }
+        environment[generatedEnv] = profile.headers[currentName];
+    }
+    return writeGeneratedCliResult(await runGeneratedCli(artifact.bundle, generatedArgs, environment), generatedArgs);
+}
+function refreshUsage() {
+    return t(`用法：${COMMAND_NAME} refresh [--force] [--output json|text]\n`, `Usage: ${COMMAND_NAME} refresh [--force] [--output json|text]\n`);
+}
+function parseRefreshOutput(args) {
+    let output = "text";
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        let value;
+        if (token === "--output") {
+            value = valueAfter(args, index, token);
+            index += 1;
+        }
+        else if (token.startsWith("--output=")) {
+            value = token.slice("--output=".length);
+        }
+        else {
+            throw new CliError("INVALID_ARGUMENT", t(`不支持的 refresh 选项 '${token}'。`, `Unsupported refresh option '${token}'.`), refreshUsage().trim());
+        }
+        if (value !== "json" && value !== "text") {
+            throw new CliError("INVALID_ARGUMENT", t("refresh 的 output 必须为 json 或 text。", "refresh output must be json or text."), refreshUsage().trim());
+        }
+        output = value;
+    }
+    return output;
+}
+async function commandRefresh(options) {
+    const args = options.rest.slice(1);
+    if (args.includes("--help")) {
+        if (args.length !== 1) {
+            throw new CliError("INVALID_ARGUMENT", refreshUsage().trim());
+        }
+        process.stdout.write(refreshUsage());
+        return;
+    }
+    const output = parseRefreshOutput(args);
+    const profile = await resolveCurrentProfile(options);
+    const result = await refreshProfile(profile, options.force);
+    if (output === "json") {
+        printJson(result);
+        return;
+    }
+    process.stderr.write(`${result.message}\n`);
+}
+async function commandRun(options) {
+    const [name, ...args] = options.rest.slice(1);
+    if (!name || name === "--help") {
+        if (name === "--help" && args.length === 0) {
+            process.stdout.write(runUsage());
+            return;
+        }
+        throw new CliError("INVALID_ARGUMENT", runUsage().trim());
+    }
+    const code = await dispatchGeneratedCommand(options, [name, ...args]);
+    process.exitCode = code;
+}
+async function main() {
+    const options = parseGlobalOptions(process.argv.slice(2));
+    const first = options.rest[0];
+    if (first === "--version" || first === "-V") {
+        process.stdout.write(`${LAUNCHER_VERSION}\n`);
+        return;
+    }
+    if (!first) {
+        process.stdout.write(usage());
+        return;
+    }
+    if (first === "init") {
+        await commandInit(options);
+        return;
+    }
+    if (first === "refresh") {
+        await commandRefresh(options);
+        return;
+    }
+    if (first === "doctor") {
+        await commandDoctor(options);
+        return;
+    }
+    if (first === "config") {
+        await commandConfig(options);
+        return;
+    }
+    if (first === "skills") {
+        await commandSkills(options);
+        return;
+    }
+    if (first === "describe") {
+        await commandDescribe(options);
+        return;
+    }
+    if (first === "tools") {
+        await commandTools(options);
+        return;
+    }
+    if (first === "run") {
+        await commandRun(options);
+        return;
+    }
+    if (first === "help") {
+        process.stdout.write(usage());
+        return;
+    }
+    if (first === "--help" || first === "-h") {
+        process.stdout.write(usage());
+        return;
+    }
+    throw new CliError("INVALID_ARGUMENT", t(`未知的启动器命令 '${first}'。`, `Unknown launcher command '${first}'.`), usage().trim());
+}
+function requestedJsonOutput(args) {
+    for (let index = 0; index < args.length; index += 1) {
+        const token = args[index];
+        if (token === "--output" && args[index + 1] === "json") {
+            return true;
+        }
+        if (token === "--output=json") {
+            return true;
+        }
+    }
+    return false;
+}
+main().catch((error) => {
+    if (requestedJsonOutput(process.argv.slice(2))) {
+        printJson(errorDocument(error));
+    }
+    else {
+        process.stderr.write(`${COMMAND_NAME}: ${error instanceof Error ? error.message : String(error)}\n`);
+    }
+    process.exitCode = 1;
+});
+//# sourceMappingURL=cli.js.map