@leeguoo/yapi-mcp 0.3.0 → 0.3.2

package/dist/yapi-cli.js

@@ -0,0 +1,1532 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const readline_1 = __importDefault(require("readline"));
+const install_1 = require("./skill/install");
+const auth_1 = require("./services/yapi/auth");
+function parseKeyValue(raw) {
+    if (!raw || !raw.includes("="))
+        throw new Error("expected key=value");
+    const idx = raw.indexOf("=");
+    return [raw.slice(0, idx), raw.slice(idx + 1)];
+}
+function parseHeader(raw) {
+    if (!raw || !raw.includes(":"))
+        throw new Error("expected Header:Value");
+    const idx = raw.indexOf(":");
+    return [raw.slice(0, idx).trim(), raw.slice(idx + 1).trim()];
+}
+function parseJsonMaybe(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+function getPayloadMessage(payload) {
+    if (!payload || typeof payload !== "object")
+        return "";
+    const record = payload;
+    const message = record.errmsg ?? record.message ?? record.msg;
+    return typeof message === "string" ? message : "";
+}
+function getPayloadErrcode(payload) {
+    if (!payload || typeof payload !== "object")
+        return null;
+    const record = payload;
+    const code = Number(record.errcode ?? record.code ?? record.errCode);
+    return Number.isFinite(code) ? code : null;
+}
+function looksLikeAuthError(status, payload) {
+    if (status === 401 || status === 403)
+        return true;
+    const code = getPayloadErrcode(payload);
+    if (code !== null && [40011, 40012, 40013, 401, 403].includes(code))
+        return true;
+    const message = getPayloadMessage(payload);
+    if (!message)
+        return false;
+    return /登录|login|权限|unauthori|forbidden|not\s*login|no\s*permission/i.test(message);
+}
+function joinUrl(baseUrl, endpoint) {
+    if (!baseUrl)
+        return endpoint;
+    if (baseUrl.endsWith("/") && endpoint.startsWith("/"))
+        return baseUrl.slice(0, -1) + endpoint;
+    if (!baseUrl.endsWith("/") && !endpoint.startsWith("/"))
+        return baseUrl + "/" + endpoint;
+    return baseUrl + endpoint;
+}
+function globalConfigPath() {
+    const yapiHome = process.env.YAPI_HOME || path_1.default.join(os_1.default.homedir(), ".yapi");
+    return path_1.default.join(yapiHome, "config.toml");
+}
+function parseSimpleToml(text) {
+    const data = {};
+    const lines = String(text || "").split(/\r?\n/);
+    for (const rawLine of lines) {
+        const line = rawLine.split("#", 1)[0].split(";", 1)[0].trim();
+        if (!line || line.startsWith("["))
+            continue;
+        const idx = line.indexOf("=");
+        if (idx === -1)
+            continue;
+        const key = line.slice(0, idx).trim();
+        let value = line.slice(idx + 1).trim();
+        if (!key)
+            continue;
+        if ((value.startsWith("\"") && value.endsWith("\"")) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        data[key] = value;
+    }
+    return data;
+}
+function resolveToken(tokenValue, projectId) {
+    if (!tokenValue)
+        return "";
+    if (tokenValue.includes(",") || tokenValue.includes(":")) {
+        let defaultToken = "";
+        const mapping = {};
+        tokenValue.split(",").forEach((rawPair) => {
+            const pair = rawPair.trim();
+            if (!pair)
+                return;
+            const idx = pair.indexOf(":");
+            if (idx === -1) {
+                defaultToken = pair;
+                return;
+            }
+            const pid = pair.slice(0, idx).trim();
+            const token = pair.slice(idx + 1).trim();
+            if (pid && token)
+                mapping[pid] = token;
+        });
+        if (projectId && mapping[projectId])
+            return mapping[projectId];
+        if (defaultToken)
+            return defaultToken;
+        const keys = Object.keys(mapping);
+        if (keys.length)
+            return mapping[keys[0]];
+    }
+    return tokenValue;
+}
+async function fetchWithTimeout(url, options, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { ...options, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function buildUrl(baseUrl, endpoint, queryItems, token, tokenParam) {
+    const url = baseUrl ? joinUrl(baseUrl, endpoint) : endpoint;
+    const parsed = new URL(url);
+    for (const [key, value] of queryItems) {
+        if (key)
+            parsed.searchParams.append(key, value ?? "");
+    }
+    if (token && !parsed.searchParams.has(tokenParam)) {
+        parsed.searchParams.append(tokenParam, token);
+    }
+    return parsed.toString();
+}
+function parseArgs(argv) {
+    const options = {
+        query: [],
+        header: [],
+        method: "GET",
+        tokenParam: "token",
+        timeout: 30000,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (!arg)
+            continue;
+        if (arg === "-h" || arg === "--help") {
+            options.help = true;
+            continue;
+        }
+        if (arg === "-V" || arg === "--version") {
+            options.version = true;
+            continue;
+        }
+        if (arg === "--config") {
+            options.config = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--config=")) {
+            options.config = arg.slice(9);
+            continue;
+        }
+        if (arg === "--base-url") {
+            options.baseUrl = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--base-url=")) {
+            options.baseUrl = arg.slice(11);
+            continue;
+        }
+        if (arg === "--token") {
+            options.token = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--token=")) {
+            options.token = arg.slice(8);
+            continue;
+        }
+        if (arg === "--project-id") {
+            options.projectId = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--project-id=")) {
+            options.projectId = arg.slice(13);
+            continue;
+        }
+        if (arg === "--auth-mode") {
+            options.authMode = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--auth-mode=")) {
+            options.authMode = arg.slice(12);
+            continue;
+        }
+        if (arg === "--email") {
+            options.email = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--email=")) {
+            options.email = arg.slice(8);
+            continue;
+        }
+        if (arg === "--password") {
+            options.password = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--password=")) {
+            options.password = arg.slice(11);
+            continue;
+        }
+        if (arg === "--cookie") {
+            options.cookie = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--cookie=")) {
+            options.cookie = arg.slice(9);
+            continue;
+        }
+        if (arg === "--token-param") {
+            options.tokenParam = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--token-param=")) {
+            options.tokenParam = arg.slice(14);
+            continue;
+        }
+        if (arg === "--method") {
+            options.method = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--method=")) {
+            options.method = arg.slice(9);
+            continue;
+        }
+        if (arg === "--path") {
+            options.path = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--path=")) {
+            options.path = arg.slice(7);
+            continue;
+        }
+        if (arg === "--url") {
+            options.url = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--url=")) {
+            options.url = arg.slice(6);
+            continue;
+        }
+        if (arg === "--query") {
+            options.query?.push(argv[++i]);
+            continue;
+        }
+        if (arg.startsWith("--query=")) {
+            options.query?.push(arg.slice(8));
+            continue;
+        }
+        if (arg === "--header") {
+            options.header?.push(argv[++i]);
+            continue;
+        }
+        if (arg.startsWith("--header=")) {
+            options.header?.push(arg.slice(9));
+            continue;
+        }
+        if (arg === "--data") {
+            options.data = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--data=")) {
+            options.data = arg.slice(7);
+            continue;
+        }
+        if (arg === "--data-file") {
+            options.dataFile = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--data-file=")) {
+            options.dataFile = arg.slice(12);
+            continue;
+        }
+        if (arg === "--timeout") {
+            options.timeout = Number(argv[++i]);
+            continue;
+        }
+        if (arg.startsWith("--timeout=")) {
+            options.timeout = Number(arg.slice(10));
+            continue;
+        }
+        if (arg === "--no-pretty") {
+            options.noPretty = true;
+            continue;
+        }
+    }
+    return options;
+}
+function parseDocsSyncArgs(argv) {
+    const options = {
+        dirs: [],
+        bindings: [],
+        tokenParam: "token",
+        timeout: 30000,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (!arg)
+            continue;
+        if (arg === "-h" || arg === "--help") {
+            options.help = true;
+            continue;
+        }
+        if (arg === "--config") {
+            options.config = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--config=")) {
+            options.config = arg.slice(9);
+            continue;
+        }
+        if (arg === "--base-url") {
+            options.baseUrl = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--base-url=")) {
+            options.baseUrl = arg.slice(11);
+            continue;
+        }
+        if (arg === "--token") {
+            options.token = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--token=")) {
+            options.token = arg.slice(8);
+            continue;
+        }
+        if (arg === "--project-id") {
+            options.projectId = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--project-id=")) {
+            options.projectId = arg.slice(13);
+            continue;
+        }
+        if (arg === "--auth-mode") {
+            options.authMode = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--auth-mode=")) {
+            options.authMode = arg.slice(12);
+            continue;
+        }
+        if (arg === "--email") {
+            options.email = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--email=")) {
+            options.email = arg.slice(8);
+            continue;
+        }
+        if (arg === "--password") {
+            options.password = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--password=")) {
+            options.password = arg.slice(11);
+            continue;
+        }
+        if (arg === "--cookie") {
+            options.cookie = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--cookie=")) {
+            options.cookie = arg.slice(9);
+            continue;
+        }
+        if (arg === "--token-param") {
+            options.tokenParam = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--token-param=")) {
+            options.tokenParam = arg.slice(14);
+            continue;
+        }
+        if (arg === "--timeout") {
+            options.timeout = Number(argv[++i]);
+            continue;
+        }
+        if (arg.startsWith("--timeout=")) {
+            options.timeout = Number(arg.slice(10));
+            continue;
+        }
+        if (arg === "--dir") {
+            options.dirs.push(argv[++i]);
+            continue;
+        }
+        if (arg.startsWith("--dir=")) {
+            options.dirs.push(arg.slice(6));
+            continue;
+        }
+        if (arg === "--binding") {
+            options.bindings.push(argv[++i]);
+            continue;
+        }
+        if (arg.startsWith("--binding=")) {
+            options.bindings.push(arg.slice(10));
+            continue;
+        }
+        if (arg === "--dry-run") {
+            options.dryRun = true;
+            continue;
+        }
+        if (arg === "--no-mermaid") {
+            options.noMermaid = true;
+            continue;
+        }
+        if (arg.startsWith("-"))
+            continue;
+        options.dirs.push(arg);
+    }
+    return options;
+}
+function parseDocsSyncBindArgs(argv) {
+    const options = {
+        sourceFiles: [],
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (!arg)
+            continue;
+        if (arg === "-h" || arg === "--help") {
+            options.help = true;
+            continue;
+        }
+        if (arg === "--name" || arg === "--binding") {
+            options.name = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--name=")) {
+            options.name = arg.slice(7);
+            continue;
+        }
+        if (arg.startsWith("--binding=")) {
+            options.name = arg.slice(10);
+            continue;
+        }
+        if (arg === "--dir") {
+            options.dir = argv[++i];
+            continue;
+        }
+        if (arg.startsWith("--dir=")) {
+            options.dir = arg.slice(6);
+            continue;
+        }
+        if (arg === "--project-id") {
+            options.projectId = Number(argv[++i]);
+            continue;
+        }
+        if (arg.startsWith("--project-id=")) {
+            options.projectId = Number(arg.slice(13));
+            continue;
+        }
+        if (arg === "--catid" || arg === "--cat-id") {
+            options.catId = Number(argv[++i]);
+            continue;
+        }
+        if (arg.startsWith("--catid=")) {
+            options.catId = Number(arg.slice(8));
+            continue;
+        }
+        if (arg.startsWith("--cat-id=")) {
+            options.catId = Number(arg.slice(9));
+            continue;
+        }
+        if (arg === "--template-id") {
+            options.templateId = Number(argv[++i]);
+            continue;
+        }
+        if (arg.startsWith("--template-id=")) {
+            options.templateId = Number(arg.slice(14));
+            continue;
+        }
+        if (arg === "--source-file") {
+            options.sourceFiles?.push(argv[++i]);
+            continue;
+        }
+        if (arg.startsWith("--source-file=")) {
+            options.sourceFiles?.push(arg.slice(14));
+            continue;
+        }
+        if (arg === "--clear-source-files") {
+            options.clearSourceFiles = true;
+            continue;
+        }
+    }
+    return options;
+}
+function usage() {
+    return [
+        "Usage:",
+        "  yapi --path /api/interface/get --query id=123",
+        "  yapi docs-sync [options] [dir...]",
+        "  yapi docs-sync bind <action> [options]",
+        "  yapi login [options]",
+        "  yapi install-skill [options]",
+        "Options:",
+        "  --config <path>        config file path (default: ~/.yapi/config.toml)",
+        "  --base-url <url>       YApi base URL",
+        "  --token <token>        project token (supports projectId:token)",
+        "  --project-id <id>      select token for project",
+        "  --auth-mode <mode>     token or global",
+        "  --email <email>        login email for global mode",
+        "  --password <pwd>       login password for global mode",
+        "  --path <path>          API path (e.g., /api/interface/get)",
+        "  --url <url>            full URL (overrides base-url/path)",
+        "  --query key=value      query param (repeatable)",
+        "  --header Header:Value  request header (repeatable)",
+        "  --method <method>      HTTP method",
+        "  --data <payload>       request body (JSON or text)",
+        "  --data-file <file>     request body file",
+        "  --timeout <ms>         request timeout in ms",
+        "  --no-pretty            print raw response",
+        "Docs-sync options:",
+        "  --dir <path>           docs directory (repeatable; default: docs/release-notes)",
+        "  --binding <name>       use binding from .yapi/docs-sync.json (repeatable)",
+        "  --dry-run              compute but do not update YApi or mapping files",
+        "  --no-mermaid           do not render mermaid code blocks",
+        "Docs-sync bind actions:",
+        "  list, get, add, update, remove",
+        "  -V, --version          print version",
+        "  -h, --help             show help",
+    ].join("\n");
+}
+function docsSyncUsage() {
+    return [
+        "Usage:",
+        "  yapi docs-sync [options] [dir...]",
+        "  yapi docs-sync bind <action> [options]",
+        "Options:",
+        "  --config <path>        config file path (default: ~/.yapi/config.toml)",
+        "  --base-url <url>       YApi base URL",
+        "  --token <token>        project token (supports projectId:token)",
+        "  --project-id <id>      select token for project",
+        "  --auth-mode <mode>     token or global",
+        "  --email <email>        login email for global mode",
+        "  --password <pwd>       login password for global mode",
+        "  --cookie <cookie>      cookie for global mode",
+        "  --token-param <name>   token query param name (default: token)",
+        "  --timeout <ms>         request timeout in ms",
+        "  --dir <path>           docs directory (repeatable; default: docs/release-notes)",
+        "  --binding <name>       use binding from .yapi/docs-sync.json (repeatable)",
+        "  --dry-run              compute but do not update YApi or mapping files",
+        "  --no-mermaid           do not render mermaid code blocks",
+        "  -h, --help             show help",
+    ].join("\n");
+}
+function docsSyncBindUsage() {
+    return [
+        "Usage:",
+        "  yapi docs-sync bind list",
+        "  yapi docs-sync bind get --name <binding>",
+        "  yapi docs-sync bind add --name <binding> --dir <path> --project-id <id> --catid <id> [options]",
+        "  yapi docs-sync bind update --name <binding> [options]",
+        "  yapi docs-sync bind remove --name <binding>",
+        "Options:",
+        "  --name <binding>       binding name (alias: --binding)",
+        "  --dir <path>           docs directory path",
+        "  --project-id <id>      YApi project id",
+        "  --catid <id>           YApi category id",
+        "  --template-id <id>     template interface id",
+        "  --source-file <path>   sync specific file(s) (repeatable)",
+        "  --clear-source-files   clear source_files list",
+        "  -h, --help             show help",
+    ].join("\n");
+}
+function loginUsage() {
+    return [
+        "Usage:",
+        "  yapi login [options]",
+        "Options:",
+        "  --config <path>        config file path (default: ~/.yapi/config.toml)",
+        "  --base-url <url>       YApi base URL",
+        "  --email <email>        login email for global mode",
+        "  --password <pwd>       login password for global mode",
+        "  --timeout <ms>         request timeout in ms",
+        "  -h, --help             show help",
+    ].join("\n");
+}
+function escapeTomlValue(value) {
+    return String(value || "").replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+}
+function formatToml(config) {
+    const orderedKeys = ["base_url", "auth_mode", "email", "password", "token", "project_id"];
+    const lines = ["# YApi CLI config"];
+    for (const key of orderedKeys) {
+        const value = config[key] || "";
+        lines.push(`${key} = "${escapeTomlValue(value)}"`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+function writeConfig(filePath, config) {
+    fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+    fs_1.default.writeFileSync(filePath, formatToml(config), "utf8");
+}
+function promptText(question) {
+    const rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+function promptHidden(question) {
+    const rl = readline_1.default.createInterface({ input: process.stdin, output: process.stdout, terminal: true });
+    const originalWrite = rl._writeToOutput;
+    rl.stdoutMuted = true;
+    rl._writeToOutput = function writeToOutput(value) {
+        if (rl.stdoutMuted)
+            return;
+        if (typeof originalWrite === "function") {
+            originalWrite.call(this, value);
+        }
+        else {
+            rl.output.write(value);
+        }
+    };
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.stdoutMuted = false;
+            rl.close();
+            resolve(answer);
+        });
+    });
+}
+async function promptRequired(question, hidden) {
+    while (true) {
+        const answer = hidden ? await promptHidden(question) : await promptText(question);
+        const trimmed = String(answer || "").trim();
+        if (trimmed)
+            return trimmed;
+    }
+}
+async function initConfigIfMissing(options) {
+    const hasBaseUrl = Boolean(options.baseUrl);
+    const hasEmail = Boolean(options.email);
+    const hasPassword = Boolean(options.password);
+    if (!hasBaseUrl || !hasEmail || !hasPassword) {
+        if (!process.stdin.isTTY || !process.stdout.isTTY)
+            return null;
+    }
+    const baseUrl = hasBaseUrl ? options.baseUrl : await promptRequired("YApi base URL: ", false);
+    const email = hasEmail ? options.email : await promptRequired("YApi email: ", false);
+    const password = hasPassword ? options.password : await promptRequired("YApi password: ", true);
+    const config = {
+        base_url: baseUrl || "",
+        auth_mode: "global",
+        email: email || "",
+        password: password || "",
+        token: options.token || "",
+        project_id: options.projectId || "",
+    };
+    const configPath = globalConfigPath();
+    writeConfig(configPath, config);
+    return { configPath, config };
+}
+function readVersion() {
+    try {
+        const pkgPath = path_1.default.resolve(__dirname, "../package.json");
+        const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, "utf8"));
+        return pkg.version || "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+async function runLogin(rawArgs) {
+    const options = parseArgs(rawArgs);
+    if (options.help) {
+        console.log(loginUsage());
+        return 0;
+    }
+    if (options.version) {
+        console.log(readVersion());
+        return 0;
+    }
+    const configPath = options.config || globalConfigPath();
+    const config = fs_1.default.existsSync(configPath)
+        ? parseSimpleToml(fs_1.default.readFileSync(configPath, "utf8"))
+        : {};
+    let baseUrl = options.baseUrl || config.base_url || "";
+    let email = options.email || config.email || "";
+    let password = options.password || config.password || "";
+    let updated = false;
+    if (!baseUrl) {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            console.error("missing --base-url or config base_url");
+            return 2;
+        }
+        baseUrl = await promptRequired("YApi base URL: ", false);
+        updated = true;
+    }
+    if (!email) {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            console.error("missing --email or config email");
+            return 2;
+        }
+        email = await promptRequired("YApi email: ", false);
+        updated = true;
+    }
+    if (!password) {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            console.error("missing --password or config password");
+            return 2;
+        }
+        password = await promptRequired("YApi password: ", true);
+        updated = true;
+    }
+    const shouldWriteConfig = updated || !fs_1.default.existsSync(configPath) || config.auth_mode !== "global";
+    if (shouldWriteConfig) {
+        const mergedConfig = {
+            base_url: baseUrl,
+            auth_mode: "global",
+            email,
+            password,
+            token: options.token || config.token || "",
+            project_id: options.projectId || config.project_id || "",
+        };
+        writeConfig(configPath, mergedConfig);
+    }
+    try {
+        const authService = new auth_1.YApiAuthService(baseUrl, email, password, "warn", { timeoutMs: options.timeout || 30000 });
+        await authService.getCookieHeaderWithLogin({ forceLogin: true });
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 2;
+    }
+    console.log("login success (cookie cached in ~/.yapi-mcp/auth-*.json)");
+    return 0;
+}
+function findDocsSyncHome(startDir) {
+    let current = path_1.default.resolve(startDir);
+    while (true) {
+        const candidate = path_1.default.join(current, ".yapi");
+        if (fs_1.default.existsSync(candidate) && fs_1.default.statSync(candidate).isDirectory()) {
+            return candidate;
+        }
+        const parent = path_1.default.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+function resolveDocsSyncHome(startDir, ensure) {
+    const found = findDocsSyncHome(startDir);
+    if (found)
+        return found;
+    if (!ensure)
+        return null;
+    const home = path_1.default.join(path_1.default.resolve(startDir), ".yapi");
+    fs_1.default.mkdirSync(home, { recursive: true });
+    ensureDocsSyncReadme(home);
+    return home;
+}
+function docsSyncConfigPath(homeDir) {
+    return path_1.default.join(homeDir, "docs-sync.json");
+}
+const DOCS_SYNC_README = [
+    "# YApi Docs Sync",
+    "",
+    "This folder is generated by the yapi docs-sync tool.",
+    "",
+    "Project: https://github.com/leeguooooo/cross-request-master",
+    "",
+    "Files:",
+    "- docs-sync.json: bindings and file-to-doc ID mapping.",
+].join("\n");
+function ensureDocsSyncReadme(homeDir) {
+    const readmePath = path_1.default.join(homeDir, "README.md");
+    if (fs_1.default.existsSync(readmePath))
+        return;
+    fs_1.default.writeFileSync(readmePath, `${DOCS_SYNC_README}\n`, "utf8");
+}
+function loadDocsSyncConfig(homeDir) {
+    const configPath = docsSyncConfigPath(homeDir);
+    if (!fs_1.default.existsSync(configPath)) {
+        return { version: 1, bindings: {} };
+    }
+    const raw = fs_1.default.readFileSync(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const bindings = parsed.bindings && typeof parsed.bindings === "object" ? parsed.bindings : {};
+    return {
+        version: typeof parsed.version === "number" ? parsed.version : 1,
+        bindings: bindings,
+    };
+}
+function saveDocsSyncConfig(homeDir, config) {
+    const configPath = docsSyncConfigPath(homeDir);
+    fs_1.default.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+}
+function resolveBindingDir(rootDir, bindingDir) {
+    if (!bindingDir)
+        return rootDir;
+    return path_1.default.isAbsolute(bindingDir) ? bindingDir : path_1.default.resolve(rootDir, bindingDir);
+}
+function normalizeBindingDir(rootDir, bindingDir) {
+    const resolved = resolveBindingDir(rootDir, bindingDir);
+    const relative = path_1.default.relative(rootDir, resolved);
+    if (!relative || relative === ".")
+        return ".";
+    if (relative.startsWith("..") || path_1.default.isAbsolute(relative))
+        return resolved;
+    return relative;
+}
+function ensurePandoc() {
+    try {
+        (0, child_process_1.execFileSync)("pandoc", ["--version"], { stdio: "ignore" });
+    }
+    catch (error) {
+        throw new Error("pandoc not found. Install pandoc first.");
+    }
+}
+function ensureMmdc() {
+    try {
+        (0, child_process_1.execFileSync)("mmdc", ["--version"], { stdio: "ignore" });
+    }
+    catch (error) {
+        throw new Error("mmdc (mermaid-cli) not found. Install it to render Mermaid diagrams.");
+    }
+}
+function stripSvgProlog(svg) {
+    return svg
+        .replace(/^\s*<\?xml[^>]*>\s*/i, "")
+        .replace(/^\s*<!DOCTYPE[^>]*>\s*/i, "")
+        .trim();
+}
+function renderMermaidToSvg(source) {
+    ensureMmdc();
+    const tmpDir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), "yapi-docs-sync-"));
+    const inputPath = path_1.default.join(tmpDir, "diagram.mmd");
+    const outputPath = path_1.default.join(tmpDir, "diagram.svg");
+    try {
+        fs_1.default.writeFileSync(inputPath, source, "utf8");
+        (0, child_process_1.execFileSync)("mmdc", ["-i", inputPath, "-o", outputPath, "-b", "transparent"], { stdio: "pipe" });
+        const svg = fs_1.default.readFileSync(outputPath, "utf8");
+        return stripSvgProlog(svg);
+    }
+    finally {
+        fs_1.default.rmSync(tmpDir, { recursive: true, force: true });
+    }
+}
+function preprocessMarkdown(markdown, options) {
+    if (options.noMermaid)
+        return markdown;
+    const pattern = /```mermaid\s*\r?\n([\s\S]*?)\r?\n```/g;
+    return markdown.replace(pattern, (_match, content) => {
+        const svg = renderMermaidToSvg(String(content || "").trim());
+        return `<div class="mermaid-diagram">\n${svg}\n</div>`;
+    });
+}
+function markdownToHtml(markdown) {
+    return (0, child_process_1.execFileSync)("pandoc", ["-f", "gfm+hard_line_breaks", "-t", "html"], {
+        input: markdown,
+        encoding: "utf8",
+    });
+}
+function loadMapping(dirPath) {
+    const mappingPath = path_1.default.join(dirPath, ".yapi.json");
+    if (!fs_1.default.existsSync(mappingPath)) {
+        return { mapping: {}, mappingPath };
+    }
+    const raw = fs_1.default.readFileSync(mappingPath, "utf8");
+    const mapping = JSON.parse(raw);
+    return { mapping, mappingPath };
+}
+function saveMapping(mapping, mappingPath) {
+    fs_1.default.writeFileSync(mappingPath, `${JSON.stringify(mapping, null, 2)}\n`, "utf8");
+}
+function resolveSourceFiles(dirPath, mapping) {
+    const sources = Array.isArray(mapping.source_files) ? mapping.source_files : [];
+    if (!sources.length) {
+        return fs_1.default
+            .readdirSync(dirPath)
+            .filter((name) => name.endsWith(".md") && name !== "README.md")
+            .map((name) => path_1.default.join(dirPath, name))
+            .sort((a, b) => a.localeCompare(b));
+    }
+    return sources.map((source) => {
+        const resolved = path_1.default.isAbsolute(source) ? source : path_1.default.resolve(dirPath, source);
+        if (!fs_1.default.existsSync(resolved) || !fs_1.default.statSync(resolved).isFile()) {
+            throw new Error(`source file not found: ${resolved}`);
+        }
+        return resolved;
+    });
+}
+async function listExistingInterfaces(catId, request) {
+    const resp = await request("/api/interface/list_cat", "GET", { catid: catId, page: 1, limit: 10000 });
+    if (resp?.errcode !== 0) {
+        throw new Error(`list_cat failed: ${resp?.errmsg || "unknown error"}`);
+    }
+    const items = resp?.data?.list || [];
+    const byPath = {};
+    const byTitle = {};
+    for (const item of items) {
+        const apiPath = item?.path;
+        const title = item?.title;
+        const itemId = item?._id;
+        if (apiPath && itemId)
+            byPath[apiPath] = Number(itemId);
+        if (title && itemId)
+            byTitle[title] = Number(itemId);
+    }
+    return { byPath, byTitle };
+}
+function buildAddPayload(template, title, apiPath, catId, projectId) {
+    return {
+        title,
+        path: apiPath,
+        method: template.method || "GET",
+        catid: catId,
+        project_id: projectId,
+        status: template.status || "undone",
+        type: template.type || "static",
+        api_opened: template.api_opened || false,
+        req_query: template.req_query || [],
+        req_headers: template.req_headers || [],
+        req_params: template.req_params || [],
+        req_body_type: template.req_body_type || "json",
+        req_body_form: template.req_body_form || [],
+        req_body_is_json_schema: template.req_body_is_json_schema ?? true,
+        res_body_type: template.res_body_type || "json",
+        res_body: template.res_body || "{\"type\":\"object\",\"title\":\"title\",\"properties\":{}}",
+        res_body_is_json_schema: template.res_body_is_json_schema ?? true,
+        tag: template.tag || [],
+    };
+}
+async function addInterface(title, apiPath, mapping, request) {
+    const projectId = Number(mapping.project_id || 0);
+    const catId = Number(mapping.catid || 0);
+    if (!projectId || !catId) {
+        throw new Error("project_id and catid are required to create new docs");
+    }
+    let template = {};
+    if (mapping.template_id) {
+        const resp = await request("/api/interface/get", "GET", { id: mapping.template_id });
+        if (resp?.errcode !== 0) {
+            throw new Error(`interface get failed: ${resp?.errmsg || "unknown error"}`);
+        }
+        template = resp?.data || {};
+    }
+    const payload = buildAddPayload(template, title, apiPath, catId, projectId);
+    const resp = await request("/api/interface/add", "POST", {}, payload);
+    if (resp?.errcode !== 0) {
+        throw new Error(`interface add failed: ${resp?.errmsg || "unknown error"}`);
+    }
+    const newId = resp?.data?._id;
+    if (!newId) {
+        throw new Error("interface add succeeded but missing id");
+    }
+    return Number(newId);
+}
+async function updateInterface(docId, markdown, html, request) {
+    const resp = await request("/api/interface/up", "POST", {}, { id: docId, markdown, desc: html });
+    if (resp?.errcode !== 0) {
+        throw new Error(`interface up failed: ${resp?.errmsg || "unknown error"}`);
+    }
+}
+async function syncDocsDir(dirPath, mapping, options, request) {
+    mapping.files = mapping.files || {};
+    const envProjectId = process.env.YAPI_PROJECT_ID;
+    const envCatId = process.env.YAPI_CATID;
+    const envTemplateId = process.env.YAPI_TEMPLATE_ID;
+    if (!mapping.project_id && envProjectId)
+        mapping.project_id = Number(envProjectId);
+    if (!mapping.catid && envCatId)
+        mapping.catid = Number(envCatId);
+    if (!mapping.template_id && envTemplateId)
+        mapping.template_id = Number(envTemplateId);
+    if (!mapping.project_id || !mapping.catid) {
+        throw new Error("project_id/catid missing; set in binding/.yapi.json or env");
+    }
+    const { byPath, byTitle } = await listExistingInterfaces(Number(mapping.catid), request);
+    let updated = 0;
+    let created = 0;
+    const files = resolveSourceFiles(dirPath, mapping);
+    for (const mdPath of files) {
+        const stem = path_1.default.parse(mdPath).name;
+        const relName = path_1.default.basename(mdPath);
+        const apiPath = `/${stem}`;
+        let docId = mapping.files[relName];
+        if (!docId) {
+            docId = byPath[apiPath] || byTitle[stem];
+            if (docId)
+                mapping.files[relName] = docId;
+        }
+        if (!docId) {
+            created += 1;
+            if (!options.dryRun) {
+                docId = await addInterface(stem, apiPath, mapping, request);
+                mapping.files[relName] = docId;
+            }
+        }
+        const markdown = fs_1.default.readFileSync(mdPath, "utf8");
+        const html = markdownToHtml(preprocessMarkdown(markdown, options));
+        if (!options.dryRun && docId) {
+            await updateInterface(docId, markdown, html, request);
+        }
+        updated += 1;
+    }
+    return { updated, created };
+}
+async function runDocsSyncBindings(rawArgs) {
+    const action = (rawArgs[0] || "list").toLowerCase();
+    const args = rawArgs[0] ? rawArgs.slice(1) : rawArgs;
+    const options = parseDocsSyncBindArgs(args);
+    if (options.help) {
+        console.log(docsSyncBindUsage());
+        return 0;
+    }
+    const writeActions = new Set(["add", "update", "remove", "rm", "delete", "del"]);
+    const readActions = new Set(["list", "get"]);
+    if (!writeActions.has(action) && !readActions.has(action)) {
+        console.error(`unknown docs-sync bind action: ${action}`);
+        console.error(docsSyncBindUsage());
+        return 2;
+    }
+    const homeDir = resolveDocsSyncHome(process.cwd(), writeActions.has(action));
+    if (!homeDir) {
+        if (action === "list") {
+            console.log("no docs-sync bindings (missing .yapi/docs-sync.json)");
+            return 0;
+        }
+        console.error("missing .yapi/docs-sync.json (run in project root or create one with docs-sync bind add)");
+        return 2;
+    }
+    const rootDir = path_1.default.dirname(homeDir);
+    const config = loadDocsSyncConfig(homeDir);
+    if (action === "list") {
+        const entries = Object.entries(config.bindings).sort(([a], [b]) => a.localeCompare(b));
+        if (!entries.length) {
+            console.log("no docs-sync bindings");
+            return 0;
+        }
+        for (const [name, binding] of entries) {
+            const filesCount = binding.files ? Object.keys(binding.files).length : 0;
+            console.log(`${name} dir=${binding.dir} project_id=${binding.project_id ?? ""} catid=${binding.catid ?? ""}` +
+                (binding.template_id ? ` template_id=${binding.template_id}` : "") +
+                ` files=${filesCount}`);
+        }
+        return 0;
+    }
+    if (!options.name) {
+        console.error("missing --name for docs-sync bind action");
+        console.error(docsSyncBindUsage());
+        return 2;
+    }
+    if (action === "get") {
+        const binding = config.bindings[options.name];
+        if (!binding) {
+            console.error(`binding not found: ${options.name}`);
+            return 2;
+        }
+        console.log(JSON.stringify(binding, null, 2));
+        return 0;
+    }
+    if (action === "remove" || action === "rm" || action === "delete" || action === "del") {
+        if (!config.bindings[options.name]) {
+            console.error(`binding not found: ${options.name}`);
+            return 2;
+        }
+        delete config.bindings[options.name];
+        saveDocsSyncConfig(homeDir, config);
+        console.log(`binding removed: ${options.name}`);
+        return 0;
+    }
+    const hasExisting = Boolean(config.bindings[options.name]);
+    if (action === "add" && hasExisting) {
+        console.error(`binding already exists: ${options.name}`);
+        return 2;
+    }
+    if (action === "update" && !hasExisting) {
+        console.error(`binding not found: ${options.name}`);
+        return 2;
+    }
+    if (action === "add") {
+        if (!options.dir || !Number.isFinite(options.projectId ?? NaN) || !Number.isFinite(options.catId ?? NaN)) {
+            console.error("add requires --dir, --project-id, and --catid");
+            console.error(docsSyncBindUsage());
+            return 2;
+        }
+    }
+    const existing = config.bindings[options.name] || {};
+    const next = {
+        dir: existing.dir || "",
+        project_id: existing.project_id,
+        catid: existing.catid,
+        template_id: existing.template_id,
+        source_files: existing.source_files ? [...existing.source_files] : undefined,
+        files: existing.files ? { ...existing.files } : {},
+    };
+    if (options.dir) {
+        next.dir = normalizeBindingDir(rootDir, options.dir);
+    }
+    if (options.projectId !== undefined && Number.isFinite(options.projectId)) {
+        next.project_id = Number(options.projectId);
+    }
+    if (options.catId !== undefined && Number.isFinite(options.catId)) {
+        next.catid = Number(options.catId);
+    }
+    if (options.templateId !== undefined && Number.isFinite(options.templateId)) {
+        next.template_id = Number(options.templateId);
+    }
+    if (options.clearSourceFiles) {
+        next.source_files = [];
+    }
+    else if (options.sourceFiles && options.sourceFiles.length) {
+        next.source_files = options.sourceFiles;
+    }
+    if (!next.dir || !next.project_id || !next.catid) {
+        console.error("binding requires dir/project_id/catid");
+        return 2;
+    }
+    config.bindings[options.name] = next;
+    saveDocsSyncConfig(homeDir, config);
+    console.log(`${action === "add" ? "binding added" : "binding updated"}: ${options.name}`);
+    return 0;
+}
+async function runDocsSync(rawArgs) {
+    const firstArg = rawArgs[0];
+    if (firstArg === "bind" || firstArg === "bindings") {
+        return await runDocsSyncBindings(rawArgs.slice(1));
+    }
+    const options = parseDocsSyncArgs(rawArgs);
+    if (options.help) {
+        console.log(docsSyncUsage());
+        return 0;
+    }
+    try {
+        ensurePandoc();
+        if (options.bindings.length && options.dirs.length) {
+            console.error("use --binding or --dir, not both");
+            return 2;
+        }
+        const docsSyncHome = resolveDocsSyncHome(process.cwd(), false);
+        const docsSyncConfig = docsSyncHome ? loadDocsSyncConfig(docsSyncHome) : null;
+        let bindingNames = options.bindings;
+        let useBindings = bindingNames.length > 0;
+        if (!useBindings && !options.dirs.length && docsSyncConfig && Object.keys(docsSyncConfig.bindings).length) {
+            useBindings = true;
+            bindingNames = Object.keys(docsSyncConfig.bindings);
+        }
+        if (useBindings && (!docsSyncHome || !docsSyncConfig)) {
+            console.error("missing .yapi/docs-sync.json (run docs-sync bind add or use --dir)");
+            return 2;
+        }
+        if (useBindings && !bindingNames.length) {
+            console.error("no docs-sync bindings found (run docs-sync bind add or use --dir)");
+            return 2;
+        }
+        const dirs = useBindings ? [] : options.dirs.length ? options.dirs : ["docs/release-notes"];
+        let config = {};
+        let configPath = options.config || "";
+        if (options.config) {
+            if (fs_1.default.existsSync(configPath)) {
+                config = parseSimpleToml(fs_1.default.readFileSync(configPath, "utf8"));
+            }
+            else {
+                const init = await initConfigIfMissing(options);
+                if (init) {
+                    config = init.config;
+                    configPath = init.configPath;
+                }
+                else {
+                    console.error(`missing config file: ${configPath}`);
+                    return 2;
+                }
+            }
+        }
+        else {
+            const globalPath = globalConfigPath();
+            if (fs_1.default.existsSync(globalPath)) {
+                configPath = globalPath;
+                config = parseSimpleToml(fs_1.default.readFileSync(globalPath, "utf8"));
+            }
+            else {
+                const init = await initConfigIfMissing(options);
+                if (init) {
+                    config = init.config;
+                    configPath = init.configPath;
+                }
+                else {
+                    console.error("missing config: create ~/.yapi/config.toml or pass --config");
+                    return 2;
+                }
+            }
+        }
+        const baseUrl = options.baseUrl || config.base_url || "";
+        if (!baseUrl) {
+            console.error("missing --base-url or config base_url");
+            return 2;
+        }
+        const projectId = options.projectId || config.project_id || "";
+        const rawToken = options.token || config.token || "";
+        const token = resolveToken(rawToken, projectId);
+        let authMode = (options.authMode || config.auth_mode || "").trim().toLowerCase();
+        if (!authMode) {
+            authMode = token
+                ? "token"
+                : (options.email || options.password || config.email || config.password)
+                    ? "global"
+                    : "token";
+        }
+        if (authMode !== "token" && authMode !== "global") {
+            console.error("invalid --auth-mode (use token or global)");
+            return 2;
+        }
+        const headers = {};
+        const email = options.email || config.email || "";
+        const password = options.password || config.password || "";
+        const authService = authMode === "global"
+            ? new auth_1.YApiAuthService(baseUrl, email || "", password || "", "warn", { timeoutMs: options.timeout || 30000 })
+            : null;
+        const canRelogin = authMode === "global" && Boolean(authService) && Boolean(email) && Boolean(password) && !options.cookie;
+        if (options.cookie) {
+            headers.Cookie = options.cookie;
+        }
+        else if (authMode === "global") {
+            const cachedCookie = authService?.getCachedCookieHeader();
+            if (cachedCookie) {
+                headers.Cookie = cachedCookie;
+            }
+            else if (email && password && authService) {
+                try {
+                    headers.Cookie = await authService.getCookieHeaderWithLogin();
+                }
+                catch (error) {
+                    console.error(error instanceof Error ? error.message : String(error));
+                    return 2;
+                }
+            }
+            else {
+                console.error("missing email/password for global auth");
+                return 2;
+            }
+        }
+        const request = async (endpoint, method, query = {}, data) => {
+            const queryItems = [];
+            for (const [key, value] of Object.entries(query)) {
+                if (value !== undefined && value !== null) {
+                    queryItems.push([key, String(value)]);
+                }
+            }
+            const url = buildUrl(baseUrl, endpoint, queryItems, authMode === "token" ? token : "", options.tokenParam || "token");
+            let body;
+            if (data !== undefined) {
+                body = JSON.stringify(data);
+            }
+            const sendOnce = async () => {
+                const requestHeaders = { ...headers };
+                if (body !== undefined) {
+                    requestHeaders["Content-Type"] = "application/json;charset=UTF-8";
+                }
+                const response = await fetchWithTimeout(url, {
+                    method,
+                    headers: requestHeaders,
+                    body,
+                }, options.timeout || 30000);
+                const text = await response.text();
+                return { response, text, json: parseJsonMaybe(text) };
+            };
+            let result = await sendOnce();
+            if (canRelogin && looksLikeAuthError(result.response.status, result.json)) {
+                try {
+                    headers.Cookie = await authService.getCookieHeaderWithLogin({ forceLogin: true });
+                }
+                catch (error) {
+                    throw new Error(error instanceof Error ? error.message : String(error));
+                }
+                result = await sendOnce();
+            }
+            if (!result.response.ok) {
+                throw new Error(`request failed: ${result.response.status} ${result.response.statusText} ${result.text}`);
+            }
+            if (!result.json) {
+                throw new Error(`invalid JSON response from ${endpoint}`);
+            }
+            return result.json;
+        };
+        if (useBindings) {
+            const rootDir = path_1.default.dirname(docsSyncHome);
+            const configForBindings = docsSyncConfig;
+            for (const name of bindingNames) {
+                const binding = configForBindings.bindings[name];
+                if (!binding) {
+                    throw new Error(`binding not found: ${name}`);
+                }
+                const dirPath = resolveBindingDir(rootDir, binding.dir);
+                if (!fs_1.default.existsSync(dirPath) || !fs_1.default.statSync(dirPath).isDirectory()) {
+                    throw new Error(`dir not found for binding ${name}: ${dirPath}`);
+                }
+                const result = await syncDocsDir(dirPath, binding, options, request);
+                console.log(`synced=${result.updated} created=${result.created} binding=${name} dir=${dirPath}`);
+            }
+            if (!options.dryRun) {
+                saveDocsSyncConfig(docsSyncHome, configForBindings);
+            }
+        }
+        else {
+            for (const dir of dirs) {
+                const dirPath = path_1.default.resolve(dir);
+                if (!fs_1.default.existsSync(dirPath) || !fs_1.default.statSync(dirPath).isDirectory()) {
+                    throw new Error(`dir not found: ${dirPath}`);
+                }
+                const { mapping, mappingPath } = loadMapping(dirPath);
+                const result = await syncDocsDir(dirPath, mapping, options, request);
+                if (!options.dryRun) {
+                    saveMapping(mapping, mappingPath);
+                }
+                console.log(`synced=${result.updated} created=${result.created} dir=${dirPath}`);
+            }
+        }
+        return 0;
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        return 2;
+    }
+}
+async function main() {
+    const rawArgs = process.argv.slice(2);
+    if (rawArgs[0] === "install-skill") {
+        await (0, install_1.runInstallSkill)(rawArgs.slice(1));
+        return 0;
+    }
+    if (rawArgs[0] === "login") {
+        return await runLogin(rawArgs.slice(1));
+    }
+    if (rawArgs[0] === "docs-sync") {
+        return await runDocsSync(rawArgs.slice(1));
+    }
+    const options = parseArgs(rawArgs);
+    if (options.version) {
+        console.log(readVersion());
+        return 0;
+    }
+    if (options.help) {
+        console.log(usage());
+        return 0;
+    }
+    if (options.url && options.path) {
+        console.error("use --url or --path, not both");
+        return 2;
+    }
+    if (!options.url && !options.path) {
+        console.error("missing --path or --url");
+        console.error(usage());
+        return 2;
+    }
+    let config = {};
+    let configPath = options.config || "";
+    if (options.config) {
+        if (fs_1.default.existsSync(configPath)) {
+            config = parseSimpleToml(fs_1.default.readFileSync(configPath, "utf8"));
+        }
+        else {
+            const init = await initConfigIfMissing(options);
+            if (init) {
+                config = init.config;
+                configPath = init.configPath;
+            }
+            else {
+                console.error(`missing config file: ${configPath}`);
+                return 2;
+            }
+        }
+    }
+    else {
+        const globalPath = globalConfigPath();
+        if (fs_1.default.existsSync(globalPath)) {
+            configPath = globalPath;
+            config = parseSimpleToml(fs_1.default.readFileSync(globalPath, "utf8"));
+        }
+        else {
+            const init = await initConfigIfMissing(options);
+            if (init) {
+                config = init.config;
+                configPath = init.configPath;
+            }
+            else {
+                console.error("missing config: create ~/.yapi/config.toml or pass --config");
+                return 2;
+            }
+        }
+    }
+    const authBaseUrl = options.baseUrl || config.base_url || "";
+    const baseUrl = options.url ? null : authBaseUrl;
+    const endpoint = options.url || options.path || "";
+    if (!options.url && !baseUrl) {
+        console.error("missing --base-url or config base_url");
+        return 2;
+    }
+    const projectId = options.projectId || config.project_id || "";
+    const rawToken = options.token || config.token || "";
+    const token = resolveToken(rawToken, projectId);
+    let authMode = (options.authMode || config.auth_mode || "").trim().toLowerCase();
+    if (!authMode) {
+        authMode = token ? "token" : (options.email || options.password || config.email || config.password) ? "global" : "token";
+    }
+    if (authMode !== "token" && authMode !== "global") {
+        console.error("invalid --auth-mode (use token or global)");
+        return 2;
+    }
+    if (authMode === "global" && !authBaseUrl) {
+        console.error("missing --base-url or config base_url for global auth");
+        return 2;
+    }
+    const headers = {};
+    for (const header of options.header || []) {
+        const [key, value] = parseHeader(header);
+        headers[key] = value;
+    }
+    const email = options.email || config.email || "";
+    const password = options.password || config.password || "";
+    const authService = authMode === "global"
+        ? new auth_1.YApiAuthService(authBaseUrl, email || "", password || "", "warn", { timeoutMs: options.timeout || 30000 })
+        : null;
+    const canRelogin = authMode === "global" && Boolean(authService) && Boolean(email) && Boolean(password) && !options.cookie;
+    if (options.cookie) {
+        headers.Cookie = options.cookie;
+    }
+    else if (authMode === "global") {
+        const cachedCookie = authService?.getCachedCookieHeader();
+        if (cachedCookie) {
+            headers.Cookie = cachedCookie;
+        }
+        else if (email && password && authService) {
+            try {
+                headers.Cookie = await authService.getCookieHeaderWithLogin();
+            }
+            catch (error) {
+                console.error(error instanceof Error ? error.message : String(error));
+                return 2;
+            }
+        }
+        else {
+            console.error("missing email/password for global auth");
+            return 2;
+        }
+    }
+    const queryItems = [];
+    for (const query of options.query || []) {
+        queryItems.push(parseKeyValue(query));
+    }
+    const url = buildUrl(baseUrl, endpoint, queryItems, authMode === "token" ? token : "", options.tokenParam || "token");
+    let dataRaw = null;
+    if (options.dataFile) {
+        dataRaw = fs_1.default.readFileSync(options.dataFile, "utf8");
+    }
+    else if (options.data !== undefined) {
+        dataRaw = options.data;
+    }
+    let body;
+    const method = (options.method || "GET").toUpperCase();
+    if (dataRaw !== null && method !== "GET" && method !== "HEAD") {
+        try {
+            const parsed = JSON.parse(dataRaw);
+            body = JSON.stringify(parsed);
+            if (!headers["Content-Type"])
+                headers["Content-Type"] = "application/json";
+        }
+        catch {
+            body = String(dataRaw);
+            if (!headers["Content-Type"])
+                headers["Content-Type"] = "text/plain";
+        }
+    }
+    const sendOnce = async () => {
+        const response = await fetchWithTimeout(url, {
+            method,
+            headers,
+            body,
+        }, options.timeout || 30000);
+        const text = await response.text();
+        return { response, text, json: parseJsonMaybe(text) };
+    };
+    let result;
+    try {
+        result = await sendOnce();
+    }
+    catch (error) {
+        console.error("request failed: " + (error instanceof Error ? error.message : String(error)));
+        return 2;
+    }
+    if (canRelogin && looksLikeAuthError(result.response.status, result.json)) {
+        try {
+            headers.Cookie = await authService.getCookieHeaderWithLogin({ forceLogin: true });
+            result = await sendOnce();
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            return 2;
+        }
+    }
+    const { text } = result;
+    if (options.noPretty) {
+        console.log(text);
+        return 0;
+    }
+    try {
+        const payload = result.json ?? JSON.parse(text);
+        console.log(JSON.stringify(payload, null, 2));
+    }
+    catch {
+        console.log(text);
+    }
+    return 0;
+}
+main().then((code) => {
+    process.exitCode = code;
+});
+//# sourceMappingURL=yapi-cli.js.map