@lark-project/meegle 0.0.3 → 0.0.4

package/dist/bin/meegle.js

@@ -1,2076 +0,0 @@
-#!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/utils/env.ts
-function getEnv(key) {
-  return process.env[`${PREFIX}${key}`];
-}
-function getHost() {
-  return getEnv("HOST");
-}
-function getUserToken() {
-  return getEnv("USER_ACCESS_TOKEN");
-}
-function hasEnvAuth() {
-  return !!(getEnv("HOST") && getEnv("USER_ACCESS_TOKEN"));
-}
-var PREFIX;
-var init_env = __esm({
-  "src/utils/env.ts"() {
-    "use strict";
-    PREFIX = "MEEGLE_";
-  }
-});
-
-// src/core/config.ts
-import { readFile, writeFile, mkdir } from "fs/promises";
-import { join } from "path";
-import { homedir } from "os";
-function getConfigDir() {
-  return CONFIG_DIR;
-}
-function getCacheDir() {
-  return join(CONFIG_DIR, "cache");
-}
-async function readRootConfig() {
-  try {
-    const raw = await readFile(CONFIG_PATH, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!parsed.profiles) return {};
-    return parsed;
-  } catch {
-    return {};
-  }
-}
-async function writeRootConfig(root) {
-  await mkdir(CONFIG_DIR, { recursive: true, mode: 448 });
-  await writeFile(CONFIG_PATH, JSON.stringify(root, null, 2), { mode: 384 });
-}
-async function getCurrentProfileName() {
-  const root = await readRootConfig();
-  return root.current ?? "default";
-}
-async function setCurrentProfileName(name) {
-  const root = await readRootConfig();
-  root.current = name;
-  await writeRootConfig(root);
-}
-async function loadProfileConfig(profile) {
-  const root = await readRootConfig();
-  return root.profiles?.[profile] ?? {};
-}
-async function saveProfileConfig(profile, config) {
-  const root = await readRootConfig();
-  if (!root.profiles) root.profiles = {};
-  root.profiles[profile] = config;
-  if (!root.current) root.current = profile;
-  await writeRootConfig(root);
-}
-async function getProfileValue(profile, key) {
-  const config = await loadProfileConfig(profile);
-  return config[key];
-}
-async function setProfileValue(profile, key, value) {
-  const config = await loadProfileConfig(profile);
-  let parsed = value;
-  if (typeof value === "string") {
-    try {
-      parsed = JSON.parse(value);
-    } catch {
-    }
-  }
-  config[key] = parsed;
-  await saveProfileConfig(profile, config);
-}
-async function listProfiles() {
-  const root = await readRootConfig();
-  const current = root.current ?? "default";
-  const names = Object.keys(root.profiles ?? {});
-  return { names, current };
-}
-async function deleteProfile(name) {
-  const root = await readRootConfig();
-  if (root.profiles) {
-    delete root.profiles[name];
-  }
-  if (root.current === name) {
-    const remaining = Object.keys(root.profiles ?? {});
-    root.current = remaining[0] ?? "default";
-  }
-  await writeRootConfig(root);
-}
-async function loadConfig(profile) {
-  const name = profile ?? await getCurrentProfileName();
-  return loadProfileConfig(name);
-}
-async function saveConfig(config, profile) {
-  const name = profile ?? await getCurrentProfileName();
-  await saveProfileConfig(name, config);
-}
-function sanitizeHost(raw) {
-  const trimmed = raw.trim();
-  try {
-    const url = new URL(trimmed.includes("://") ? trimmed : `https://${trimmed}`);
-    return url.host;
-  } catch {
-    return trimmed;
-  }
-}
-function getServerUrl(config) {
-  const envHost = getEnv("HOST");
-  const host = sanitizeHost(envHost ?? config.host ?? "meegle.com");
-  return `https://${host}/mcp_server/v1`;
-}
-var CONFIG_DIR, CONFIG_PATH;
-var init_config = __esm({
-  "src/core/config.ts"() {
-    "use strict";
-    init_env();
-    CONFIG_DIR = join(homedir(), ".meegle");
-    CONFIG_PATH = join(CONFIG_DIR, "config.json");
-  }
-});
-
-// src/core/errors.ts
-var MeegleError, ClientError, ServerError, HttpError;
-var init_errors = __esm({
-  "src/core/errors.ts"() {
-    "use strict";
-    MeegleError = class extends Error {
-      code;
-      exitCode;
-      suggestion;
-      constructor(message, code, exitCode, suggestion) {
-        super(message);
-        this.name = "MeegleError";
-        this.code = code;
-        this.exitCode = exitCode;
-        this.suggestion = suggestion;
-      }
-      toJSON() {
-        return {
-          error: this.code,
-          message: this.message,
-          ...this.suggestion !== void 0 && { suggestion: this.suggestion }
-        };
-      }
-    };
-    ClientError = class extends MeegleError {
-      constructor(message, code, suggestion) {
-        super(message, code, 1, suggestion);
-        this.name = "ClientError";
-      }
-    };
-    ServerError = class extends MeegleError {
-      constructor(message, code, suggestion) {
-        super(message, code, 2, suggestion);
-        this.name = "ServerError";
-      }
-    };
-    HttpError = class extends ServerError {
-      httpStatus;
-      constructor(message, code, httpStatus, suggestion) {
-        super(message, code, suggestion);
-        this.name = "HttpError";
-        this.httpStatus = httpStatus;
-      }
-    };
-  }
-});
-
-// src/core/profile-validation.ts
-function validateProfileName(profile) {
-  if (!PROFILE_NAME_RE.test(profile)) {
-    throw new ClientError(
-      `Profile \u540D\u79F0\u53EA\u80FD\u5305\u542B\u5B57\u6BCD\u3001\u6570\u5B57\u3001\u8FDE\u5B57\u7B26\u548C\u4E0B\u5212\u7EBF\uFF0C\u6536\u5230: "${profile}"`,
-      "CLIENT_INVALID_PROFILE"
-    );
-  }
-}
-var PROFILE_NAME_RE;
-var init_profile_validation = __esm({
-  "src/core/profile-validation.ts"() {
-    "use strict";
-    init_errors();
-    PROFILE_NAME_RE = /^[a-zA-Z0-9_-]+$/;
-  }
-});
-
-// src/core/auth/keychain-store.ts
-var keychain_store_exports = {};
-__export(keychain_store_exports, {
-  KeychainStore: () => KeychainStore,
-  SecretToolStore: () => SecretToolStore
-});
-import { execFile } from "child_process";
-import { promisify } from "util";
-var exec, SERVICE, KeychainStore, SecretToolStore;
-var init_keychain_store = __esm({
-  "src/core/auth/keychain-store.ts"() {
-    "use strict";
-    init_profile_validation();
-    exec = promisify(execFile);
-    SERVICE = "meegle-cli";
-    KeychainStore = class {
-      account;
-      constructor(profile = "default") {
-        validateProfileName(profile);
-        this.account = profile;
-      }
-      async isAvailable() {
-        try {
-          await exec("security", ["help"]);
-          return true;
-        } catch {
-          return false;
-        }
-      }
-      async load() {
-        try {
-          const { stdout } = await exec("security", [
-            "find-generic-password",
-            "-s",
-            SERVICE,
-            "-a",
-            this.account,
-            "-w"
-          ]);
-          return JSON.parse(stdout.trim());
-        } catch {
-          return null;
-        }
-      }
-      async save(data) {
-        const json = JSON.stringify(data);
-        try {
-          await exec("security", ["delete-generic-password", "-s", SERVICE, "-a", this.account]);
-        } catch {
-        }
-        await exec("security", [
-          "add-generic-password",
-          "-s",
-          SERVICE,
-          "-a",
-          this.account,
-          "-w",
-          json
-        ]);
-      }
-      async clear() {
-        try {
-          await exec("security", ["delete-generic-password", "-s", SERVICE, "-a", this.account]);
-        } catch {
-        }
-      }
-    };
-    SecretToolStore = class {
-      account;
-      constructor(profile = "default") {
-        validateProfileName(profile);
-        this.account = profile;
-      }
-      async isAvailable() {
-        try {
-          await exec("which", ["secret-tool"]);
-          return true;
-        } catch {
-          return false;
-        }
-      }
-      async load() {
-        try {
-          const { stdout } = await exec("secret-tool", [
-            "lookup",
-            "service",
-            SERVICE,
-            "account",
-            this.account
-          ]);
-          return JSON.parse(stdout.trim());
-        } catch {
-          return null;
-        }
-      }
-      async save(data) {
-        const json = JSON.stringify(data);
-        const { spawn } = await import("child_process");
-        const child = spawn("secret-tool", [
-          "store",
-          "--label=meegle-cli",
-          "service",
-          SERVICE,
-          "account",
-          this.account
-        ], { stdio: ["pipe", "pipe", "pipe"] });
-        child.stdin.write(json);
-        child.stdin.end();
-        await new Promise((resolve, reject) => {
-          child.on("close", (code) => code === 0 ? resolve() : reject(new Error(`secret-tool exited ${code}`)));
-        });
-      }
-      async clear() {
-        try {
-          await exec("secret-tool", ["clear", "service", SERVICE, "account", this.account]);
-        } catch {
-        }
-      }
-    };
-  }
-});
-
-// src/core/auth/file-store.ts
-var file_store_exports = {};
-__export(file_store_exports, {
-  FileStore: () => FileStore
-});
-import {
-  randomBytes,
-  createCipheriv,
-  createDecipheriv,
-  pbkdf2Sync
-} from "crypto";
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, rm } from "fs/promises";
-import { join as join2 } from "path";
-import { hostname, userInfo } from "os";
-function toHex(b) {
-  return Buffer.from(b).toString("hex");
-}
-function fromHex(s) {
-  return new Uint8Array(Buffer.from(s, "hex"));
-}
-async function getOrCreateMachineKey(dir) {
-  const keyPath = join2(dir, MACHINE_KEY_FILE);
-  try {
-    return await readFile2(keyPath, "utf-8");
-  } catch {
-    const key = randomBytes(32).toString("hex");
-    await mkdir2(dir, { recursive: true, mode: 448 });
-    await writeFile2(keyPath, key, { mode: 384 });
-    return key;
-  }
-}
-function deriveKey(salt, machineKey) {
-  const material = `${hostname()}:${userInfo().username}:${machineKey}:meegle-cli`;
-  return new Uint8Array(pbkdf2Sync(material, salt, 1e5, 32, "sha256").buffer);
-}
-var MACHINE_KEY_FILE, FileStore;
-var init_file_store = __esm({
-  "src/core/auth/file-store.ts"() {
-    "use strict";
-    init_config();
-    init_profile_validation();
-    MACHINE_KEY_FILE = ".machine-key";
-    FileStore = class {
-      dir;
-      filename;
-      constructor(dir, profile = "default") {
-        this.dir = dir ?? getConfigDir();
-        validateProfileName(profile);
-        this.filename = profile === "default" ? "credentials.enc" : `credentials-${profile}.enc`;
-      }
-      get filePath() {
-        return join2(this.dir, this.filename);
-      }
-      async load() {
-        try {
-          const machineKey = await getOrCreateMachineKey(this.dir);
-          const raw = await readFile2(this.filePath, "utf-8");
-          const file = JSON.parse(raw);
-          const salt = fromHex(file.salt);
-          const iv = fromHex(file.iv);
-          const tag = fromHex(file.tag);
-          const encrypted = fromHex(file.data);
-          const key = deriveKey(salt, machineKey);
-          const decipher = createDecipheriv("aes-256-gcm", key, iv);
-          decipher.setAuthTag(tag);
-          const part1 = decipher.update(encrypted);
-          const part2 = decipher.final();
-          const decrypted = Buffer.concat([part1, part2]);
-          return JSON.parse(decrypted.toString("utf-8"));
-        } catch {
-          return null;
-        }
-      }
-      async save(data) {
-        const machineKey = await getOrCreateMachineKey(this.dir);
-        const salt = new Uint8Array(randomBytes(16).buffer);
-        const iv = new Uint8Array(randomBytes(12).buffer);
-        const key = deriveKey(salt, machineKey);
-        const cipher = createCipheriv("aes-256-gcm", key, iv);
-        const plaintext = JSON.stringify(data);
-        const enc1 = cipher.update(plaintext, "utf-8");
-        const enc2 = cipher.final();
-        const encrypted = Buffer.concat([enc1, enc2]);
-        const tag = new Uint8Array(cipher.getAuthTag().buffer);
-        const file = {
-          salt: toHex(salt),
-          iv: toHex(iv),
-          tag: toHex(tag),
-          data: encrypted.toString("hex")
-        };
-        await mkdir2(this.dir, { recursive: true, mode: 448 });
-        await writeFile2(this.filePath, JSON.stringify(file, null, 2), { mode: 384 });
-      }
-      async clear() {
-        try {
-          await rm(this.filePath);
-        } catch {
-        }
-      }
-    };
-  }
-});
-
-// src/cli.ts
-import { Command } from "commander";
-
-// src/commands/auth/login.ts
-init_config();
-init_env();
-import { select as select2, input as input2 } from "@inquirer/prompts";
-
-// src/core/auth/token-store.ts
-async function createTokenStore(profile = "default") {
-  if (process.platform === "darwin") {
-    const { KeychainStore: KeychainStore2 } = await Promise.resolve().then(() => (init_keychain_store(), keychain_store_exports));
-    const store = new KeychainStore2(profile);
-    if (await store.isAvailable()) return store;
-  }
-  if (process.platform === "linux") {
-    const { SecretToolStore: SecretToolStore2 } = await Promise.resolve().then(() => (init_keychain_store(), keychain_store_exports));
-    const store = new SecretToolStore2(profile);
-    if (await store.isAvailable()) return store;
-  }
-  const { FileStore: FileStore2 } = await Promise.resolve().then(() => (init_file_store(), file_store_exports));
-  return new FileStore2(void 0, profile);
-}
-
-// src/core/auth/token-manager.ts
-init_env();
-
-// src/core/auth/oauth-discovery.ts
-init_errors();
-var REQUIRED_ENDPOINTS = [
-  "issuer",
-  "authorization_endpoint",
-  "token_endpoint",
-  "registration_endpoint"
-];
-function validateMetadata(metadata) {
-  for (const field of REQUIRED_ENDPOINTS) {
-    const value = metadata[field];
-    if (typeof value !== "string" || !value.startsWith("https://")) {
-      throw new ClientError(
-        `OAuth \u914D\u7F6E\u5B57\u6BB5\u65E0\u6548: ${field}`,
-        "OAUTH_DISCOVERY_INVALID"
-      );
-    }
-  }
-  return metadata;
-}
-async function fetchOAuthMetadata(host, headers) {
-  const url = `https://${host}/.well-known/oauth-authorization-server`;
-  const res = await fetch(url, { headers });
-  if (!res.ok) {
-    throw new ClientError(
-      `\u65E0\u6CD5\u83B7\u53D6 OAuth \u914D\u7F6E: ${res.status}`,
-      "OAUTH_DISCOVERY_FAILED",
-      `\u8BF7\u786E\u8BA4\u7AD9\u70B9 ${host} \u662F\u5426\u6B63\u786E`
-    );
-  }
-  const data = await res.json();
-  return validateMetadata(data);
-}
-
-// src/core/auth/token-manager.ts
-var TokenManager = class {
-  store;
-  host;
-  constructor(store, host) {
-    this.store = store;
-    this.host = host;
-  }
-  async getToken() {
-    const envToken = getUserToken();
-    if (envToken) return envToken;
-    const data = await this.store.load();
-    if (!data) return void 0;
-    if (data.expiresAt && Date.now() > data.expiresAt) {
-      const refreshed = await this.refreshToken(data);
-      if (refreshed) return refreshed.accessToken;
-      return void 0;
-    }
-    return data.accessToken;
-  }
-  async refreshToken(tokenData) {
-    if (!tokenData.refreshToken || !tokenData.clientId || !this.host) return null;
-    try {
-      const metadata = await fetchOAuthMetadata(this.host);
-      const res = await fetch(metadata.token_endpoint, {
-        method: "POST",
-        headers: { "Content-Type": "application/x-www-form-urlencoded" },
-        body: new URLSearchParams({
-          grant_type: "refresh_token",
-          refresh_token: tokenData.refreshToken,
-          client_id: tokenData.clientId
-        })
-      });
-      if (!res.ok) return null;
-      const data = await res.json();
-      if (typeof data.access_token !== "string" || !data.access_token) {
-        return null;
-      }
-      const newTokenData = {
-        accessToken: data.access_token,
-        refreshToken: (typeof data.refresh_token === "string" ? data.refresh_token : void 0) ?? tokenData.refreshToken,
-        clientId: tokenData.clientId,
-        expiresAt: typeof data.expires_in === "number" ? Date.now() + data.expires_in * 1e3 : void 0
-      };
-      await this.store.save(newTokenData);
-      return newTokenData;
-    } catch {
-      return null;
-    }
-  }
-  async saveToken(data) {
-    await this.store.save(data);
-  }
-  async clearToken() {
-    await this.store.clear();
-  }
-  async isAuthenticated() {
-    const token = await this.getToken();
-    return token !== void 0;
-  }
-  getStore() {
-    return this.store;
-  }
-};
-
-// src/core/auth/auth-code-flow.ts
-import { randomBytes as randomBytes3 } from "crypto";
-import open from "open";
-
-// src/core/auth/oauth-client-registration.ts
-init_errors();
-import { hostname as hostname2, platform, arch, userInfo as userInfo2 } from "os";
-function getClientName() {
-  const parts = [];
-  try {
-    parts.push(userInfo2().username);
-  } catch {
-  }
-  try {
-    parts.push(hostname2());
-  } catch {
-  }
-  const name = parts.length > 1 ? `${parts[0]}@${parts[1]}` : parts[0];
-  try {
-    const sys = `${platform()}/${arch()}`;
-    return name ? `${name} (${sys})` : `meegle-cli (${sys})`;
-  } catch {
-    return name || "meegle-cli";
-  }
-}
-async function registerClient(registrationEndpoint, redirectUri, customHeaders) {
-  const body = {
-    client_name: getClientName(),
-    token_endpoint_auth_method: "none"
-  };
-  if (redirectUri) {
-    body.redirect_uris = [redirectUri];
-    body.grant_types = ["authorization_code", "refresh_token"];
-    body.response_types = ["code"];
-  } else {
-    body.grant_types = ["urn:ietf:params:oauth:grant-type:device_code", "refresh_token"];
-  }
-  const res = await fetch(registrationEndpoint, {
-    method: "POST",
-    headers: { "Content-Type": "application/json", ...customHeaders },
-    body: JSON.stringify(body)
-  });
-  if (!res.ok) {
-    throw new ClientError(
-      `\u5BA2\u6237\u7AEF\u6CE8\u518C\u5931\u8D25: ${res.status}`,
-      "CLIENT_REGISTRATION_FAILED"
-    );
-  }
-  const data = await res.json();
-  const payload = (data.client_id ? data : data.data) ?? data;
-  if (!payload?.client_id) {
-    const msg = data.msg || data.error?.localizedMessage?.toString() || JSON.stringify(data);
-    throw new ClientError(
-      `\u5BA2\u6237\u7AEF\u6CE8\u518C\u5931\u8D25: \u54CD\u5E94\u4E2D\u7F3A\u5C11 client_id (${msg})`,
-      "CLIENT_REGISTRATION_FAILED"
-    );
-  }
-  return {
-    client_id: payload.client_id,
-    client_secret: payload.client_secret ?? ""
-  };
-}
-
-// src/core/auth/pkce.ts
-import { randomBytes as randomBytes2, createHash } from "crypto";
-function generateCodeVerifier() {
-  return randomBytes2(32).toString("base64url");
-}
-function generateCodeChallenge(verifier) {
-  return createHash("sha256").update(verifier).digest("base64url");
-}
-
-// src/core/auth/callback-server.ts
-init_errors();
-import http from "http";
-import { URL as URL2 } from "url";
-var SUCCESS_HTML = `<!DOCTYPE html><html><body>
-<h1>\u6388\u6743\u6210\u529F\uFF01</h1><p>\u53EF\u4EE5\u5173\u95ED\u6B64\u9875\u9762\uFF0C\u8FD4\u56DE\u7EC8\u7AEF\u3002</p>
-</body></html>`;
-var ERROR_HTML = `<!DOCTYPE html><html><body>
-<h1>\u6388\u6743\u9519\u8BEF</h1><p>\u72B6\u6001\u9A8C\u8BC1\u5931\u8D25\uFF0C\u8BF7\u91CD\u8BD5\u3002</p>
-</body></html>`;
-async function startCallbackServer() {
-  return new Promise((resolve, reject) => {
-    const server = http.createServer();
-    server.listen(0, "127.0.0.1", () => {
-      const addr = server.address();
-      if (!addr || typeof addr === "string") {
-        reject(new Error("Failed to get server address"));
-        return;
-      }
-      const port = addr.port;
-      const redirectUri = `http://127.0.0.1:${port}/callback`;
-      const callbackServer = {
-        port,
-        redirectUri,
-        waitForCallback(expectedState) {
-          let resolveCallback;
-          let rejectCallback;
-          const promise = new Promise((res, rej) => {
-            resolveCallback = res;
-            rejectCallback = rej;
-          });
-          promise.catch(() => {
-          });
-          let settled = false;
-          const settle = (fn) => {
-            if (settled) return;
-            settled = true;
-            clearTimeout(timeout);
-            fn();
-          };
-          const timeout = setTimeout(() => {
-            settle(() => rejectCallback(new ClientError("\u6388\u6743\u8D85\u65F6\uFF08120\u79D2\uFF09", "OAUTH_TIMEOUT")));
-          }, 12e4);
-          const requestHandler = (req, res) => {
-            const url = new URL2(req.url ?? "", `http://127.0.0.1:${port}`);
-            if (url.pathname !== "/callback") {
-              res.writeHead(404);
-              res.end("Not Found");
-              return;
-            }
-            const code = url.searchParams.get("code");
-            const state = url.searchParams.get("state");
-            server.off("request", requestHandler);
-            if (state !== expectedState) {
-              res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
-              res.end(ERROR_HTML, () => {
-                settle(() => rejectCallback(new ClientError("\u6388\u6743\u72B6\u6001\u4E0D\u5339\u914D", "OAUTH_STATE_MISMATCH")));
-              });
-              return;
-            }
-            if (!code) {
-              res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
-              res.end(ERROR_HTML, () => {
-                settle(() => rejectCallback(new ClientError("\u672A\u6536\u5230\u6388\u6743\u7801", "OAUTH_NO_CODE")));
-              });
-              return;
-            }
-            res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-            res.end(SUCCESS_HTML, () => {
-              settle(() => resolveCallback({ code }));
-            });
-          };
-          server.on("request", requestHandler);
-          return promise;
-        },
-        close() {
-          if (typeof server.closeAllConnections === "function") {
-            server.closeAllConnections();
-          }
-          server.close();
-        }
-      };
-      resolve(callbackServer);
-    });
-    server.on("error", reject);
-  });
-}
-
-// src/core/auth/auth-code-flow.ts
-init_errors();
-function buildAuthUrl(endpoint, params) {
-  const url = new URL(endpoint);
-  for (const [key, value] of Object.entries(params)) {
-    url.searchParams.set(key, value);
-  }
-  return url.toString();
-}
-async function exchangeToken(tokenEndpoint, params, customHeaders) {
-  const res = await fetch(tokenEndpoint, {
-    method: "POST",
-    headers: { "Content-Type": "application/x-www-form-urlencoded", ...customHeaders },
-    body: new URLSearchParams(params)
-  });
-  if (!res.ok) {
-    throw new ServerError(`Token \u4EA4\u6362\u5931\u8D25: ${res.status}`, "TOKEN_EXCHANGE_FAILED");
-  }
-  return res.json();
-}
-async function startAuthCodeFlow(host, customHeaders) {
-  const metadata = await fetchOAuthMetadata(host, customHeaders);
-  const server = await startCallbackServer();
-  try {
-    const client = await registerClient(metadata.registration_endpoint, server.redirectUri, customHeaders);
-    const codeVerifier = generateCodeVerifier();
-    const codeChallenge = generateCodeChallenge(codeVerifier);
-    const state = randomBytes3(16).toString("hex");
-    const authUrl = buildAuthUrl(metadata.authorization_endpoint, {
-      response_type: "code",
-      client_id: client.client_id,
-      redirect_uri: server.redirectUri,
-      code_challenge: codeChallenge,
-      code_challenge_method: "S256",
-      state
-    });
-    console.log("  \u6B63\u5728\u6253\u5F00\u6D4F\u89C8\u5668\u8FDB\u884C\u6388\u6743...");
-    console.log(`  \u6388\u6743\u5730\u5740: ${authUrl}`);
-    try {
-      const cp = await open(authUrl);
-      console.log(`  \u6D4F\u89C8\u5668\u5DF2\u542F\u52A8 (pid: ${cp.pid})`);
-    } catch (err) {
-      console.log(`  \u65E0\u6CD5\u81EA\u52A8\u6253\u5F00\u6D4F\u89C8\u5668\uFF0C\u8BF7\u624B\u52A8\u8BBF\u95EE\u4E0A\u65B9\u5730\u5740`);
-    }
-    const result = await server.waitForCallback(state);
-    const tokenResponse = await exchangeToken(metadata.token_endpoint, {
-      grant_type: "authorization_code",
-      code: result.code,
-      redirect_uri: server.redirectUri,
-      client_id: client.client_id,
-      code_verifier: codeVerifier
-    }, customHeaders);
-    return {
-      accessToken: tokenResponse.access_token,
-      refreshToken: tokenResponse.refresh_token,
-      clientId: client.client_id,
-      expiresAt: tokenResponse.expires_in ? Date.now() + tokenResponse.expires_in * 1e3 : void 0
-    };
-  } finally {
-    server.close();
-  }
-}
-
-// src/core/auth/device-code-flow.ts
-import qrcode from "qrcode-terminal";
-init_errors();
-function generateQR(url) {
-  return new Promise((resolve) => {
-    qrcode.generate(url, { small: true }, (code) => {
-      resolve(code);
-    });
-  });
-}
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function startDeviceCodeInit(host, customHeaders) {
-  const metadata = await fetchOAuthMetadata(host, customHeaders);
-  if (!metadata.device_authorization_endpoint) {
-    throw new ClientError(
-      "\u5F53\u524D\u7AD9\u70B9\u4E0D\u652F\u6301 Device Code \u6388\u6743",
-      "DEVICE_CODE_NOT_SUPPORTED"
-    );
-  }
-  const client = await registerClient(metadata.registration_endpoint, void 0, customHeaders);
-  const deviceRes = await fetch(metadata.device_authorization_endpoint, {
-    method: "POST",
-    headers: { "Content-Type": "application/x-www-form-urlencoded", ...customHeaders },
-    body: new URLSearchParams({ client_id: client.client_id })
-  });
-  if (!deviceRes.ok) {
-    throw new ServerError(
-      `\u83B7\u53D6\u8BBE\u5907\u6388\u6743\u7801\u5931\u8D25: ${deviceRes.status}`,
-      "DEVICE_CODE_REQUEST_FAILED"
-    );
-  }
-  const deviceRaw = await deviceRes.json();
-  const device = deviceRaw.device_code ? deviceRaw : deviceRaw.data;
-  if (!device?.device_code) {
-    const msg = deviceRaw.msg || JSON.stringify(deviceRaw);
-    throw new ServerError(
-      `\u83B7\u53D6\u8BBE\u5907\u6388\u6743\u7801\u5931\u8D25: \u54CD\u5E94\u4E2D\u7F3A\u5C11 device_code (${msg})`,
-      "DEVICE_CODE_REQUEST_FAILED"
-    );
-  }
-  return {
-    ...device,
-    client_id: client.client_id
-  };
-}
-async function pollDeviceCodeOnce(options) {
-  const metadata = await fetchOAuthMetadata(options.host, options.customHeaders);
-  const tokenRes = await fetch(metadata.token_endpoint, {
-    method: "POST",
-    headers: { "Content-Type": "application/x-www-form-urlencoded", ...options.customHeaders },
-    body: new URLSearchParams({
-      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-      device_code: options.device_code,
-      client_id: options.client_id
-    })
-  });
-  const tokenRaw = await tokenRes.json();
-  const data = tokenRaw.access_token || tokenRaw.error ? tokenRaw : tokenRaw.data ?? tokenRaw;
-  if (data.access_token) {
-    return {
-      status: "ok",
-      token_data: {
-        accessToken: data.access_token,
-        refreshToken: data.refresh_token,
-        clientId: options.client_id,
-        expiresAt: data.expires_in ? Date.now() + data.expires_in * 1e3 : void 0
-      }
-    };
-  }
-  if (data.error === "slow_down") return { status: "slow_down" };
-  if (data.error === "authorization_pending") return { status: "authorization_pending" };
-  if (data.error === "expired_token") return { status: "expired_token" };
-  throw new ServerError(
-    `Device Code \u6388\u6743\u5931\u8D25: ${data.error ?? "\u672A\u77E5\u9519\u8BEF"}`,
-    "DEVICE_CODE_FAILED"
-  );
-}
-async function startDeviceCodePoll(options) {
-  let interval = options.interval * 1e3;
-  const deadline = Date.now() + options.expires_in * 1e3;
-  while (Date.now() < deadline) {
-    await sleep(interval);
-    const result = await pollDeviceCodeOnce(options);
-    if (result.status === "ok" && result.token_data) {
-      return result.token_data;
-    }
-    if (result.status === "slow_down") {
-      interval += 5e3;
-      continue;
-    }
-    if (result.status === "authorization_pending") {
-      continue;
-    }
-    if (result.status === "expired_token") {
-      throw new ClientError("\u6388\u6743\u5DF2\u8D85\u65F6\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C meegle auth login --device-code", "DEVICE_CODE_EXPIRED");
-    }
-  }
-  throw new ClientError("\u6388\u6743\u5DF2\u8D85\u65F6\uFF0C\u8BF7\u91CD\u65B0\u6267\u884C meegle auth login --device-code", "DEVICE_CODE_EXPIRED");
-}
-async function startDeviceCodeFlow(host, customHeaders) {
-  const initResult = await startDeviceCodeInit(host, customHeaders);
-  const qr = await generateQR(initResult.verification_uri_complete);
-  console.log("\n  \u8BF7\u4F7F\u7528\u624B\u673A\u626B\u63CF\u4E8C\u7EF4\u7801\uFF0C\u6216\u5728\u6D4F\u89C8\u5668\u4E2D\u6253\u5F00\u4EE5\u4E0B\u5730\u5740\uFF1A\n");
-  console.log(qr);
-  console.log(`  \u5730\u5740: ${initResult.verification_uri_complete}`);
-  console.log(`  \u6388\u6743\u7801: ${initResult.user_code}`);
-  console.log(`
-  \u7B49\u5F85\u6388\u6743\u4E2D... (\u8D85\u65F6\u65F6\u95F4 ${Math.round(initResult.expires_in / 60)} \u5206\u949F)
-`);
-  return startDeviceCodePoll({
-    host,
-    device_code: initResult.device_code,
-    client_id: initResult.client_id,
-    interval: initResult.interval,
-    expires_in: initResult.expires_in,
-    customHeaders
-  });
-}
-
-// src/core/first-run.ts
-init_env();
-init_config();
-import { select, input } from "@inquirer/prompts";
-var PRESET_HOSTS = [
-  { name: "\u98DE\u4E66\u9879\u76EE (project.feishu.cn)", value: "project.feishu.cn" },
-  { name: "Meegle (meegle.com)", value: "meegle.com" },
-  { name: "\u81EA\u5B9A\u4E49\u57DF\u540D", value: "__custom__" }
-];
-function normalizeHost(raw) {
-  const trimmed = raw.trim();
-  try {
-    const url = new URL(trimmed.includes("://") ? trimmed : `https://${trimmed}`);
-    return url.host;
-  } catch {
-    return trimmed;
-  }
-}
-async function promptHost() {
-  const choice = await select({
-    message: "\u9009\u62E9\u7AD9\u70B9",
-    choices: PRESET_HOSTS
-  });
-  if (choice === "__custom__") {
-    const raw = await input({
-      message: "\u8F93\u5165\u7AD9\u70B9\u57DF\u540D\uFF08\u652F\u6301\u7C98\u8D34\u5B8C\u6574 URL\uFF09",
-      validate: (val) => val.trim() ? true : "\u57DF\u540D\u4E0D\u80FD\u4E3A\u7A7A"
-    });
-    return normalizeHost(raw);
-  }
-  return choice;
-}
-async function checkFirstRun(profileName) {
-  if (hasEnvAuth()) return;
-  const profile = profileName ?? await getCurrentProfileName();
-  const config = await loadConfig(profile);
-  const needsHost = !config.host;
-  const store = await createTokenStore(profile);
-  const tokenManager = new TokenManager(store, config.host);
-  const needsAuth = !await tokenManager.isAuthenticated();
-  if (!needsHost && !needsAuth) return;
-  if (!process.stdin.isTTY) {
-    console.error("\n  \u9519\u8BEF\uFF1AMeegle CLI \u672A\u521D\u59CB\u5316\uFF0C\u4E14\u5F53\u524D\u73AF\u5883\u4E0D\u652F\u6301\u4EA4\u4E92\u5F0F\u5F15\u5BFC\u3002\n");
-    console.error("  \u8BF7\u901A\u8FC7\u4EE5\u4E0B\u65B9\u5F0F\u4E4B\u4E00\u5B8C\u6210\u914D\u7F6E\uFF1A");
-    console.error("    1. \u8BBE\u7F6E\u73AF\u5883\u53D8\u91CF: MEEGLE_HOST \u548C MEEGLE_USER_ACCESS_TOKEN");
-    console.error("    2. \u5728\u4EA4\u4E92\u5F0F\u7EC8\u7AEF\u4E2D\u8FD0\u884C: meegle config init && meegle auth login\n");
-    process.exit(1);
-  }
-  console.log("\n  \u6B22\u8FCE\u4F7F\u7528 Meegle CLI\uFF01\u9996\u6B21\u4F7F\u7528\u9700\u8981\u5B8C\u6210\u521D\u59CB\u5316\u3002\n");
-  if (needsHost) {
-    const host = await promptHost();
-    config.host = host;
-    await saveConfig(config, profile);
-    console.log(`
-  \u2713 \u914D\u7F6E\u5DF2\u4FDD\u5B58: host=${host}
-`);
-  }
-  if (needsAuth) {
-    const tokenData = await startAuthCodeFlow(config.host);
-    await tokenManager.saveToken(tokenData);
-    console.log("\n  \u2713 \u767B\u5F55\u6210\u529F\uFF01\n");
-  }
-  console.log("  \u521D\u59CB\u5316\u5B8C\u6210\u3002\u8BF7\u91CD\u65B0\u6267\u884C\u60A8\u7684\u547D\u4EE4\u3002\n");
-  process.exit(0);
-}
-
-// src/commands/auth/login.ts
-init_errors();
-
-// src/output/table.ts
-import Table from "cli-table3";
-function renderTable(data) {
-  if (data.length === 0) return "(no data)";
-  const headers = Object.keys(data[0]);
-  const table = new Table({ head: headers });
-  for (const row of data) {
-    table.push(headers.map((h) => String(row[h] ?? "")));
-  }
-  return table.toString();
-}
-
-// src/output/formatter.ts
-var VALID_FORMATS = /* @__PURE__ */ new Set(["json", "table", "ndjson"]);
-function validateFormat(format) {
-  if (!VALID_FORMATS.has(format)) {
-    throw new Error(`\u4E0D\u652F\u6301\u7684\u8F93\u51FA\u683C\u5F0F "${format}"\uFF0C\u53EF\u9009: json, table, ndjson`);
-  }
-  return format;
-}
-function formatOutput(data, format) {
-  switch (format) {
-    case "json":
-      return JSON.stringify(data, null, 2);
-    case "ndjson":
-      if (Array.isArray(data)) {
-        return data.map((item) => JSON.stringify(item)).join("\n");
-      }
-      return JSON.stringify(data);
-    case "table":
-      return formatAsTable(data);
-  }
-}
-function formatAsTable(data) {
-  if (data === null || data === void 0) return "(no data)";
-  if (Array.isArray(data)) {
-    if (data.length === 0) return "(no data)";
-    if (typeof data[0] === "object" && data[0] !== null) {
-      return renderTable(data);
-    }
-    return data.map(String).join("\n");
-  }
-  if (typeof data === "object") {
-    const entries = Object.entries(data);
-    if (entries.length === 0) return "(no data)";
-    return renderTable(entries.map(([key, value]) => ({
-      key,
-      value: typeof value === "object" ? JSON.stringify(value) : value
-    })));
-  }
-  return String(data);
-}
-
-// src/commands/auth/login.ts
-var PRESET_HOSTS2 = [
-  { name: "\u98DE\u4E66\u9879\u76EE (project.feishu.cn)", value: "project.feishu.cn" },
-  { name: "Meegle (meegle.com)", value: "meegle.com" },
-  { name: "\u81EA\u5B9A\u4E49\u57DF\u540D", value: "__custom__" }
-];
-async function resolveHost(profile, hostFlag) {
-  if (hostFlag) {
-    const host2 = normalizeHost(hostFlag);
-    const config2 = await loadConfig(profile);
-    config2.host = host2;
-    await saveConfig(config2, profile);
-    return host2;
-  }
-  const config = await loadConfig(profile);
-  const envHost = getHost();
-  if (envHost) return envHost;
-  if (config.host) return config.host;
-  const choice = await select2({
-    message: "\u9009\u62E9\u7AD9\u70B9",
-    choices: PRESET_HOSTS2
-  });
-  let host;
-  if (choice === "__custom__") {
-    const raw = await input2({
-      message: "\u8F93\u5165\u7AD9\u70B9\u57DF\u540D\uFF08\u652F\u6301\u7C98\u8D34\u5B8C\u6574 URL\uFF09",
-      validate: (val) => val.trim() ? true : "\u57DF\u540D\u4E0D\u80FD\u4E3A\u7A7A"
-    });
-    host = normalizeHost(raw);
-  } else {
-    host = choice;
-  }
-  config.host = host;
-  await saveConfig(config, profile);
-  console.log(`\u2713 \u914D\u7F6E\u5DF2\u4FDD\u5B58: host=${host}`);
-  return host;
-}
-function registerLogin(auth) {
-  auth.command("login").description("\u767B\u5F55\u98DE\u4E66\u9879\u76EE").option("--device-code", "\u4F7F\u7528 Device Code \u6D41\u7A0B\uFF08\u65E0\u6D4F\u89C8\u5668\u73AF\u5883\uFF09").option("--phase <phase>", "Device Code \u9636\u6BB5: init \u6216 poll").option("--host <host>", "\u6307\u5B9A\u7AD9\u70B9\u57DF\u540D\uFF08\u8DF3\u8FC7\u4EA4\u4E92\u5F0F\u9009\u62E9\uFF09").option("--device-code-value <code>", "poll \u9636\u6BB5\u7684 device_code").option("--client-id <id>", "poll \u9636\u6BB5\u7684 client_id").option("--interval <seconds>", "poll \u8F6E\u8BE2\u95F4\u9694\uFF08\u79D2\uFF09", "5").option("--expires-in <seconds>", "poll \u8D85\u65F6\u65F6\u95F4\uFF08\u79D2\uFF09", "600").option("--once", "poll \u9636\u6BB5\u5355\u6B21\u5C1D\u8BD5\uFF0C\u7ACB\u5373\u8FD4\u56DE\u7ED3\u679C\uFF08\u4E0D\u963B\u585E\uFF09").option("--format <format>", "\u8F93\u51FA\u683C\u5F0F: json, table, ndjson", "table").action(async (options) => {
-    const profileName = auth.parent?.opts().profile ?? await getCurrentProfileName();
-    const format = validateFormat(options.format);
-    const config = await loadConfig(profileName);
-    if (options.phase === "init") {
-      if (!options.deviceCode) {
-        throw new ClientError("--phase \u4EC5\u5728 --device-code \u6A21\u5F0F\u4E0B\u53EF\u7528", "INVALID_OPTION");
-      }
-      const host2 = await resolveHost(profileName, options.host);
-      const result = await startDeviceCodeInit(host2, config.headers);
-      console.log(formatOutput(result, format));
-      return;
-    }
-    if (options.phase === "poll") {
-      if (!options.deviceCode) {
-        throw new ClientError("--phase \u4EC5\u5728 --device-code \u6A21\u5F0F\u4E0B\u53EF\u7528", "INVALID_OPTION");
-      }
-      if (!options.deviceCodeValue || !options.clientId) {
-        throw new ClientError("--phase poll \u9700\u8981 --device-code-value \u548C --client-id", "MISSING_OPTION");
-      }
-      const host2 = await resolveHost(profileName, options.host);
-      if (options.once) {
-        const result = await pollDeviceCodeOnce({
-          host: host2,
-          device_code: options.deviceCodeValue,
-          client_id: options.clientId,
-          customHeaders: config.headers
-        });
-        if (result.status === "ok" && result.token_data) {
-          const store3 = await createTokenStore(profileName);
-          const tokenManager3 = new TokenManager(store3, host2);
-          await tokenManager3.saveToken(result.token_data);
-          console.log(formatOutput({ status: "ok", message: "\u767B\u5F55\u6210\u529F" }, format));
-        } else {
-          console.log(formatOutput({ status: result.status }, format));
-        }
-        return;
-      }
-      const tokenData2 = await startDeviceCodePoll({
-        host: host2,
-        device_code: options.deviceCodeValue,
-        client_id: options.clientId,
-        interval: Number(options.interval),
-        expires_in: Number(options.expiresIn),
-        customHeaders: config.headers
-      });
-      const store2 = await createTokenStore(profileName);
-      const tokenManager2 = new TokenManager(store2, host2);
-      await tokenManager2.saveToken(tokenData2);
-      console.log(formatOutput({ status: "ok", message: "\u767B\u5F55\u6210\u529F" }, format));
-      return;
-    }
-    const host = await resolveHost(profileName, options.host);
-    const tokenData = options.deviceCode ? await startDeviceCodeFlow(host, config.headers) : await startAuthCodeFlow(host, config.headers);
-    const store = await createTokenStore(profileName);
-    const tokenManager = new TokenManager(store, host);
-    await tokenManager.saveToken(tokenData);
-    console.log(`\u2713 [${profileName}] \u767B\u5F55\u6210\u529F\uFF01`);
-  });
-}
-
-// src/commands/auth/logout.ts
-init_config();
-function registerLogout(auth) {
-  auth.command("logout").description("\u9000\u51FA\u767B\u5F55\uFF0C\u6E05\u9664\u672C\u5730\u51ED\u636E").action(async () => {
-    const profileName = auth.parent?.opts().profile;
-    const profile = profileName ?? await getCurrentProfileName();
-    const store = await createTokenStore(profile);
-    await store.clear();
-    console.log("\u2713 \u5DF2\u9000\u51FA\u767B\u5F55");
-  });
-}
-
-// src/commands/auth/status.ts
-init_env();
-init_config();
-async function buildStatusResult(profile) {
-  const config = await loadConfig(profile);
-  const host = config.host ?? null;
-  if (getUserToken()) {
-    return { authenticated: true, host, source: "env", expires_in_minutes: null };
-  }
-  const store = await createTokenStore(profile);
-  const token = await store.load();
-  if (!token) {
-    return { authenticated: false, host, source: null, expires_in_minutes: null };
-  }
-  let expiresInMinutes = null;
-  if (token.expiresAt) {
-    const remaining = token.expiresAt - Date.now();
-    expiresInMinutes = remaining > 0 ? Math.floor(remaining / 6e4) : 0;
-  }
-  return {
-    authenticated: true,
-    host,
-    source: "token_store",
-    expires_in_minutes: expiresInMinutes
-  };
-}
-function registerStatus(auth) {
-  auth.command("status").description("\u67E5\u770B\u5F53\u524D\u767B\u5F55\u72B6\u6001\u548C Token \u6709\u6548\u671F").option("--format <format>", "\u8F93\u51FA\u683C\u5F0F", "table").action(async (options) => {
-    const profileName = auth.parent?.opts().profile ?? await getCurrentProfileName();
-    const format = validateFormat(options.format);
-    const result = await buildStatusResult(profileName);
-    if (format === "json") {
-      console.log(formatOutput(result, "json"));
-      if (!result.authenticated) process.exit(1);
-      return;
-    }
-    if (result.source === "env") {
-      console.log("\u5DF2\u767B\u5F55\uFF08\u901A\u8FC7\u73AF\u5883\u53D8\u91CF MEEGLE_USER_ACCESS_TOKEN\uFF09");
-      return;
-    }
-    if (!result.authenticated) {
-      console.log("\u672A\u767B\u5F55");
-      process.exit(1);
-    }
-    console.log("\u5DF2\u767B\u5F55");
-    if (result.expires_in_minutes !== null) {
-      if (result.expires_in_minutes > 0) {
-        console.log(`Token \u6709\u6548\u671F\u5269\u4F59: ${result.expires_in_minutes} \u5206\u949F`);
-      } else {
-        console.log("Token \u5DF2\u8FC7\u671F\uFF0C\u5C06\u5728\u4E0B\u6B21\u4F7F\u7528\u65F6\u81EA\u52A8\u5237\u65B0");
-      }
-    }
-  });
-}
-
-// src/commands/auth/index.ts
-function registerAuthCommands(program) {
-  const auth = program.command("auth").description("\u8BA4\u8BC1\u7BA1\u7406");
-  registerLogin(auth);
-  registerLogout(auth);
-  registerStatus(auth);
-}
-
-// src/commands/config/init.ts
-init_config();
-function registerInit(config) {
-  config.command("init").description("\u521D\u59CB\u5316\u914D\u7F6E").option("--host <host>", "\u7AD9\u70B9\u57DF\u540D", "meegle.com").action(async (options) => {
-    const profile = config.parent?.opts().profile ?? await getCurrentProfileName();
-    await saveConfig({ host: options.host }, profile);
-    console.log(`\u2713 [${profile}] \u914D\u7F6E\u5DF2\u521D\u59CB\u5316: host=${options.host}`);
-  });
-}
-
-// src/commands/config/show.ts
-init_config();
-function registerShow(config) {
-  config.command("show").description("\u67E5\u770B\u5F53\u524D\u914D\u7F6E").action(async () => {
-    const profile = config.parent?.opts().profile ?? await getCurrentProfileName();
-    const cfg = await loadConfig(profile);
-    console.log(`Profile: ${profile}`);
-    console.log(JSON.stringify(cfg, null, 2));
-  });
-}
-
-// src/commands/config/set.ts
-init_config();
-function registerSet(config) {
-  config.command("set <key> <value>").description("\u4FEE\u6539\u5F53\u524D profile \u7684\u914D\u7F6E\u9879").action(async (key, value) => {
-    const profile = config.parent?.opts().profile ?? await getCurrentProfileName();
-    await setProfileValue(profile, key, value);
-    console.log(`\u2713 [${profile}] ${key}=${value}`);
-  });
-}
-
-// src/commands/config/get.ts
-init_config();
-function registerGet(config) {
-  config.command("get <key>").description("\u67E5\u770B\u5F53\u524D profile \u7684\u914D\u7F6E\u9879").action(async (key) => {
-    const profile = config.parent?.opts().profile ?? await getCurrentProfileName();
-    const value = await getProfileValue(profile, key);
-    if (value === void 0) {
-      console.log("(\u672A\u8BBE\u7F6E)");
-    } else {
-      console.log(String(value));
-    }
-  });
-}
-
-// src/commands/config/profile.ts
-init_config();
-import { select as select3, input as input3 } from "@inquirer/prompts";
-var PRESET_HOSTS3 = [
-  { name: "\u98DE\u4E66\u9879\u76EE (project.feishu.cn)", value: "project.feishu.cn" },
-  { name: "Meegle (meegle.com)", value: "meegle.com" },
-  { name: "\u81EA\u5B9A\u4E49\u57DF\u540D", value: "__custom__" }
-];
-function registerProfile(config) {
-  const profile = config.command("profile").description("\u73AF\u5883\u7BA1\u7406");
-  profile.command("list").description("\u5217\u51FA\u6240\u6709 profile").action(async () => {
-    const { names, current } = await listProfiles();
-    if (names.length === 0) {
-      console.log("\u6682\u65E0 profile\uFF0C\u4F7F\u7528 meegle config profile create <name> \u521B\u5EFA");
-      return;
-    }
-    for (const name of names) {
-      const marker = name === current ? " (\u5F53\u524D)" : "";
-      console.log(`  ${name}${marker}`);
-    }
-  });
-  profile.command("current").description("\u663E\u793A\u5F53\u524D profile").action(async () => {
-    const name = await getCurrentProfileName();
-    console.log(name);
-  });
-  profile.command("use <name>").description("\u5207\u6362\u5F53\u524D profile").action(async (name) => {
-    const { names } = await listProfiles();
-    if (!names.includes(name)) {
-      console.error(`profile "${name}" \u4E0D\u5B58\u5728`);
-      process.exit(1);
-    }
-    await setCurrentProfileName(name);
-    console.log(`\u2713 \u5DF2\u5207\u6362\u5230 ${name}`);
-  });
-  profile.command("create <name>").description("\u521B\u5EFA\u65B0 profile").action(async (name) => {
-    const { names } = await listProfiles();
-    if (names.includes(name)) {
-      console.error(`profile "${name}" \u5DF2\u5B58\u5728`);
-      process.exit(1);
-    }
-    const choice = await select3({
-      message: "\u9009\u62E9\u7AD9\u70B9",
-      choices: PRESET_HOSTS3
-    });
-    let host;
-    if (choice === "__custom__") {
-      const raw = await input3({
-        message: "\u8F93\u5165\u7AD9\u70B9\u57DF\u540D\uFF08\u652F\u6301\u7C98\u8D34\u5B8C\u6574 URL\uFF09",
-        validate: (val) => val.trim() ? true : "\u57DF\u540D\u4E0D\u80FD\u4E3A\u7A7A"
-      });
-      host = normalizeHost(raw);
-    } else {
-      host = choice;
-    }
-    await saveConfig({ host }, name);
-    console.log(`\u2713 profile "${name}" \u5DF2\u521B\u5EFA (host=${host})`);
-    const shouldLogin = await select3({
-      message: "\u662F\u5426\u7ACB\u5373\u767B\u5F55\uFF1F",
-      choices: [
-        { name: "\u662F", value: true },
-        { name: "\u5426", value: false }
-      ]
-    });
-    if (shouldLogin) {
-      const tokenData = await startAuthCodeFlow(host);
-      const store = await createTokenStore(name);
-      const tokenManager = new TokenManager(store, host);
-      await tokenManager.saveToken(tokenData);
-      console.log("\u2713 \u767B\u5F55\u6210\u529F\uFF01");
-    }
-    await setCurrentProfileName(name);
-    console.log(`\u2713 \u5DF2\u5207\u6362\u5230 ${name}`);
-  });
-  profile.command("delete <name>").description("\u5220\u9664 profile \u53CA\u5176\u51ED\u636E").action(async (name) => {
-    const { current } = await listProfiles();
-    if (name === current) {
-      console.error(`\u4E0D\u80FD\u5220\u9664\u5F53\u524D\u6B63\u5728\u4F7F\u7528\u7684 profile "${name}"\uFF0C\u8BF7\u5148\u5207\u6362`);
-      process.exit(1);
-    }
-    const store = await createTokenStore(name);
-    await store.clear();
-    await deleteProfile(name);
-    console.log(`\u2713 profile "${name}" \u5DF2\u5220\u9664`);
-  });
-}
-
-// src/commands/config/index.ts
-function registerConfigCommands(program) {
-  const config = program.command("config").description("\u914D\u7F6E\u7BA1\u7406");
-  registerInit(config);
-  registerShow(config);
-  registerSet(config);
-  registerGet(config);
-  registerProfile(config);
-}
-
-// src/dynamic/params-parser.ts
-init_errors();
-function parseSetFlag(input4) {
-  const eqIndex = input4.indexOf("=");
-  if (eqIndex === -1) {
-    throw new ClientError(
-      `--set \u683C\u5F0F\u9519\u8BEF: "${input4}"\uFF0C\u5E94\u4E3A key=value`,
-      "INVALID_SET_FLAG"
-    );
-  }
-  const key = input4.slice(0, eqIndex);
-  const rawValue = input4.slice(eqIndex + 1);
-  let value;
-  try {
-    const parsed = JSON.parse(rawValue);
-    value = typeof parsed === "object" && parsed !== null ? parsed : rawValue;
-  } catch {
-    value = rawValue;
-  }
-  return { field_key: key, field_value: value };
-}
-function parseParams(json) {
-  try {
-    const parsed = JSON.parse(json);
-    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
-      throw new Error("not an object");
-    }
-    return parsed;
-  } catch {
-    throw new ClientError(
-      "--params JSON \u89E3\u6790\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u683C\u5F0F\u662F\u5426\u4E3A\u5408\u6CD5 JSON \u5BF9\u8C61",
-      "INVALID_PARAMS_JSON"
-    );
-  }
-}
-function mergeParams(setFields, params, cliFlags) {
-  const base = params ? { ...params } : {};
-  for (const [key, value] of Object.entries(cliFlags)) {
-    if (value !== void 0) {
-      base[key] = value;
-    }
-  }
-  if (setFields.length > 0) {
-    const existingFields = Array.isArray(base.fields) ? base.fields : [];
-    const setKeys = new Set(setFields.map((f) => f.field_key));
-    const kept = existingFields.filter((f) => !setKeys.has(f.field_key));
-    base.fields = [...kept, ...setFields];
-  }
-  return base;
-}
-
-// src/output/fields.ts
-function parseFieldList(input4) {
-  if (!input4) return [];
-  return input4.split(",").map((f) => f.trim()).filter(Boolean);
-}
-function filterFields(data, fields) {
-  if (fields.length === 0) return data;
-  if (Array.isArray(data)) {
-    return data.map((item) => pickFields(item, fields));
-  }
-  return pickFields(data, fields);
-}
-function pickFields(obj, fields) {
-  if (typeof obj !== "object" || obj === null) return obj;
-  const result = {};
-  for (const field of fields) {
-    if (field.includes(".")) {
-      result[field] = resolveDotPath(obj, field.split("."));
-    } else if (field in obj) {
-      result[field] = obj[field];
-    }
-  }
-  return result;
-}
-function resolveDotPath(current, segments) {
-  for (let i = 0; i < segments.length; i++) {
-    if (current === null || current === void 0) return void 0;
-    if (Array.isArray(current)) {
-      const remaining = segments.slice(i);
-      return current.map((item) => resolveDotPath(item, remaining));
-    }
-    if (typeof current === "object") {
-      current = current[segments[i]];
-    } else {
-      return void 0;
-    }
-  }
-  return current;
-}
-
-// src/dynamic/response.ts
-init_errors();
-
-// src/core/logger.ts
-import chalk from "chalk";
-var LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
-var currentLevel = "info";
-function setLogLevel(level) {
-  currentLevel = level;
-}
-function shouldLog(level) {
-  return LEVELS[level] >= LEVELS[currentLevel];
-}
-var logger = {
-  debug: (msg) => {
-    if (shouldLog("debug")) console.error(chalk.gray(`[debug] ${msg}`));
-  },
-  info: (msg) => {
-    if (shouldLog("info")) console.error(chalk.blue(`[info] ${msg}`));
-  },
-  warn: (msg) => {
-    if (shouldLog("warn")) console.error(chalk.yellow(`[warn] ${msg}`));
-  },
-  error: (msg) => {
-    if (shouldLog("error")) console.error(chalk.red(`[error] ${msg}`));
-  }
-};
-
-// src/dynamic/response.ts
-function unwrapResponse(raw) {
-  if (raw === null || raw === void 0) return void 0;
-  const response = raw;
-  const content = response.content;
-  if (!Array.isArray(content)) return void 0;
-  if (response.isError) {
-    const allTexts = content.filter((e) => e.type === "text" && e.text).map((e) => e.text);
-    const message = allTexts.join("\n") || "\u670D\u52A1\u7AEF\u8FD4\u56DE\u9519\u8BEF";
-    throw new ServerError(message, "SERVER_CALL_FAILED");
-  }
-  const dataTexts = [];
-  for (const entry of content) {
-    if (entry.type !== "text" || !entry.text) continue;
-    if (entry.text.startsWith("logid:")) {
-      logger.debug(entry.text);
-    } else {
-      dataTexts.push(entry.text);
-    }
-  }
-  if (dataTexts.length === 0) return void 0;
-  const text = dataTexts[0];
-  try {
-    return JSON.parse(text);
-  } catch {
-    return text;
-  }
-}
-
-// src/dynamic/register.ts
-init_errors();
-var RESOURCE_DESCRIPTIONS = {
-  workitem: "\u5DE5\u4F5C\u9879\u57DF \u2014 \u5DE5\u4F5C\u9879\u5B9E\u4F8B\u7684 CRUD \u548C\u6A21\u578B\u914D\u7F6E\uFF0C\u901A\u8FC7 work-item-id \u6807\u8BC6",
-  workflow: "\u5DE5\u4F5C\u6D41\u57DF \u2014 \u8282\u70B9\u6D41\u8F6C\u4E0E\u72B6\u6001\u6D41\u8F6C\uFF0C\u4F9D\u8D56 workitem \u7684 work-item-id",
-  subtask: "\u5B50\u4EFB\u52A1 \u2014 \u8282\u70B9\u4E0B\u7684\u5B50\u4EFB\u52A1\u64CD\u4F5C\uFF0C\u4F9D\u8D56 workflow \u7684 node-id",
-  comment: "\u8BC4\u8BBA\u57DF \u2014 \u8DE8\u5B9E\u4F53\u8BC4\u8BBA\uFF0C\u5F53\u524D\u901A\u8FC7 work-item-id \u5173\u8054",
-  workhour: "\u5DE5\u65F6\u57DF \u2014 \u5DE5\u65F6\u8BB0\u5F55\u4E0E\u6392\u671F\uFF0C\u4F9D\u8D56 workitem \u7684 work-item-id",
-  relation: "\u5173\u7CFB\u57DF \u2014 \u5DE5\u4F5C\u9879\u4E4B\u95F4\u7684\u5173\u8054\u5173\u7CFB\u5B9A\u4E49\u4E0E\u67E5\u8BE2",
-  mywork: "\u5DE5\u4F5C\u53F0\u57DF \u2014 \u8DE8\u7A7A\u95F4\u7684\u4E2A\u4EBA\u5F85\u529E/\u5DF2\u529E",
-  view: "\u89C6\u56FE\u57DF \u2014 \u89C6\u56FE\u7684\u521B\u5EFA\u3001\u67E5\u770B\u3001\u66F4\u65B0\u3001\u641C\u7D22",
-  chart: "\u5EA6\u91CF\u57DF \u2014 \u56FE\u8868\u67E5\u770B\u4E0E\u5217\u8868\uFF0C\u4F9D\u8D56 view \u7684 view-id",
-  team: "\u4EBA\u5458\u57DF \u2014 \u56E2\u961F\u5217\u8868\u4E0E\u6210\u5458\u67E5\u8BE2",
-  user: "\u4EBA\u5458\u57DF \u2014 \u7528\u6237\u641C\u7D22\uFF0C\u652F\u6301\u540D\u79F0\u6A21\u7CCA\u5339\u914D",
-  project: "\u7A7A\u95F4\u57DF \u2014 \u7A7A\u95F4\u4FE1\u606F\u641C\u7D22"
-};
-var registeredCommands = [];
-function registerDynamicCommands(program, commands, client) {
-  registeredCommands = commands;
-  const groups = /* @__PURE__ */ new Map();
-  for (const cmd of commands) {
-    const list = groups.get(cmd.resource) ?? [];
-    list.push(cmd);
-    groups.set(cmd.resource, list);
-  }
-  for (const [resource, cmds] of groups) {
-    const group = program.command(resource).description(RESOURCE_DESCRIPTIONS[resource] ?? `${resource} \u64CD\u4F5C`);
-    for (const cmd of cmds) {
-      const flagSummary = buildFlagSummary(cmd);
-      const sub = group.command(cmd.method).description(`${cmd.description ?? ""}  ${flagSummary}`);
-      for (const param of cmd.parameters) {
-        if (param.name === "url") continue;
-        const kebab = param.name.replace(/_/g, "-");
-        let desc = param.description ?? "";
-        if (param.required) desc = `[\u5FC5\u586B] ${desc}`;
-        if (param.type === "array") {
-          const itemType = param.items?.type;
-          if (itemType === "object") {
-            desc += "\uFF08\u591A\u4E2A JSON \u5BF9\u8C61\uFF0C\u91CD\u590D\u4F20\u5165\uFF09";
-          } else if (itemType === "number") {
-            desc += "\uFF08\u591A\u4E2A\u6570\u5B57\uFF0C\u9017\u53F7\u5206\u9694\u6216\u91CD\u590D\u4F20\u5165\uFF09";
-          } else {
-            desc += "\uFF08\u591A\u4E2A\u503C\uFF0C\u9017\u53F7\u5206\u9694\u6216\u91CD\u590D\u4F20\u5165\uFF09";
-          }
-        }
-        if (param.type === "object") desc += "\uFF08JSON \u683C\u5F0F\uFF09";
-        const typeLabel = formatTypeLabel(param);
-        if (param.type === "boolean") {
-          sub.option(`--${kebab}`, desc);
-        } else if (param.type === "array") {
-          sub.option(`--${kebab} <${typeLabel}>`, desc, collect, []);
-        } else {
-          sub.option(`--${kebab} <${typeLabel}>`, desc);
-        }
-      }
-      sub.option("--params <json>", "\u5B8C\u6574 JSON \u53C2\u6570\uFF08--set \u548C flag \u4F1A\u8986\u76D6\u540C\u540D\u5B57\u6BB5\uFF09");
-      if (cmd.hasFields) {
-        sub.option("--set <key=value>", "\u8BBE\u7F6E\u5B57\u6BB5 key=value\uFF0C\u53EF\u91CD\u590D\uFF0Cvalue \u652F\u6301 JSON", collect, []);
-      }
-      sub.action(async (options) => {
-        const { params: rawParams, set: rawSet, ...cliFlags } = options;
-        const snakeFlags = {};
-        for (const param of cmd.parameters) {
-          const camelKey = snakeToCamel(param.name);
-          const value = cliFlags[camelKey];
-          if (value === void 0) continue;
-          if (param.type === "array") {
-            const arr = Array.isArray(value) ? value : [value];
-            const itemType = param.items?.type;
-            const expanded = itemType === "object" ? arr : arr.flatMap((s) => s.split(",").map((v) => v.trim()));
-            const filtered = expanded.filter((s) => s !== "");
-            if (filtered.length > 0) {
-              snakeFlags[param.name] = convertArrayItems(filtered, itemType);
-            }
-          } else if (param.type === "number" && typeof value === "string") {
-            const num = Number(value);
-            if (Number.isNaN(num)) {
-              throw new ClientError(
-                `\u53C2\u6570 --${param.name.replace(/_/g, "-")} \u9700\u8981\u6570\u5B57\uFF0C\u6536\u5230: "${value}"`,
-                "CLIENT_INVALID_TYPE"
-              );
-            }
-            snakeFlags[param.name] = num;
-          } else {
-            snakeFlags[param.name] = value;
-          }
-        }
-        const setFields = (rawSet ?? []).map(parseSetFlag);
-        const parsedParams = rawParams ? parseParams(rawParams) : void 0;
-        const finalParams = mergeParams(setFields, parsedParams, snakeFlags);
-        const missing = cmd.parameters.filter((p) => p.required && p.name !== "url").filter((p) => finalParams[p.name] === void 0 || finalParams[p.name] === null).map((p) => `--${p.name.replace(/_/g, "-")}`);
-        if (missing.length > 0) {
-          throw new ClientError(
-            `\u7F3A\u5C11\u5FC5\u586B\u53C2\u6570: ${missing.join(", ")}`,
-            "CLIENT_MISSING_REQUIRED",
-            `\u4F7F\u7528 meegle inspect ${cmd.resource}.${cmd.method} \u67E5\u770B\u53C2\u6570\u8BE6\u60C5`
-          );
-        }
-        const raw = await client.callTool(cmd.toolName, finalParams);
-        let result = unwrapResponse(raw);
-        if (result !== void 0) {
-          const rootOpts = program.opts();
-          const selectStr = rootOpts.select;
-          if (selectStr) {
-            const fields = parseFieldList(selectStr);
-            result = filterFields(result, fields);
-          }
-          const format = validateFormat(rootOpts.format ?? "json");
-          console.log(formatOutput(result, format));
-        }
-      });
-    }
-  }
-}
-function collect(value, previous) {
-  return [...previous, value];
-}
-function formatTypeLabel(param) {
-  if (param.type === "array" && param.items?.type) {
-    return `array<${param.items.type}>`;
-  }
-  return param.type;
-}
-function convertArrayItems(values, itemType) {
-  if (itemType === "number") {
-    return values.map((v) => {
-      const n = Number(v);
-      if (Number.isNaN(n)) {
-        throw new ClientError(
-          `\u6570\u7EC4\u5143\u7D20\u9700\u8981\u6570\u5B57\uFF0C\u6536\u5230: "${v}"`,
-          "CLIENT_INVALID_TYPE"
-        );
-      }
-      return n;
-    });
-  }
-  if (itemType === "object") {
-    return values.map((v) => {
-      try {
-        return JSON.parse(v);
-      } catch {
-        throw new ClientError(
-          `\u65E0\u6CD5\u89E3\u6790 JSON: ${v}`,
-          "CLIENT_INVALID_JSON"
-        );
-      }
-    });
-  }
-  return values;
-}
-function snakeToCamel(s) {
-  return s.replace(/_(\w)/g, (_, c) => c.toUpperCase());
-}
-function buildFlagSummary(cmd) {
-  const flags = [];
-  for (const param of cmd.parameters) {
-    if (param.name === "url") continue;
-    const kebab = param.name.replace(/_/g, "-");
-    flags.push(param.required ? `--${kebab}*` : `--${kebab}`);
-  }
-  if (cmd.hasFields) flags.push("--set");
-  if (flags.length === 0) return "";
-  return `[${flags.join(", ")}]`;
-}
-
-// src/commands/inspect.ts
-function registerInspectCommand(program) {
-  program.command("inspect [command]").description("\u67E5\u770B\u547D\u4EE4\u7684\u53C2\u6570\u8BE6\u60C5\uFF08\u5982 inspect workitem.create\uFF09").action(async (command) => {
-    if (!command) {
-      const grouped = /* @__PURE__ */ new Map();
-      for (const cmd2 of registeredCommands) {
-        const list = grouped.get(cmd2.resource) ?? [];
-        list.push(cmd2.method);
-        grouped.set(cmd2.resource, list);
-      }
-      for (const [resource2, methods] of grouped) {
-        console.log(`${resource2}: ${methods.join(", ")}`);
-      }
-      return;
-    }
-    const parts = command.includes(".") ? command.split(".") : command.split(" ");
-    const [resource, method] = parts;
-    const cmd = registeredCommands.find(
-      (c) => c.resource === resource && c.method === method
-    );
-    if (!cmd) {
-      console.error(`\u672A\u627E\u5230\u547D\u4EE4: ${command}`);
-      console.error("\u4F7F\u7528 meegle inspect \u67E5\u770B\u6240\u6709\u53EF\u7528\u547D\u4EE4");
-      process.exit(1);
-    }
-    const params = cmd.parameters.filter((p) => p.name !== "url").map((p) => ({
-      flag: `--${p.name.replace(/_/g, "-")}`,
-      type: formatTypeLabel(p),
-      required: p.required ?? false,
-      description: p.description ?? ""
-    }));
-    if (cmd.hasFields) {
-      params.push({
-        flag: "--set",
-        type: "key=value",
-        required: false,
-        description: "\u8BBE\u7F6E\u5B57\u6BB5 key=value\uFF0C\u53EF\u91CD\u590D\uFF0Cvalue \u652F\u6301 JSON"
-      });
-    }
-    params.push({
-      flag: "--params",
-      type: "json",
-      required: false,
-      description: "\u5B8C\u6574 JSON \u53C2\u6570\uFF08--set \u548C flag \u4F1A\u8986\u76D6\u540C\u540D\u5B57\u6BB5\uFF09"
-    });
-    console.log(`
-  meegle ${cmd.resource} ${cmd.method}`);
-    console.log(`  ${cmd.description ?? ""}
-`);
-    const required = params.filter((p) => p.required);
-    const optional = params.filter((p) => !p.required);
-    if (required.length > 0) {
-      console.log("  \u5FC5\u586B\u53C2\u6570:");
-      for (const p of required) {
-        console.log(`    ${p.flag} <${p.type}>`);
-        if (p.description) console.log(`      ${p.description}`);
-      }
-      console.log();
-    }
-    if (optional.length > 0) {
-      console.log("  \u53EF\u9009\u53C2\u6570:");
-      for (const p of optional) {
-        console.log(`    ${p.flag} <${p.type}>`);
-        if (p.description) console.log(`      ${p.description}`);
-      }
-      console.log();
-    }
-  });
-}
-
-// src/commands/index.ts
-function registerStaticCommands(program) {
-  registerAuthCommands(program);
-  registerConfigCommands(program);
-  registerInspectCommand(program);
-}
-
-// src/dynamic/mapper.ts
-var FALLBACK_TABLE = {
-  // WorkItem 工作项域 (9)
-  create_workitem: { resource: "workitem", method: "create", hasFields: true },
-  get_workitem_brief: { resource: "workitem", method: "get" },
-  update_field: { resource: "workitem", method: "update", hasFields: true },
-  search_by_mql: { resource: "workitem", method: "query" },
-  get_workitem_op_record: { resource: "workitem", method: "list-op-records" },
-  list_workitem_types: { resource: "workitem", method: "meta-types" },
-  get_workitem_field_meta: { resource: "workitem", method: "meta-create-fields" },
-  list_workitem_field_config: { resource: "workitem", method: "meta-fields" },
-  list_workitem_role_config: { resource: "workitem", method: "meta-roles" },
-  // WorkFlow 工作流域 (6)
-  transition_node: { resource: "workflow", method: "transition" },
-  get_node_detail: { resource: "workflow", method: "get-node" },
-  update_node: { resource: "workflow", method: "update-node", hasFields: true },
-  list_node_field_config: { resource: "workflow", method: "meta-node-fields" },
-  get_transitable_states: { resource: "workflow", method: "list-state-transitions" },
-  get_transition_required: { resource: "workflow", method: "list-state-required" },
-  // SubTask 子任务 (1)
-  update_node_subtask: { resource: "subtask", method: "update", hasFields: true },
-  // Comment 评论域 (2)
-  add_comment: { resource: "comment", method: "add" },
-  list_workitem_comments: { resource: "comment", method: "list" },
-  // WorkHour 工时域 (2)
-  get_workitem_man_hour_records: { resource: "workhour", method: "list-records" },
-  list_schedule: { resource: "workhour", method: "list-schedule" },
-  // Relation 关系域 (2)
-  list_workitem_relations: { resource: "relation", method: "meta-definitions" },
-  list_related_workitems: { resource: "relation", method: "list" },
-  // MyWork 工作台域 (1)
-  list_todo: { resource: "mywork", method: "todo" },
-  // View 视图域 (4)
-  create_fixed_view: { resource: "view", method: "create-fixed" },
-  get_view_detail: { resource: "view", method: "get" },
-  update_fixed_view: { resource: "view", method: "update-fixed" },
-  search_view_by_title: { resource: "view", method: "search" },
-  // Chart 度量域 (2)
-  get_chart_detail: { resource: "chart", method: "get" },
-  list_charts: { resource: "chart", method: "list" },
-  // UserGroup 人员域 (3)
-  list_project_team: { resource: "team", method: "list" },
-  list_team_members: { resource: "team", method: "list-members" },
-  search_user_info: { resource: "user", method: "search" },
-  // Project 空间域 (1)
-  search_project_info: { resource: "project", method: "search" }
-};
-function mapTool(tool) {
-  if (tool.metadata?.resource && tool.metadata?.method) {
-    return {
-      resource: tool.metadata.resource,
-      method: tool.metadata.method,
-      toolName: tool.name,
-      description: tool.description,
-      parameters: tool.parameters ?? []
-    };
-  }
-  const fallback = FALLBACK_TABLE[tool.name];
-  if (fallback) {
-    return {
-      resource: fallback.resource,
-      method: fallback.method,
-      toolName: tool.name,
-      description: tool.description,
-      parameters: tool.parameters ?? [],
-      hasFields: fallback.hasFields
-    };
-  }
-  logger.debug(`\u672A\u77E5 tool "${tool.name}" \u4E0D\u5728\u6620\u5C04\u8868\u4E2D\uFF0C\u4F7F\u7528 name parsing \u56DE\u9000`);
-  const parts = tool.name.split("_");
-  const resource = parts[0];
-  const method = parts.slice(1).join("-");
-  return {
-    resource,
-    method: method || "default",
-    toolName: tool.name,
-    description: tool.description,
-    parameters: tool.parameters ?? []
-  };
-}
-function mapTools(tools) {
-  return tools.map(mapTool);
-}
-
-// src/dynamic/cache.ts
-init_profile_validation();
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { join as join3, dirname } from "path";
-var DEFAULT_TTL_MS = 24 * 60 * 60 * 1e3;
-var ToolCache = class {
-  filePath;
-  ttlMs;
-  constructor(cacheDir, profile = "default", ttlMs = DEFAULT_TTL_MS) {
-    validateProfileName(profile);
-    const filename = profile === "default" ? "tools.json" : `tools-${profile}.json`;
-    this.filePath = join3(cacheDir, filename);
-    this.ttlMs = ttlMs;
-  }
-  async get() {
-    try {
-      const raw = await readFile3(this.filePath, "utf-8");
-      const data = JSON.parse(raw);
-      if (!Array.isArray(data.tools) || typeof data.timestamp !== "number") {
-        return null;
-      }
-      const stale = Date.now() - data.timestamp > this.ttlMs;
-      return { tools: data.tools, stale };
-    } catch {
-      return null;
-    }
-  }
-  async set(tools) {
-    const data = { timestamp: Date.now(), tools };
-    await mkdir3(dirname(this.filePath), { recursive: true });
-    await writeFile3(this.filePath, JSON.stringify(data, null, 2));
-  }
-};
-
-// src/dynamic/discovery.ts
-async function discoverTools(client) {
-  const result = await client.listTools();
-  const tools = result?.tools ?? [];
-  return tools.map(convertTool);
-}
-function convertTool(entry) {
-  const parameters = [];
-  const props = entry.inputSchema?.properties ?? {};
-  const required = new Set(entry.inputSchema?.required ?? []);
-  for (const [name, schema] of Object.entries(props)) {
-    const param = {
-      name,
-      type: schema.type ?? "string",
-      description: schema.description,
-      required: required.has(name)
-    };
-    if (schema.type === "array" && schema.items?.type) {
-      param.items = { type: schema.items.type };
-    }
-    parameters.push(param);
-  }
-  return {
-    name: entry.name,
-    description: entry.description,
-    parameters
-  };
-}
-
-// src/cli.ts
-init_config();
-init_errors();
-
-// src/core/mcp-client.ts
-init_errors();
-var McpClient = class {
-  baseUrl;
-  tokenManager;
-  customHeaders;
-  requestId = 0;
-  constructor(baseUrl, tokenManager, customHeaders) {
-    this.baseUrl = baseUrl;
-    this.tokenManager = tokenManager;
-    this.customHeaders = customHeaders ?? {};
-  }
-  async call(method, params) {
-    try {
-      return await this._doCall(method, params);
-    } catch (err) {
-      if (err instanceof HttpError && err.httpStatus === 401) {
-        const store = this.tokenManager.getStore();
-        const tokenData = await store.load();
-        if (tokenData) {
-          const refreshed = await this.tokenManager.refreshToken(tokenData);
-          if (refreshed) {
-            return await this._doCall(method, params);
-          }
-        }
-        throw new ClientError("\u8BA4\u8BC1\u5DF2\u8FC7\u671F\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55", "AUTH_EXPIRED", "meegle auth login");
-      }
-      throw err;
-    }
-  }
-  async _doCall(method, params) {
-    const token = await this.tokenManager.getToken();
-    const id = ++this.requestId;
-    const body = { jsonrpc: "2.0", id, method, params };
-    const headers = {
-      "Content-Type": "application/json",
-      "User-Agent": "meegle-cli",
-      ...this.customHeaders
-    };
-    if (token) {
-      headers["Authorization"] = `Bearer ${token}`;
-    }
-    const response = await fetch(this.baseUrl, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-      throw new HttpError(
-        `\u670D\u52A1\u7AEF\u8FD4\u56DE\u9519\u8BEF (${response.status})`,
-        "SERVER_HTTP_ERROR",
-        response.status
-      );
-    }
-    const data = await response.json();
-    if (data.error) {
-      throw new ServerError(data.error.message, "SERVER_CALL_FAILED");
-    }
-    return data.result;
-  }
-  async listTools() {
-    return this.call("tools/list");
-  }
-  async callTool(name, params) {
-    return this.call("tools/call", { name, arguments: params });
-  }
-};
-
-// src/cli.ts
-import { readFileSync } from "fs";
-import { join as join4, dirname as dirname2 } from "path";
-import { fileURLToPath } from "url";
-function loadVersion() {
-  try {
-    const dir = dirname2(fileURLToPath(import.meta.url));
-    for (const rel of ["../../package.json", "../package.json"]) {
-      try {
-        const raw = readFileSync(join4(dir, rel), "utf-8");
-        return JSON.parse(raw).version;
-      } catch {
-        continue;
-      }
-    }
-  } catch {
-  }
-  return "0.0.0";
-}
-var version = loadVersion();
-var SKIP_FIRST_RUN = ["config", "auth", "help"];
-function getCommandChain(cmd) {
-  const chain = [];
-  let current = cmd;
-  while (current && current.name() !== "meegle") {
-    chain.unshift(current.name());
-    current = current.parent ?? null;
-  }
-  return chain;
-}
-function extractProfileFromArgv(argv) {
-  for (let i = 0; i < argv.length; i++) {
-    if (argv[i] === "--profile" && i + 1 < argv.length) {
-      return argv[i + 1];
-    }
-    if (argv[i]?.startsWith("--profile=")) {
-      return argv[i].slice("--profile=".length);
-    }
-  }
-  return void 0;
-}
-async function createProgram() {
-  const program = new Command();
-  program.name("meegle").description(`Agent-First CLI for Meegle (Lark Project)
-
-\u9886\u57DF\u6A21\u578B:
-  workitem\uFF08\u5DE5\u4F5C\u9879\uFF09\u2500 \u6838\u5FC3\u5B9E\u4F53\uFF0C\u901A\u8FC7 work-item-id \u6807\u8BC6
-  \u251C\u2500 workflow\uFF08\u5DE5\u4F5C\u6D41\uFF09\u2500 \u8282\u70B9\u6D41\u8F6C\u4E0E\u72B6\u6001\u6D41\u8F6C\uFF0C\u4F9D\u8D56 work-item-id
-  \u2502    \u2514\u2500 subtask\uFF08\u5B50\u4EFB\u52A1\uFF09\u2500 \u8282\u70B9\u4E0B\u7684\u5B50\u4EFB\u52A1\uFF0C\u4F9D\u8D56 node-id
-  \u251C\u2500 comment\uFF08\u8BC4\u8BBA\uFF09\u2500 \u5DE5\u4F5C\u9879\u7684\u8BC4\u8BBA\uFF0C\u4F9D\u8D56 work-item-id
-  \u251C\u2500 workhour\uFF08\u5DE5\u65F6\uFF09\u2500 \u5DE5\u65F6\u8BB0\u5F55\u4E0E\u6392\u671F\uFF0C\u4F9D\u8D56 work-item-id
-  \u2514\u2500 relation\uFF08\u5173\u7CFB\uFF09\u2500 \u5DE5\u4F5C\u9879\u4E4B\u95F4\u7684\u5173\u8054\u5173\u7CFB
-
-  mywork\uFF08\u5DE5\u4F5C\u53F0\uFF09\u2500 \u8DE8\u7A7A\u95F4\u7684\u4E2A\u4EBA\u5F85\u529E/\u5DF2\u529E
-  view\uFF08\u89C6\u56FE\uFF09\u2500 \u56FA\u5B9A\u89C6\u56FE\u3001\u7B5B\u9009\u89C6\u56FE
-  chart\uFF08\u5EA6\u91CF\uFF09\u2500 \u89C6\u56FE\u4E0B\u7684\u56FE\u8868\uFF0C\u4F9D\u8D56 view-id
-  team / user\uFF08\u4EBA\u5458\uFF09\u2500 \u56E2\u961F\u4E0E\u7528\u6237
-  project\uFF08\u7A7A\u95F4\uFF09\u2500 \u7A7A\u95F4\u4FE1\u606F
-
-\u5178\u578B\u64CD\u4F5C\u94FE\u8DEF:
-  \u521B\u5EFA\u5DE5\u4F5C\u9879: workitem meta-types \u2192 workitem meta-create-fields \u2192 workitem create
-  \u6D41\u8F6C\u8282\u70B9:   workflow get-node \u2192 workflow list-state-transitions \u2192 workflow transition
-  \u67E5\u770B\u5173\u8054:   relation meta-definitions \u2192 relation list`).version(version).option("--format <format>", "\u8F93\u51FA\u683C\u5F0F: json | table | ndjson", "json").option("--select <props>", "\u9009\u53D6\u8F93\u51FA\u5C5E\u6027\uFF0C\u9017\u53F7\u5206\u9694").option("--verbose", "\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7").option("--profile <name>", "\u4F7F\u7528\u6307\u5B9A profile\uFF08\u4E34\u65F6\uFF0C\u4E0D\u6539\u53D8\u5168\u5C40\uFF09").hook("preAction", async (thisCommand, actionCommand) => {
-    const opts = thisCommand.opts();
-    if (opts.verbose) {
-      setLogLevel("debug");
-    }
-    const chain = getCommandChain(actionCommand);
-    const topCmd = chain[0] ?? "";
-    const profileName2 = thisCommand.opts().profile;
-    if (!SKIP_FIRST_RUN.includes(topCmd)) {
-      await checkFirstRun(profileName2);
-    }
-  });
-  registerStaticCommands(program);
-  const profileName = extractProfileFromArgv(process.argv);
-  try {
-    const config = await loadConfig(profileName);
-    const serverUrl = getServerUrl(config);
-    const currentProfile = profileName ?? await getCurrentProfileName();
-    const store = await createTokenStore(currentProfile);
-    const tokenManager = new TokenManager(store, config.host);
-    const client = new McpClient(serverUrl, tokenManager, config.headers);
-    const cache = new ToolCache(getCacheDir(), currentProfile);
-    const cached = await cache.get();
-    let tools;
-    if (cached) {
-      tools = cached.tools;
-      if (cached.stale) {
-        logger.debug("\u7F13\u5B58\u5DF2\u8FC7\u671F\uFF0C\u540E\u53F0\u5237\u65B0\u4E2D...");
-        discoverTools(client).then((fresh) => {
-          if (fresh.length > 0) cache.set(fresh);
-        }).catch(() => {
-        });
-      }
-    } else {
-      logger.debug("\u6B63\u5728\u83B7\u53D6\u547D\u4EE4\u5217\u8868...");
-      tools = await discoverTools(client);
-      if (tools.length > 0) {
-        await cache.set(tools);
-      }
-    }
-    const mapped = mapTools(tools);
-    registerDynamicCommands(program, mapped, client);
-    logger.debug(`\u5DF2\u52A0\u8F7D ${mapped.length} \u4E2A\u547D\u4EE4`);
-  } catch (err) {
-    logger.debug(`\u547D\u4EE4\u52A0\u8F7D\u8DF3\u8FC7: ${err}`);
-  }
-  return program;
-}
-async function run() {
-  try {
-    const program = await createProgram();
-    await program.parseAsync(process.argv);
-  } catch (err) {
-    if (err instanceof MeegleError) {
-      console.error(JSON.stringify(err.toJSON(), null, 2));
-      process.exit(err.exitCode);
-    }
-    console.error(JSON.stringify({
-      error: "UNEXPECTED",
-      message: err instanceof Error ? err.message : String(err)
-    }, null, 2));
-    process.exit(1);
-  }
-}
-
-// bin/meegle.ts
-run();