yingmi-skill-cli 0.0.1

package/bin/index.js

@@ -0,0 +1,1349 @@
+#!/usr/bin/env node
+
+'use strict';
+
+var commander = require('commander');
+var fs = require('fs');
+var os = require('os');
+var path = require('path');
+var axios = require('axios');
+var puppeteer = require('puppeteer');
+var crypto = require('crypto');
+var child_process = require('child_process');
+
+var name = "yingmi-cli";
+var version = "0.0.10";
+
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+function resolveCommand(root, pathSegments) {
+  let current = root;
+  pathSegments.forEach((segment) => {
+    current = current?.commands.find((command) => command.name() === segment);
+  });
+  return current;
+}
+function registerHelpCommand(program) {
+  program.command("help").description("\u663E\u793A CLI \u6216\u6307\u5B9A\u5B50\u547D\u4EE4\u7684\u5E2E\u52A9\u4FE1\u606F").argument("[commandPath...]", "\u547D\u4EE4\u8DEF\u5F84\uFF0C\u4F8B\u5982: mcp call").action((commandPath) => {
+    if (!commandPath || commandPath.length === 0) {
+      program.outputHelp();
+      return;
+    }
+    const targetCommand = resolveCommand(program, commandPath);
+    if (!targetCommand) {
+      fail(`\u672A\u627E\u5230\u547D\u4EE4: ${commandPath.join(" ")}`);
+    }
+    targetCommand.outputHelp();
+  });
+}
+
+const CONFIG_DIR = path.join(os.homedir(), ".yingmi-cli");
+const CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+const SKILLS_DIR = path.join(CONFIG_DIR, "skills");
+const DEFAULT_QIEMAN_BASE_URL = "https://qieman.com";
+const DEFAULT_REMOTE_SKILL_SERVER_BASE_URL = "https://stargate-staging.yingmi-inc.com/";
+function ensureConfigDir() {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+function readConfig() {
+  ensureConfigDir();
+  if (!fs.existsSync(CONFIG_FILE)) {
+    return {};
+  }
+  const content = fs.readFileSync(CONFIG_FILE, "utf8").trim();
+  if (!content) {
+    return {};
+  }
+  const parsed = JSON.parse(content);
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("\u914D\u7F6E\u6587\u4EF6\u683C\u5F0F\u975E\u6CD5\uFF0C\u8BF7\u68C0\u67E5 ~/.yingmi-cli/config.json");
+  }
+  return parsed;
+}
+function writeConfig(config) {
+  ensureConfigDir();
+  fs.writeFileSync(CONFIG_FILE, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+function setApiKey(apiKey) {
+  const nextConfig = {
+    ...readConfig(),
+    apiKey
+  };
+  writeConfig(nextConfig);
+}
+function getApiKeyApplySession() {
+  return readConfig().apiKeyApplySession;
+}
+function setApiKeyApplySession(session) {
+  const nextConfig = {
+    ...readConfig(),
+    apiKeyApplySession: session
+  };
+  writeConfig(nextConfig);
+}
+function clearApiKeyApplySession() {
+  const nextConfig = {
+    ...readConfig()
+  };
+  delete nextConfig.apiKeyApplySession;
+  writeConfig(nextConfig);
+}
+function getCurrentRemoteSkillSession() {
+  return readConfig().currentRemoteSkillSession;
+}
+function setCurrentRemoteSkillSession(session) {
+  const nextConfig = {
+    ...readConfig(),
+    currentRemoteSkillSession: session
+  };
+  writeConfig(nextConfig);
+}
+function maskSecret(value) {
+  if (!value) {
+    return "(\u672A\u8BBE\u7F6E)";
+  }
+  if (value.length <= 8) {
+    return `${value.slice(0, 2)}***${value.slice(-2)}`;
+  }
+  return `${value.slice(0, 4)}***${value.slice(-4)}`;
+}
+function getConfigFilePath() {
+  return CONFIG_FILE;
+}
+function getSkillsDirPath() {
+  ensureConfigDir();
+  fs.mkdirSync(SKILLS_DIR, { recursive: true });
+  return SKILLS_DIR;
+}
+function getRemoteSkillServerBaseUrl() {
+  const configuredBaseUrl = readConfig().remoteSkillServerBaseUrl?.trim();
+  return configuredBaseUrl || DEFAULT_REMOTE_SKILL_SERVER_BASE_URL;
+}
+function getQiemanBaseUrl() {
+  const configuredBaseUrl = readConfig().qiemanBaseUrl?.trim();
+  return configuredBaseUrl || DEFAULT_QIEMAN_BASE_URL;
+}
+
+function validatePhone(phone) {
+  if (!/^1\d{10}$/.test(phone)) {
+    throw new Error("\u624B\u673A\u53F7\u683C\u5F0F\u975E\u6CD5\uFF0C\u8BF7\u4F20\u5165 11 \u4F4D\u4E2D\u56FD\u5927\u9646\u624B\u673A\u53F7");
+  }
+}
+function validateXSign(xSign) {
+  if (!/^\d+[A-Fa-f0-9]{40}$/.test(xSign)) {
+    throw new Error("x-sign \u683C\u5F0F\u975E\u6CD5\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C\u521D\u59CB\u5316\u6D41\u7A0B");
+  }
+}
+function validateVerifyCode(verifyCode) {
+  if (!/^\d{4,8}$/.test(verifyCode)) {
+    throw new Error("\u9A8C\u8BC1\u7801\u683C\u5F0F\u975E\u6CD5\uFF0C\u8BF7\u4F20\u5165 4 \u5230 8 \u4F4D\u6570\u5B57\u9A8C\u8BC1\u7801");
+  }
+}
+function maskPhone(phone) {
+  return phone.replace(/^(\d{3})\d{4}(\d{4})$/, "$1****$2");
+}
+function extractApiKey(response) {
+  const apiKey = response.key ?? response.apiKey;
+  return typeof apiKey === "string" && apiKey.trim() ? apiKey.trim() : void 0;
+}
+
+function getInitStatusSummary() {
+  const config = readConfig();
+  const session = getApiKeyApplySession();
+  return {
+    configFile: getConfigFilePath(),
+    hasApiKey: Boolean(config.apiKey),
+    apiKey: maskSecret(config.apiKey),
+    hasPendingSession: Boolean(session),
+    pendingPhone: session?.phone ? maskPhone(session.phone) : null
+  };
+}
+
+function getErrorMessage(error) {
+  if (error instanceof axios.AxiosError) {
+    const status = error.response?.status;
+    const data = error.response?.data;
+    const detail = data?.msg?.trim() || data?.detail?.msg?.trim() || error.message || "\u672A\u77E5\u9519\u8BEF";
+    return `\u8BF7\u6C42\u5931\u8D25${status ? ` (${status})` : ""}: ${detail}`;
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+function isInvalidVerifyCodeError(error) {
+  if (!(error instanceof axios.AxiosError)) {
+    return false;
+  }
+  const data = error.response?.data;
+  const errorCode = data?.code ?? data?.detail?.code;
+  const errorMessage = data?.msg ?? data?.detail?.msg ?? "";
+  return errorCode === "8602" || errorMessage.includes("\u77ED\u4FE1\u9A8C\u8BC1\u7801\u6709\u8BEF");
+}
+
+function runInitDoctorChecks() {
+  const checks = [
+    {
+      name: "node",
+      status: "ok",
+      message: `\u5F53\u524D Node.js \u7248\u672C: ${process.version}`
+    }
+  ];
+  try {
+    const status = getInitStatusSummary();
+    checks.push({
+      name: "config-file",
+      status: "ok",
+      message: `\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84\u5DF2\u89E3\u6790: ${status.configFile}`
+    });
+    checks.push(
+      status.hasApiKey ? {
+        name: "api-key",
+        status: "ok",
+        message: `\u5DF2\u914D\u7F6E apiKey: ${status.apiKey}`
+      } : {
+        name: "api-key",
+        status: "warning",
+        message: "\u5C1A\u672A\u914D\u7F6E apiKey",
+        nextStep: "\u6267\u884C yingmi-cli init setup --api-key <your-api-key> \u6216\u9A8C\u8BC1\u7801\u521D\u59CB\u5316\u6D41\u7A0B"
+      }
+    );
+    if (status.hasPendingSession && status.pendingPhone) {
+      checks.push({
+        name: "pending-session",
+        status: "warning",
+        message: `\u5B58\u5728\u5F85\u5B8C\u6210\u7684\u9A8C\u8BC1\u7801\u767B\u5F55\u4E0A\u4E0B\u6587: ${status.pendingPhone}`,
+        nextStep: "\u6267\u884C yingmi-cli init setup --verify-code <\u9A8C\u8BC1\u7801> \u5B8C\u6210\u521D\u59CB\u5316"
+      });
+    } else {
+      checks.push({
+        name: "pending-session",
+        status: "ok",
+        message: "\u5F53\u524D\u6CA1\u6709\u5F85\u5B8C\u6210\u7684\u9A8C\u8BC1\u7801\u767B\u5F55\u4E0A\u4E0B\u6587"
+      });
+    }
+  } catch (error) {
+    checks.push({
+      name: "config-read",
+      status: "warning",
+      message: `\u8BFB\u53D6\u914D\u7F6E\u5931\u8D25: ${getErrorMessage(error)}`,
+      nextStep: "\u68C0\u67E5 ~/.yingmi-cli/config.json \u683C\u5F0F\uFF0C\u5FC5\u8981\u65F6\u4FEE\u590D\u540E\u91CD\u8BD5"
+    });
+  }
+  return {
+    status: checks.some((check) => check.status === "warning") ? "warning" : "ok",
+    nodeVersion: process.version,
+    configFile: getConfigFilePath(),
+    checks
+  };
+}
+
+function getPendingSetupResult() {
+  return {
+    status: "pending",
+    setupMode: "guided",
+    configFile: getConfigFilePath(),
+    availableActions: ["--api-key <value>", "--phone <value>", "--verify-code <value>"],
+    nextSteps: [
+      "yingmi-cli init setup --api-key <your-api-key>",
+      "yingmi-cli init setup --phone <your-phone>",
+      "yingmi-cli init setup --verify-code <\u9A8C\u8BC1\u7801>"
+    ]
+  };
+}
+
+function getHeaderValue(headers, headerName) {
+  const expectedHeaderName = headerName.toLowerCase();
+  const matchedEntry = Object.entries(headers).find(
+    ([currentHeaderName]) => currentHeaderName.toLowerCase() === expectedHeaderName
+  );
+  return matchedEntry?.[1];
+}
+function waitForFirstFetchRequest(page, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const cleanup = () => {
+      clearTimeout(timer);
+      page.off("request", handleRequest);
+    };
+    const settle = (callback) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      cleanup();
+      callback();
+    };
+    const handleRequest = (request) => {
+      if (request.resourceType() !== "fetch") {
+        return;
+      }
+      settle(() => resolve(request));
+    };
+    const timer = setTimeout(() => {
+      settle(() => reject(new Error(`\u5728 ${timeoutMs}ms \u5185\u672A\u6355\u83B7\u5230 fetch \u8BF7\u6C42`)));
+    }, timeoutMs);
+    page.on("request", handleRequest);
+  });
+}
+
+function getCandidateExecutablePaths() {
+  const homeDirectory = os.homedir();
+  switch (process.platform) {
+    case "darwin":
+      return [
+        "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+        "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+        "/Applications/Chromium.app/Contents/MacOS/Chromium"
+      ];
+    case "win32":
+      return [
+        "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+        "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+        "C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe",
+        "C:\\Program Files (x86)\\Microsoft\\Edge\\Application\\msedge.exe"
+      ];
+    default:
+      return [
+        "/usr/bin/google-chrome",
+        "/usr/bin/google-chrome-stable",
+        "/usr/bin/chromium",
+        "/usr/bin/chromium-browser",
+        `${homeDirectory}/.cache/puppeteer/chrome/linux-*/chrome-linux64/chrome`
+      ];
+  }
+}
+function resolveExecutablePath(executablePath) {
+  const customExecutablePath = executablePath?.trim() || process.env.PUPPETEER_EXECUTABLE_PATH?.trim();
+  if (customExecutablePath) {
+    if (!fs.existsSync(customExecutablePath)) {
+      throw new Error(`\u6D4F\u89C8\u5668\u4E0D\u5B58\u5728: ${customExecutablePath}`);
+    }
+    return customExecutablePath;
+  }
+  const matchedPath = getCandidateExecutablePaths().find(
+    (candidatePath) => fs.existsSync(candidatePath)
+  );
+  if (!matchedPath) {
+    throw new Error(
+      "\u672A\u627E\u5230\u53EF\u7528\u7684 Chrome/Chromium\uFF0C\u53EF\u901A\u8FC7 --executable-path \u6216 PUPPETEER_EXECUTABLE_PATH \u6307\u5B9A\u6D4F\u89C8\u5668\u8DEF\u5F84"
+    );
+  }
+  return matchedPath;
+}
+
+const DEFAULT_TIMEOUT_MS = 2e4;
+async function getXSign(options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const browser = await puppeteer.launch({
+    executablePath: resolveExecutablePath(options.executablePath),
+    headless: options.headless ?? true,
+    args: ["--no-sandbox", "--disable-setuid-sandbox"]
+  });
+  try {
+    const page = await browser.newPage();
+    const firstFetchRequestPromise = waitForFirstFetchRequest(page, timeoutMs);
+    const url = options.url ?? getQiemanBaseUrl();
+    await page.goto(url, {
+      waitUntil: "domcontentloaded",
+      timeout: timeoutMs
+    });
+    const firstFetchRequest = await firstFetchRequestPromise;
+    const xSign = getHeaderValue(firstFetchRequest.headers(), "x-sign")?.trim();
+    if (!xSign) {
+      throw new Error(`\u9996\u4E2A fetch \u8BF7\u6C42\u672A\u643A\u5E26 x-sign: ${firstFetchRequest.url()}`);
+    }
+    return xSign;
+  } finally {
+    await browser.close();
+  }
+}
+
+function trimTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+function getQiemanPmdjBaseUrl() {
+  return `${trimTrailingSlash(getQiemanBaseUrl())}/pmdj/v1`;
+}
+const API_KEY_APPLICATION_PAYLOAD = {
+  name: "CLI\u7533\u8BF7\u7684\u5360\u4F4D\u7B26",
+  organization: "CLI\u7533\u8BF7\u7684\u5360\u4F4D\u7B26",
+  email: "",
+  usagePurposes: ["\u63A2\u7D22\u66F4\u591A\u5408\u4F5C\u53EF\u80FD"],
+  usageDescription: "",
+  agreementIds: ["AGREEMENT34-V20250425"],
+  positionId: "user_position_other",
+  position: "CLI\u7533\u8BF7\u7684\u5360\u4F4D\u7B26",
+  organizationType: "\u5176\u4ED6"
+};
+
+function createRequestId() {
+  const hexTimestamp = Date.now().toString(16).toUpperCase();
+  const randomSuffix = crypto.randomBytes(8).toString("hex").toUpperCase();
+  return `yingmi-cli.${hexTimestamp}${randomSuffix}`;
+}
+function getHeaders(xSign, accessToken) {
+  return {
+    accept: "application/json",
+    "content-type": "application/json",
+    "x-request-id": createRequestId(),
+    "x-sign": xSign,
+    ...accessToken ? { authorization: `Bearer ${accessToken}` } : {}
+  };
+}
+
+async function prepareSmsSetup(phone) {
+  validatePhone(phone);
+  const qiemanPmdjBaseUrl = getQiemanPmdjBaseUrl();
+  const xSign = await getXSign();
+  validateXSign(xSign);
+  const response = await axios.post(
+    `${qiemanPmdjBaseUrl}/user/register/phone/prepare`,
+    { phone },
+    {
+      headers: getHeaders(xSign),
+      timeout: 2e4
+    }
+  );
+  if (!response.data.token) {
+    throw new Error("\u83B7\u53D6\u9A8C\u8BC1\u7801\u6210\u529F\uFF0C\u4F46\u54CD\u5E94\u4E2D\u7F3A\u5C11 token\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5");
+  }
+  setApiKeyApplySession({
+    phone,
+    xSign,
+    prepareToken: response.data.token,
+    requestedAt: Date.now()
+  });
+  return {
+    status: "code_sent",
+    setupMode: "sms_prepare",
+    configFile: getConfigFilePath(),
+    pendingPhone: maskPhone(phone),
+    cooldownSeconds: response.data.nextInSec ?? null,
+    nextStep: "yingmi-cli init setup --verify-code <\u9A8C\u8BC1\u7801>"
+  };
+}
+
+async function setupWithApiKey(apiKey) {
+  setApiKey(apiKey);
+  return {
+    status: "configured",
+    setupMode: "direct_api_key",
+    apiKey: maskSecret(apiKey),
+    configFile: getConfigFilePath()
+  };
+}
+
+async function refreshSessionXSignOnInvalidVerifyCode(session) {
+  if (!session) {
+    return;
+  }
+  const nextXSign = await getXSign();
+  validateXSign(nextXSign);
+  setApiKeyApplySession({
+    ...session,
+    xSign: nextXSign
+  });
+}
+
+async function confirmSmsSetup(verifyCode) {
+  validateVerifyCode(verifyCode);
+  const session = getApiKeyApplySession();
+  if (!session) {
+    throw new Error("\u672A\u627E\u5230\u9A8C\u8BC1\u7801\u767B\u5F55\u4E0A\u4E0B\u6587\uFF0C\u8BF7\u5148\u6267\u884C: yingmi-cli init setup --phone <\u624B\u673A\u53F7>");
+  }
+  if (!session.accessToken && !session.prepareToken) {
+    throw new Error("\u7533\u8BF7\u4E0A\u4E0B\u6587\u7F3A\u5C11\u767B\u5F55 token\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C: yingmi-cli init setup --phone <\u624B\u673A\u53F7>");
+  }
+  try {
+    const qiemanPmdjBaseUrl = getQiemanPmdjBaseUrl();
+    let accessToken = session.accessToken;
+    if (!accessToken) {
+      const confirmResponse = await axios.post(
+        `${qiemanPmdjBaseUrl}/user/register/phone/confirm`,
+        {
+          phone: session.phone,
+          poManagerName: null,
+          token: session.prepareToken,
+          verifyCode,
+          autoLogin: true
+        },
+        {
+          headers: getHeaders(session.xSign),
+          timeout: 2e4
+        }
+      );
+      accessToken = confirmResponse.data.accessToken?.trim();
+      if (!accessToken) {
+        throw new Error("\u786E\u8BA4\u767B\u5F55\u6210\u529F\uFF0C\u4F46\u54CD\u5E94\u4E2D\u7F3A\u5C11 accessToken\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5");
+      }
+      setApiKeyApplySession({
+        ...session,
+        accessToken
+      });
+    }
+    const currentApplicationResponse = await axios.get(
+      `${qiemanPmdjBaseUrl}/stargate/api-key-application`,
+      {
+        headers: getHeaders(session.xSign, accessToken),
+        timeout: 2e4
+      }
+    );
+    let apiKey = extractApiKey(currentApplicationResponse.data);
+    if (!apiKey) {
+      const hasExistingApplication = Object.keys(currentApplicationResponse.data ?? {}).length > 0;
+      if (hasExistingApplication) {
+        throw new Error(
+          `\u5DF2\u5B58\u5728 API Key \u7533\u8BF7\u8BB0\u5F55\uFF0C\u4F46\u54CD\u5E94\u4E2D\u672A\u8FD4\u56DE key\uFF0C\u5F53\u524D\u72B6\u6001: ${currentApplicationResponse.data.status ?? "unknown"}`
+        );
+      }
+      const applyResponse = await axios.post(
+        `${qiemanPmdjBaseUrl}/stargate/api-key-application`,
+        API_KEY_APPLICATION_PAYLOAD,
+        {
+          headers: getHeaders(session.xSign, accessToken),
+          timeout: 2e4
+        }
+      );
+      apiKey = extractApiKey(applyResponse.data);
+    }
+    if (!apiKey) {
+      throw new Error("API Key \u7533\u8BF7\u6210\u529F\uFF0C\u4F46\u54CD\u5E94\u4E2D\u7F3A\u5C11 key\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5");
+    }
+    setApiKey(apiKey);
+    clearApiKeyApplySession();
+    return {
+      status: "configured",
+      setupMode: "sms_confirm",
+      apiKey: maskSecret(apiKey),
+      configFile: getConfigFilePath()
+    };
+  } catch (error) {
+    if (isInvalidVerifyCodeError(error)) {
+      try {
+        await refreshSessionXSignOnInvalidVerifyCode(session);
+      } catch (refreshError) {
+        throw new Error(
+          `\u9A8C\u8BC1\u7801\u6821\u9A8C\u5931\u8D25\uFF0C\u5237\u65B0 x-sign \u4E5F\u5931\u8D25\u4E86: ${getErrorMessage(refreshError)}\u3002\u8BF7\u91CD\u65B0\u6267\u884C: yingmi-cli init setup --phone <\u624B\u673A\u53F7>`
+        );
+      }
+    }
+    throw new Error(getErrorMessage(error));
+  }
+}
+
+function countSetupModes(options) {
+  return [options.apiKey, options.phone, options.verifyCode].filter(Boolean).length;
+}
+function persistHiddenConfigOptions(options) {
+  const remoteSkillServerBaseUrl = options.remoteSkillServerBaseUrl?.trim();
+  const qiemanBaseUrl = options.qiemanBaseUrl?.trim();
+  if (!remoteSkillServerBaseUrl && !qiemanBaseUrl) {
+    return;
+  }
+  writeConfig({
+    ...readConfig(),
+    ...remoteSkillServerBaseUrl ? { remoteSkillServerBaseUrl } : {},
+    ...qiemanBaseUrl ? { qiemanBaseUrl } : {}
+  });
+}
+async function runInitSetup(options) {
+  const apiKey = options.apiKey?.trim();
+  const phone = options.phone?.trim();
+  const qiemanBaseUrl = options.qiemanBaseUrl?.trim();
+  const remoteSkillServerBaseUrl = options.remoteSkillServerBaseUrl?.trim();
+  const verifyCode = options.verifyCode?.trim();
+  persistHiddenConfigOptions({
+    remoteSkillServerBaseUrl,
+    qiemanBaseUrl
+  });
+  if (countSetupModes({ apiKey, phone, verifyCode }) > 1) {
+    throw new Error("`--api-key`\u3001`--phone`\u3001`--verify-code` \u4E00\u6B21\u53EA\u80FD\u4F7F\u7528\u4E00\u79CD\uFF0C\u8BF7\u6309\u521D\u59CB\u5316\u9636\u6BB5\u5206\u522B\u6267\u884C");
+  }
+  if (apiKey) {
+    return setupWithApiKey(apiKey);
+  }
+  if (phone) {
+    return prepareSmsSetup(phone);
+  }
+  if (verifyCode) {
+    return confirmSmsSetup(verifyCode);
+  }
+  return getPendingSetupResult();
+}
+
+function registerDoctorCommand(initCommand) {
+  initCommand.command("doctor").description("\u68C0\u67E5\u672C\u5730\u914D\u7F6E\u4E0E\u8FD0\u884C\u73AF\u5883").action(() => {
+    console.log(JSON.stringify(runInitDoctorChecks(), null, 2));
+  });
+}
+
+function registerSetupCommand(initCommand) {
+  initCommand.command("setup").description("\u6267\u884C\u9996\u6B21\u521D\u59CB\u5316\uFF0C\u652F\u6301\u76F4\u63A5\u5199\u5165 API Key \u6216\u9A8C\u8BC1\u7801\u7533\u8BF7 API Key").option("--api-key <value>", "\u76F4\u63A5\u5199\u5165 StarGate API Key").option("--phone <value>", "\u901A\u8FC7\u624B\u673A\u53F7\u53D1\u8D77\u9A8C\u8BC1\u7801\u521D\u59CB\u5316").option("--verify-code <value>", "\u786E\u8BA4\u77ED\u4FE1\u9A8C\u8BC1\u7801\u5E76\u5B8C\u6210 API Key \u521D\u59CB\u5316").addOption(
+    new commander.Option("--remote-skill-server-base-url <value>", "\u8986\u76D6 remote-skill \u670D\u52A1\u57FA\u5730\u5740").hideHelp()
+  ).addOption(new commander.Option("--qieman-base-url <value>", "\u8986\u76D6\u4E14\u6162\u670D\u52A1\u57FA\u5730\u5740").hideHelp()).action(async (options) => {
+    try {
+      const result = await runInitSetup(options);
+      console.log(JSON.stringify(result, null, 2));
+    } catch (error) {
+      fail(error.message);
+    }
+  });
+}
+
+function registerStatusCommand(initCommand) {
+  initCommand.command("status").description("\u67E5\u770B\u521D\u59CB\u5316\u72B6\u6001\u548C\u914D\u7F6E\u6458\u8981").action(() => {
+    console.log(JSON.stringify(getInitStatusSummary(), null, 2));
+  });
+}
+
+function registerInitCommand(program) {
+  const initCommand = program.command("init").description("\u521D\u59CB\u5316 CLI \u5E76\u67E5\u770B\u5F53\u524D\u72B6\u6001");
+  registerSetupCommand(initCommand);
+  registerStatusCommand(initCommand);
+  registerDoctorCommand(initCommand);
+}
+
+function buildRequestPath(pathTemplate, pathValues) {
+  return pathTemplate.replace(/\{([^}]+)\}/g, (_, key) => {
+    const value = pathValues[key];
+    if (value === void 0) {
+      throw new Error(`\u7F3A\u5C11 path \u53C2\u6570: ${key}`);
+    }
+    return encodeURIComponent(String(value));
+  });
+}
+
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function readJsonInput(input, inputFile) {
+  if (input && inputFile) {
+    fail("--input \u548C --input-file \u4E0D\u80FD\u540C\u65F6\u4F7F\u7528");
+  }
+  if (!input && !inputFile) {
+    return {};
+  }
+  const raw = inputFile ? fs.readFileSync(inputFile, "utf8") : input;
+  try {
+    return JSON.parse(raw ?? "{}");
+  } catch (error) {
+    fail(`\u8F93\u5165\u4E0D\u662F\u5408\u6CD5 JSON: ${error.message}`);
+  }
+}
+
+function requireApiKey() {
+  const { apiKey } = readConfig();
+  if (!apiKey) {
+    fail(
+      "\u672A\u914D\u7F6E apiKey\uFF0C\u8BF7\u5148\u6267\u884C: yingmi-cli init setup --api-key <your-api-key>\uFF0C\u6216\u5148\u7528 yingmi-cli init setup --phone <\u624B\u673A\u53F7> \u5B8C\u6210\u9A8C\u8BC1\u7801\u521D\u59CB\u5316"
+    );
+  }
+  return apiKey;
+}
+
+function getParametersByLocation(operation, location) {
+  return operation.parameters.filter((parameter) => parameter.in === location);
+}
+function splitInput(operation, rawInput) {
+  if (!isPlainObject(rawInput)) {
+    if (operation.requestBody && operation.parameters.length === 0) {
+      return {
+        path: {},
+        query: {},
+        header: {},
+        body: rawInput
+      };
+    }
+    fail("\u8C03\u7528\u8F93\u5165\u5FC5\u987B\u662F JSON \u5BF9\u8C61");
+  }
+  const reservedKeys = /* @__PURE__ */ new Set(["path", "query", "header", "body"]);
+  const pathParameters = getParametersByLocation(operation, "path");
+  const queryParameters = getParametersByLocation(operation, "query");
+  const headerParameters = getParametersByLocation(operation, "header");
+  const pathValues = {
+    ...Object.fromEntries(pathParameters.map((parameter) => [parameter.name, rawInput[parameter.name]])),
+    ...isPlainObject(rawInput.path) ? rawInput.path : {}
+  };
+  const queryValues = {
+    ...Object.fromEntries(queryParameters.map((parameter) => [parameter.name, rawInput[parameter.name]])),
+    ...isPlainObject(rawInput.query) ? rawInput.query : {}
+  };
+  const headerValues = {
+    ...Object.fromEntries(
+      headerParameters.map((parameter) => [parameter.name, rawInput[parameter.name]])
+    ),
+    ...isPlainObject(rawInput.header) ? rawInput.header : {}
+  };
+  const explicitBody = Object.prototype.hasOwnProperty.call(rawInput, "body") ? rawInput.body : void 0;
+  const parameterNames = /* @__PURE__ */ new Set([
+    ...pathParameters.map((parameter) => parameter.name),
+    ...queryParameters.map((parameter) => parameter.name),
+    ...headerParameters.map((parameter) => parameter.name)
+  ]);
+  const remainingTopLevelEntries = Object.entries(rawInput).filter(
+    ([key]) => !reservedKeys.has(key) && !parameterNames.has(key)
+  );
+  let body = explicitBody;
+  if (body === void 0 && operation.requestBody) {
+    if (operation.parameters.length === 0) {
+      body = rawInput;
+    } else if (remainingTopLevelEntries.length > 0) {
+      body = Object.fromEntries(remainingTopLevelEntries);
+    }
+  }
+  return {
+    path: pathValues,
+    query: queryValues,
+    header: headerValues,
+    body
+  };
+}
+function getParametersByIn(operation, location) {
+  return getParametersByLocation(operation, location);
+}
+
+function inferSchemaType(schema) {
+  if (schema.type) {
+    return schema.type;
+  }
+  if (schema.properties || schema.required) {
+    return "object";
+  }
+  if (schema.items) {
+    return "array";
+  }
+  return void 0;
+}
+function validateSchema(schema, value, label) {
+  if (!schema || value === void 0) {
+    return;
+  }
+  if (value === null) {
+    if (schema.nullable) {
+      return;
+    }
+    throw new Error(`${label} \u4E0D\u80FD\u4E3A null`);
+  }
+  if (schema.oneOf?.length) {
+    const matches = schema.oneOf.some((candidate) => {
+      try {
+        validateSchema(candidate, value, label);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    if (!matches) {
+      throw new Error(`${label} \u4E0D\u7B26\u5408 oneOf \u7EA6\u675F`);
+    }
+    return;
+  }
+  if (schema.anyOf?.length) {
+    const matches = schema.anyOf.some((candidate) => {
+      try {
+        validateSchema(candidate, value, label);
+        return true;
+      } catch {
+        return false;
+      }
+    });
+    if (!matches) {
+      throw new Error(`${label} \u4E0D\u7B26\u5408 anyOf \u7EA6\u675F`);
+    }
+    return;
+  }
+  if (schema.enum && !schema.enum.some((item) => item === value)) {
+    throw new Error(`${label} \u4E0D\u5728\u5141\u8BB8\u7684\u679A\u4E3E\u503C\u4E2D: ${schema.enum.join(", ")}`);
+  }
+  const type = inferSchemaType(schema);
+  switch (type) {
+    case "object": {
+      if (!isPlainObject(value)) {
+        throw new Error(`${label} \u5FC5\u987B\u662F\u5BF9\u8C61`);
+      }
+      for (const requiredKey of schema.required ?? []) {
+        if (value[requiredKey] === void 0) {
+          throw new Error(`${label}.${requiredKey} \u4E3A\u5FC5\u586B\u9879`);
+        }
+      }
+      Object.entries(schema.properties ?? {}).forEach(([propertyName, propertySchema]) => {
+        validateSchema(propertySchema, value[propertyName], `${label}.${propertyName}`);
+      });
+      return;
+    }
+    case "array": {
+      if (!Array.isArray(value)) {
+        throw new Error(`${label} \u5FC5\u987B\u662F\u6570\u7EC4`);
+      }
+      value.forEach((item, index) => validateSchema(schema.items, item, `${label}[${index}]`));
+      return;
+    }
+    case "string": {
+      if (typeof value !== "string") {
+        throw new Error(`${label} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+      }
+      return;
+    }
+    case "integer": {
+      if (typeof value !== "number" || !Number.isInteger(value)) {
+        throw new Error(`${label} \u5FC5\u987B\u662F\u6574\u6570`);
+      }
+      return;
+    }
+    case "number": {
+      if (typeof value !== "number" || Number.isNaN(value)) {
+        throw new Error(`${label} \u5FC5\u987B\u662F\u6570\u5B57`);
+      }
+      return;
+    }
+    case "boolean": {
+      if (typeof value !== "boolean") {
+        throw new Error(`${label} \u5FC5\u987B\u662F\u5E03\u5C14\u503C`);
+      }
+      return;
+    }
+    default:
+      return;
+  }
+}
+function validateParameters(parameters, values, locationLabel) {
+  parameters.forEach((parameter) => {
+    const value = values[parameter.name];
+    if (parameter.required && value === void 0) {
+      throw new Error(`${locationLabel} \u53C2\u6570 ${parameter.name} \u4E3A\u5FC5\u586B\u9879`);
+    }
+    validateSchema(parameter.schema, value, `${locationLabel}.${parameter.name}`);
+  });
+}
+
+const DOCS_URL = "https://stargate.yingmi.com/api/docs.json";
+const HTTP_METHODS = ["get", "post", "put", "patch", "delete", "head", "options"];
+async function fetchOpenApiDocument(apiKey) {
+  const response = await axios.get(DOCS_URL, {
+    params: {
+      apiKey
+    },
+    timeout: 15e3
+  });
+  return response.data;
+}
+function getServerBaseUrl(document) {
+  return document.servers?.[0]?.url ?? "https://stargate.yingmi.com/api";
+}
+function listOperations(document) {
+  const operations = [];
+  Object.entries(document.paths).forEach(([path, pathItem]) => {
+    const sharedParameters = pathItem.parameters ?? [];
+    HTTP_METHODS.forEach((method) => {
+      const operation = pathItem[method];
+      if (!operation?.operationId) {
+        return;
+      }
+      operations.push({
+        name: operation.operationId,
+        summary: operation.summary,
+        description: operation.description,
+        method: method.toUpperCase(),
+        path,
+        parameters: [...sharedParameters, ...operation.parameters ?? []],
+        requestBody: operation.requestBody,
+        responses: operation.responses ?? {}
+      });
+    });
+  });
+  return operations.sort((left, right) => left.name.localeCompare(right.name));
+}
+function getOperationByName(document, toolName) {
+  return listOperations(document).find((operation) => operation.name === toolName);
+}
+function getPrimaryRequestSchema(operation) {
+  const content = operation.requestBody?.content;
+  if (!content) {
+    return void 0;
+  }
+  return content["application/json"]?.schema ?? content["*/*"]?.schema ?? Object.values(content)[0]?.schema;
+}
+function getPrimaryRequestContentType(operation) {
+  const content = operation.requestBody?.content;
+  if (!content) {
+    return void 0;
+  }
+  if (content["application/json"]) {
+    return "application/json";
+  }
+  if (content["*/*"]) {
+    return "application/json";
+  }
+  return Object.keys(content)[0];
+}
+
+function registerCallCommand(mcpCommand) {
+  mcpCommand.command("call").description("\u8C03\u7528\u6307\u5B9A MCP \u5DE5\u5177").argument("<toolName>", "\u5DE5\u5177\u540D").option("--input <json>", "\u76F4\u63A5\u4F20\u5165 JSON \u5B57\u7B26\u4E32").option("--input-file <path>", "\u4ECE\u6587\u4EF6\u8BFB\u53D6 JSON \u8F93\u5165").action(async (toolName, options) => {
+    const apiKey = requireApiKey();
+    const document = await fetchOpenApiDocument(apiKey);
+    const operation = getOperationByName(document, toolName);
+    if (!operation) {
+      fail(`Tool not found: ${toolName}`);
+    }
+    const rawInput = readJsonInput(options.input, options.inputFile);
+    const sections = splitInput(operation, rawInput);
+    try {
+      validateParameters(getParametersByIn(operation, "path"), sections.path, "path");
+      validateParameters(getParametersByIn(operation, "query"), sections.query, "query");
+      validateParameters(getParametersByIn(operation, "header"), sections.header, "header");
+      if (operation.requestBody?.required && sections.body === void 0) {
+        throw new Error("body \u4E3A\u5FC5\u586B\u9879");
+      }
+      validateSchema(getPrimaryRequestSchema(operation), sections.body, "body");
+    } catch (error) {
+      fail(`\u8F93\u5165\u6821\u9A8C\u5931\u8D25: ${error.message}`);
+    }
+    const url = buildRequestPath(operation.path, sections.path);
+    const contentType = getPrimaryRequestContentType(operation);
+    try {
+      const response = await axios.request({
+        method: operation.method,
+        baseURL: getServerBaseUrl(document),
+        url,
+        params: sections.query,
+        data: sections.body,
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          ...contentType ? { "Content-Type": contentType } : {},
+          ...Object.fromEntries(
+            Object.entries(sections.header).map(([key, value]) => [key, String(value)])
+          )
+        },
+        timeout: 2e4
+      });
+      console.log(JSON.stringify(response.data, null, 2));
+    } catch (error) {
+      if (error instanceof axios.AxiosError) {
+        const status = error.response?.status;
+        const data = error.response?.data;
+        const detail = data ? JSON.stringify(data, null, 2) : error.message;
+        fail(`\u8C03\u7528\u5931\u8D25${status ? ` (${status})` : ""}: ${detail}`);
+      }
+      fail(`\u8C03\u7528\u5931\u8D25: ${error.message}`);
+    }
+  });
+}
+
+function registerListCommand(mcpCommand) {
+  mcpCommand.command("list").description("\u5217\u51FA\u6240\u6709 MCP \u5DE5\u5177\u6458\u8981").action(async () => {
+    const apiKey = requireApiKey();
+    const document = await fetchOpenApiDocument(apiKey);
+    const operations = listOperations(document);
+    console.log(
+      JSON.stringify(
+        operations.map((operation) => ({
+          name: operation.name,
+          summary: operation.summary,
+          description: operation.description,
+          method: operation.method,
+          path: operation.path
+        })),
+        null,
+        2
+      )
+    );
+  });
+}
+
+function registerSchemaCommand(mcpCommand) {
+  mcpCommand.command("schema").description("\u67E5\u770B\u67D0\u4E2A MCP \u5DE5\u5177\u7684\u5B8C\u6574 Schema").argument("<toolName>", "\u5DE5\u5177\u540D").action(async (toolName) => {
+    const apiKey = requireApiKey();
+    const document = await fetchOpenApiDocument(apiKey);
+    const operation = getOperationByName(document, toolName);
+    if (!operation) {
+      fail(`Tool not found: ${toolName}`);
+    }
+    console.log(
+      JSON.stringify(
+        {
+          name: operation.name,
+          summary: operation.summary,
+          description: operation.description,
+          method: operation.method,
+          path: operation.path,
+          parameters: operation.parameters,
+          requestBody: operation.requestBody,
+          responses: operation.responses
+        },
+        null,
+        2
+      )
+    );
+  });
+}
+
+function registerMcpCommand(program) {
+  const mcpCommand = program.command("mcp").description("\u6D4F\u89C8 MCP \u6458\u8981\u3001\u67E5\u770B Schema \u5E76\u8C03\u7528\u5DE5\u5177");
+  registerListCommand(mcpCommand);
+  registerSchemaCommand(mcpCommand);
+  registerCallCommand(mcpCommand);
+}
+
+async function runScriptInDirectory(script, workingDirectory) {
+  const shellCommand = process.platform === "win32" ? "cmd.exe" : "sh";
+  const shellArgs = process.platform === "win32" ? ["/d", "/s", "/c", script] : ["-lc", script];
+  return new Promise((resolve, reject) => {
+    const child = child_process.spawn(shellCommand, shellArgs, {
+      cwd: workingDirectory,
+      env: process.env
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      const exitCode = code ?? 1;
+      resolve({
+        exitCode,
+        status: exitCode === 0 ? "success" : "failed",
+        stdout,
+        stderr
+      });
+    });
+  });
+}
+
+async function extractZipArchive(archivePath, targetDirectory) {
+  fs.mkdirSync(targetDirectory, { recursive: true });
+  await new Promise((resolve, reject) => {
+    const child = child_process.spawn("unzip", ["-oq", archivePath, "-d", targetDirectory], {
+      stdio: "inherit"
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`unzip \u89E3\u538B\u5931\u8D25\uFF0C\u9000\u51FA\u7801: ${code ?? "null"}`));
+    });
+  });
+}
+
+const REQUEST_TIMEOUT = 15e3;
+const DOWNLOAD_TIMEOUT = 12e4;
+const REMOTE_SKILL_NAME_PATTERN = /^[A-Za-z0-9._-]+$/;
+function normalizeServerBaseUrl(serverBaseUrl) {
+  return serverBaseUrl.replace(/\/+$/, "");
+}
+function buildRequestHeaders(apiKey) {
+  return {
+    apiKey
+  };
+}
+function listDirectoryEntries(rootDirectory, baseDirectory = rootDirectory) {
+  const entries = fs.readdirSync(rootDirectory, { withFileTypes: true }).sort((left, right) => {
+    if (left.isDirectory() !== right.isDirectory()) {
+      return left.isDirectory() ? -1 : 1;
+    }
+    return left.name.localeCompare(right.name);
+  });
+  return entries.flatMap((entry) => {
+    const absolutePath = path.join(rootDirectory, entry.name);
+    const relativePath = path.relative(baseDirectory, absolutePath);
+    if (entry.isDirectory()) {
+      return [
+        { path: relativePath, type: "directory" },
+        ...listDirectoryEntries(absolutePath, baseDirectory)
+      ];
+    }
+    return [{ path: relativePath, type: "file" }];
+  });
+}
+function resolveSkillRootDirectory(extractedDirectory) {
+  const entries = fs.readdirSync(extractedDirectory, { withFileTypes: true });
+  if (entries.length !== 1 || !entries[0]?.isDirectory()) {
+    return extractedDirectory;
+  }
+  return path.join(extractedDirectory, entries[0].name);
+}
+function assertRemoteSkillDetail(data) {
+  if (typeof data !== "object" || data === null || typeof data.name !== "string" || typeof data.description !== "string" || typeof data.packageUrl !== "string") {
+    throw new Error("\u8FDC\u7AEF skill \u8BE6\u60C5\u683C\u5F0F\u975E\u6CD5\uFF0C\u8BF7\u68C0\u67E5\u670D\u52A1\u7AEF\u8FD4\u56DE");
+  }
+}
+function validateRemoteSkillName(skillName) {
+  const normalizedName = skillName.trim();
+  if (!REMOTE_SKILL_NAME_PATTERN.test(normalizedName)) {
+    throw new Error("skill \u540D\u79F0\u975E\u6CD5\uFF0C\u4EC5\u652F\u6301\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u70B9\u3001\u4E0B\u5212\u7EBF\u548C\u4E2D\u5212\u7EBF");
+  }
+  return normalizedName;
+}
+async function fetchRemoteSkillSummaries(apiKey) {
+  const serverBaseUrl = normalizeServerBaseUrl(getRemoteSkillServerBaseUrl());
+  const response = await axios.get(`${serverBaseUrl}/api/get-skills`, {
+    headers: buildRequestHeaders(apiKey),
+    timeout: REQUEST_TIMEOUT
+  });
+  return response.data;
+}
+async function prepareRemoteSkillContext(skillName, apiKey) {
+  const normalizedSkillName = validateRemoteSkillName(skillName);
+  const serverBaseUrl = normalizeServerBaseUrl(getRemoteSkillServerBaseUrl());
+  const detailResponse = await axios.get(
+    `${serverBaseUrl}/api/get-skill-by-name`,
+    {
+      headers: buildRequestHeaders(apiKey),
+      params: {
+        name: normalizedSkillName
+      },
+      timeout: REQUEST_TIMEOUT
+    }
+  );
+  assertRemoteSkillDetail(detailResponse.data);
+  const skillsDirectory = getSkillsDirPath();
+  const archivePath = path.join(skillsDirectory, `${normalizedSkillName}.zip`);
+  const extractionDirectory = path.join(skillsDirectory, normalizedSkillName);
+  const url = detailResponse.data.packageUrl.replace("-internal.", ".");
+  const packageResponse = await axios.get(url, {
+    responseType: "arraybuffer",
+    timeout: DOWNLOAD_TIMEOUT
+  });
+  fs.rmSync(extractionDirectory, { recursive: true, force: true });
+  fs.mkdirSync(extractionDirectory, { recursive: true });
+  fs.writeFileSync(archivePath, Buffer.from(packageResponse.data));
+  try {
+    await extractZipArchive(archivePath, extractionDirectory);
+  } finally {
+    fs.rmSync(archivePath, { force: true });
+  }
+  const workingDirectory = resolveSkillRootDirectory(extractionDirectory);
+  return {
+    skill: detailResponse.data,
+    workingDirectory,
+    files: listDirectoryEntries(workingDirectory)
+  };
+}
+
+function formatWorkingDirectoryTree(rootDir) {
+  const lines = ["."];
+  const walk = (currentDir, prefix) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    entries.sort((left, right) => {
+      const leftRank = left.isDirectory() ? 0 : 1;
+      const rightRank = right.isDirectory() ? 0 : 1;
+      if (leftRank !== rightRank) {
+        return leftRank - rightRank;
+      }
+      return left.name.localeCompare(right.name);
+    });
+    entries.forEach((entry, index) => {
+      const isLast = index === entries.length - 1;
+      const connector = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+      lines.push(`${prefix}${connector}${entry.name}`);
+      if (entry.isDirectory()) {
+        const nextPrefix = prefix + (isLast ? "    " : "\u2502   ");
+        walk(path.join(currentDir, entry.name), nextPrefix);
+      }
+    });
+  };
+  walk(rootDir, "");
+  return lines.join("\n");
+}
+function readScriptInput(options) {
+  if (!options.scriptFile) {
+    return options.script;
+  }
+  try {
+    return fs.readFileSync(options.scriptFile, "utf8");
+  } catch {
+    throw new Error("\u8BFB\u53D6\u811A\u672C\u6587\u4EF6\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u8DEF\u5F84\u662F\u5426\u5B58\u5728\u4E14\u5F53\u524D\u7528\u6237\u6709\u8BFB\u53D6\u6743\u9650");
+  }
+}
+function registerRemoteSkillCommand(program) {
+  const remoteSkillCommand = program.command("remote-skill").description("\u67E5\u770B skill \u6458\u8981\uFF0C\u5E76\u8FDB\u5165\u67D0\u4E2A skill \u4E0A\u4E0B\u6587");
+  remoteSkillCommand.command("list").description("\u5C55\u793A\u5F53\u524D\u652F\u6301\u7684 skill \u6458\u8981").action(async () => {
+    try {
+      const apiKey = requireApiKey();
+      const skills = await fetchRemoteSkillSummaries(apiKey);
+      console.log(JSON.stringify(skills, null, 2));
+    } catch (error) {
+      fail(error.message);
+    }
+  });
+  remoteSkillCommand.command("enter").description("\u8FDB\u5165\u67D0\u4E2A skill \u4E0A\u4E0B\u6587\uFF0C\u5E76\u5C55\u793A\u76EE\u5F55\u548C\u6587\u4EF6\u7ED3\u6784").argument("<skillName>", "skill \u540D\u79F0").action(async (skillName) => {
+    try {
+      const apiKey = requireApiKey();
+      const context = await prepareRemoteSkillContext(skillName, apiKey);
+      setCurrentRemoteSkillSession({
+        skillName,
+        workingDirectory: context.workingDirectory
+      });
+      console.log(formatWorkingDirectoryTree(context.workingDirectory));
+    } catch (error) {
+      fail(error.message);
+    }
+  });
+  remoteSkillCommand.command("exec").description("\u5728\u6700\u8FD1\u4E00\u6B21\u8FDB\u5165\u7684 skill \u4E0A\u4E0B\u6587\u4E2D\u6267\u884C\u811A\u672C").option("--script <content>", "\u5728\u5F53\u524D skill \u4E0A\u4E0B\u6587\u4E2D\u6267\u884C\u811A\u672C").option("--script-file <path>", "\u4ECE\u6587\u4EF6\u8BFB\u53D6\u811A\u672C\u5185\u5BB9\u540E\u6267\u884C").action(async (options) => {
+    try {
+      if (options.script && options.scriptFile) {
+        fail("--script \u548C --script-file \u4E0D\u80FD\u540C\u65F6\u4F7F\u7528");
+      }
+      const script = readScriptInput(options);
+      if (!script) {
+        fail("\u8BF7\u901A\u8FC7 --script \u6216 --script-file \u63D0\u4F9B\u8981\u6267\u884C\u7684\u811A\u672C");
+      }
+      const currentSession = getCurrentRemoteSkillSession();
+      if (!currentSession) {
+        fail("\u8BF7\u5148\u6267\u884C remote-skill enter <skillName> \u8FDB\u5165\u67D0\u4E2A skill \u4E0A\u4E0B\u6587");
+      }
+      if (!fs.existsSync(currentSession.workingDirectory)) {
+        fail(
+          `\u5F53\u524D skill \u4E0A\u4E0B\u6587\u76EE\u5F55\u4E0D\u5B58\u5728\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C remote-skill enter ${currentSession.skillName}`
+        );
+      }
+      const execution = await runScriptInDirectory(script, currentSession.workingDirectory);
+      console.log(
+        JSON.stringify(
+          {
+            skillName: currentSession.skillName,
+            workingDirectory: currentSession.workingDirectory,
+            execution
+          },
+          null,
+          2
+        )
+      );
+    } catch (error) {
+      fail(error.message);
+    }
+  });
+}
+
+const REGISTRY_URL$1 = "https://registry.npmmirror.com";
+async function fetchLatestVersion() {
+  const response = await axios.get(
+    `${REGISTRY_URL$1}/${encodeURIComponent(name)}`,
+    {
+      timeout: 1e4
+    }
+  );
+  const latestVersion = response.data?.["dist-tags"]?.latest?.trim();
+  if (!latestVersion) {
+    throw new Error("\u672A\u83B7\u53D6\u5230\u6700\u65B0\u7248\u672C\u53F7");
+  }
+  return latestVersion;
+}
+
+async function installLatestVersion() {
+  const npmCommand = process.platform === "win32" ? "npm.cmd" : "npm";
+  await new Promise((resolve, reject) => {
+    const child = child_process.spawn(
+      npmCommand,
+      [
+        "install",
+        "-g",
+        `${name}@latest`,
+        "--registry=https://registry.npmmirror.com",
+        "--prefer-online"
+      ],
+      {
+        env: {
+          ...process.env,
+          PUPPETEER_SKIP_DOWNLOAD: "true"
+        },
+        stdio: "inherit"
+      }
+    );
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`npm install \u9000\u51FA\u7801\u5F02\u5E38: ${code ?? "null"}`));
+    });
+  });
+}
+
+function normalizeVersion(input) {
+  return input.trim().replace(/^v/i, "").split(/[.-]/);
+}
+function parseVersionPart(part) {
+  return /^\d+$/.test(part) ? Number(part) : part;
+}
+
+function isNewerVersion(latestVersion, currentVersion) {
+  const latestParts = normalizeVersion(latestVersion).map(parseVersionPart);
+  const currentParts = normalizeVersion(currentVersion).map(parseVersionPart);
+  const maxLength = Math.max(latestParts.length, currentParts.length);
+  for (let index = 0; index < maxLength; index += 1) {
+    const latestPart = latestParts[index] ?? 0;
+    const currentPart = currentParts[index] ?? 0;
+    if (latestPart === currentPart) {
+      continue;
+    }
+    if (typeof latestPart === "number" && typeof currentPart === "number") {
+      return latestPart > currentPart;
+    }
+    return String(latestPart) > String(currentPart);
+  }
+  return false;
+}
+
+const REGISTRY_URL = "https://registry.npmmirror.com";
+async function checkAndUpdate(checkOnly = false) {
+  console.log("\u6B63\u5728\u68C0\u67E5\u66F4\u65B0...");
+  const latestVersion = await fetchLatestVersion();
+  if (!isNewerVersion(latestVersion, version)) {
+    console.log(`\u5F53\u524D\u5DF2\u662F\u6700\u65B0\u7248\u672C: ${version}`);
+    return;
+  }
+  console.log(`\u53D1\u73B0\u65B0\u7248\u672C: ${version} -> ${latestVersion}`);
+  if (checkOnly) {
+    console.log(
+      `\u53EF\u6267\u884C PUPPETEER_SKIP_DOWNLOAD=true npm install -g ${name}@latest --registry=${REGISTRY_URL} --prefer-online \u8FDB\u884C\u5347\u7EA7`
+    );
+    return;
+  }
+  await installLatestVersion();
+  console.log(`\u5347\u7EA7\u5B8C\u6210\uFF0C\u5F53\u524D\u6700\u65B0\u7248\u672C: ${latestVersion}`);
+}
+
+function registerUpgradeCommand(program) {
+  program.command("upgrade").description("\u68C0\u67E5 CLI \u66F4\u65B0\uFF0C\u5E76\u5728\u6709\u65B0\u7248\u672C\u65F6\u6267\u884C\u5347\u7EA7").option("--check-only", "\u4EC5\u68C0\u67E5\u6700\u65B0\u7248\u672C\uFF0C\u4E0D\u6267\u884C\u5B89\u88C5").action(async (options) => {
+    try {
+      await checkAndUpdate(Boolean(options.checkOnly));
+    } catch (error) {
+      console.error(
+        `\u68C0\u67E5\u66F4\u65B0\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}\u3002\u8BF7\u68C0\u67E5\u7F51\u7EDC\u6216\u7A0D\u540E\u91CD\u8BD5\u3002`
+      );
+      process.exit(1);
+    }
+  });
+}
+
+function createProgram() {
+  const program = new commander.Command();
+  program.name("yingmi-cli").version(version);
+  registerInitCommand(program);
+  registerMcpCommand(program);
+  registerRemoteSkillCommand(program);
+  registerHelpCommand(program);
+  registerUpgradeCommand(program);
+  program.showHelpAfterError("(\u4F7F\u7528 --help \u67E5\u770B\u547D\u4EE4\u5E2E\u52A9)");
+  return program;
+}
+
+createProgram().parseAsync(process.argv).catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
+});