@insightsuen/dingdoc 0.1.0

package/dist/index.js

@@ -0,0 +1,788 @@
+#!/usr/bin/env node
+
+// ../../packages/shared/src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// ../../packages/shared/src/logger.ts
+var LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var currentLevel = process.env["LOG_LEVEL"] ?? "info";
+function log(level, message, meta) {
+  if (LEVELS[level] < LEVELS[currentLevel]) return;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const prefix = `[${timestamp}] [${level.toUpperCase()}]`;
+  const output = meta !== void 0 ? `${prefix} ${message} ${JSON.stringify(meta)}` : `${prefix} ${message}`;
+  process.stderr.write(output + "\n");
+}
+var logger = {
+  debug: (message, meta) => log("debug", message, meta),
+  info: (message, meta) => log("info", message, meta),
+  warn: (message, meta) => log("warn", message, meta),
+  error: (message, meta) => log("error", message, meta)
+};
+
+// ../../packages/shared/src/server.ts
+function createServer(config) {
+  logger.info(`Creating MCP server: ${config.name} v${config.version}`);
+  return new McpServer({
+    name: config.name,
+    version: config.version
+  });
+}
+
+// ../../packages/shared/src/transport.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+async function launch(server2, options) {
+  const args = process.argv.slice(2);
+  const useHttp = options?.transport === "http" || args.includes("--http");
+  if (useHttp) {
+    await launchHttp(server2, options);
+  } else {
+    await launchStdio(server2);
+  }
+}
+async function launchStdio(server2) {
+  logger.info("Starting MCP server in stdio mode");
+  const transport = new StdioServerTransport();
+  await server2.connect(transport);
+  logger.info("MCP server connected via stdio");
+}
+async function launchHttp(server2, options) {
+  const { createServer: createServer2 } = await import("node:http");
+  const { randomUUID } = await import("node:crypto");
+  const { StreamableHTTPServerTransport } = await import("@modelcontextprotocol/sdk/server/streamableHttp.js");
+  const port = options?.port ?? parseInt(process.env["PORT"] ?? "3000", 10);
+  const host = options?.host ?? process.env["HOST"] ?? "localhost";
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: () => randomUUID()
+  });
+  await server2.connect(transport);
+  const httpServer = createServer2((req, res) => {
+    transport.handleRequest(req, res);
+  });
+  httpServer.listen(port, host, () => {
+    logger.info(`MCP server listening on http://${host}:${port}`);
+  });
+  process.on("SIGINT", () => {
+    logger.info("Shutting down MCP server...");
+    httpServer.close();
+    process.exit(0);
+  });
+}
+
+// ../../packages/shared/src/errors.ts
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+function toToolError(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return {
+    isError: true,
+    content: [{ type: "text", text: message }]
+  };
+}
+
+// ../../packages/shared/src/index.ts
+import { McpServer as McpServer2 } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/auth.ts
+var OAUTH_URL = "https://api.dingtalk.com/v1.0/oauth2/accessToken";
+var USER_GET_URL = "https://oapi.dingtalk.com/topapi/v2/user/get";
+var LEAD_TIME_MS = 10 * 60 * 1e3;
+var cachedToken = null;
+var tokenExpiresAt = 0;
+var cachedOperatorId = null;
+function parseCliArgs() {
+  const map = /* @__PURE__ */ new Map();
+  for (const arg of process.argv.slice(2)) {
+    if (arg.startsWith("--")) {
+      const eqIdx = arg.indexOf("=");
+      if (eqIdx > 2) {
+        const key = arg.slice(2, eqIdx);
+        const val = arg.slice(eqIdx + 1);
+        map.set(key, val);
+      }
+    }
+  }
+  return map;
+}
+var CLI_ARGS = parseCliArgs();
+function resolveCredential(argKey, defaultEnvKey) {
+  const direct = CLI_ARGS.get(argKey);
+  if (direct) return direct;
+  const customEnvName = CLI_ARGS.get(`${argKey}-env`);
+  if (customEnvName) {
+    const val = process.env[customEnvName];
+    if (val) return val;
+    logger.warn(`--${argKey}-env \u6307\u5B9A\u4E86 ${customEnvName}\uFF0C\u4F46\u8BE5\u73AF\u5883\u53D8\u91CF\u672A\u8BBE\u7F6E`);
+  }
+  return process.env[defaultEnvKey];
+}
+async function getAccessToken() {
+  const now = Date.now();
+  if (cachedToken && now < tokenExpiresAt) {
+    return cachedToken;
+  }
+  const appKey = resolveCredential("app-key", "DINGTALK_APP_KEY");
+  const appSecret = resolveCredential("app-secret", "DINGTALK_APP_SECRET");
+  if (!appKey || !appSecret) {
+    throw new Error(
+      [
+        "\u7F3A\u5C11\u9489\u9489\u5E94\u7528\u51ED\u8BC1\uFF0C\u8BF7\u901A\u8FC7\u4EE5\u4E0B\u4EFB\u4E00\u65B9\u5F0F\u63D0\u4F9B\uFF1A",
+        "  \u2022 \u73AF\u5883\u53D8\u91CF\uFF1ADINGTALK_APP_KEY / DINGTALK_APP_SECRET",
+        "  \u2022 CLI \u53C2\u6570\uFF1A--app-key=xxx --app-secret=xxx",
+        "  \u2022 \u81EA\u5B9A\u4E49 env \u540D\uFF1A--app-key-env=MY_VAR --app-secret-env=MY_VAR",
+        "  AppKey/AppSecret \u53EF\u5728\u9489\u9489\u5F00\u53D1\u8005\u540E\u53F0\u300C\u51ED\u8BC1\u4E0E\u57FA\u7840\u4FE1\u606F\u300D\u9875\u9762\u83B7\u53D6\u3002"
+      ].join("\n")
+    );
+  }
+  logger.debug("Refreshing DingTalk access token...");
+  const resp = await fetch(OAUTH_URL, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ appKey, appSecret, grantType: "client_credentials" })
+  });
+  if (!resp.ok) {
+    throw new Error(`\u83B7\u53D6 access token \u5931\u8D25\uFF1AHTTP ${resp.status}`);
+  }
+  const data = await resp.json();
+  cachedToken = data.accessToken;
+  tokenExpiresAt = now + data.expireIn * 1e3 - LEAD_TIME_MS;
+  logger.debug("DingTalk access token refreshed");
+  return cachedToken;
+}
+async function fetchUnionId(userId) {
+  const token = await getAccessToken();
+  const resp = await fetch(`${USER_GET_URL}?access_token=${token}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ userid: userId })
+  });
+  if (!resp.ok) {
+    throw new Error(`\u83B7\u53D6 unionId \u5931\u8D25\uFF1AHTTP ${resp.status}`);
+  }
+  const data = await resp.json();
+  if (data.errcode !== 0 || !data.result?.unionid) {
+    throw new Error(`\u83B7\u53D6 unionId \u5931\u8D25\uFF1A${data.errmsg}\uFF08errcode: ${data.errcode}\uFF09`);
+  }
+  return data.result.unionid;
+}
+async function getOperatorId() {
+  if (cachedOperatorId) return cachedOperatorId;
+  const unionId = resolveCredential("union-id", "DINGTALK_UNION_ID");
+  if (unionId) {
+    cachedOperatorId = unionId;
+    return cachedOperatorId;
+  }
+  const userId = resolveCredential("user-id", "DINGTALK_USER_ID");
+  if (userId) {
+    logger.info(
+      [
+        `\u68C0\u6D4B\u5230 DINGTALK_USER_ID\uFF0C\u6B63\u5728\u67E5\u8BE2\u5BF9\u5E94\u7684 unionId...`,
+        `  \u63D0\u793A\uFF1A\u4F60\u4E5F\u53EF\u4EE5\u76F4\u63A5\u8BBE\u7F6E DINGTALK_UNION_ID \u8DF3\u8FC7\u6B64\u6B65\u9AA4\uFF0C`,
+        `         unionId \u53EF\u4ECE\u9489\u9489\u5F00\u53D1\u8005\u540E\u53F0\u300C\u7528\u6237\u7BA1\u7406\u300D\u6216\u9996\u6B21\u8FD0\u884C\u65E5\u5FD7\u4E2D\u83B7\u53D6\u3002`
+      ].join("\n")
+    );
+    const resolved = await fetchUnionId(userId);
+    logger.info(`  \u2713 unionId \u89E3\u6790\u6210\u529F\uFF1A${resolved}`);
+    logger.info(`  \u5EFA\u8BAE\u5C06 DINGTALK_UNION_ID=${resolved} \u5199\u5165\u73AF\u5883\u53D8\u91CF\u4EE5\u52A0\u901F\u540E\u7EED\u542F\u52A8\u3002`);
+    cachedOperatorId = resolved;
+    return cachedOperatorId;
+  }
+  throw new Error(
+    [
+      "\u7F3A\u5C11\u64CD\u4F5C\u4EBA\u8EAB\u4EFD\uFF08unionId\uFF09\uFF0C\u8BF7\u901A\u8FC7\u4EE5\u4E0B\u4EFB\u4E00\u65B9\u5F0F\u63D0\u4F9B\uFF1A",
+      "  \u2022 \u73AF\u5883\u53D8\u91CF\uFF08\u63A8\u8350\uFF09\uFF1ADINGTALK_UNION_ID=xxx",
+      "  \u2022 \u73AF\u5883\u53D8\u91CF\uFF08\u81EA\u52A8\u89E3\u6790\uFF09\uFF1ADINGTALK_USER_ID=xxx  \uFF08\u5C06\u81EA\u52A8\u67E5\u8BE2 unionId\uFF09",
+      "  \u2022 CLI \u53C2\u6570\uFF1A--union-id=xxx  \u6216  --user-id=xxx",
+      "  \u2022 \u81EA\u5B9A\u4E49 env \u540D\uFF1A--union-id-env=MY_VAR",
+      "",
+      "  unionId \u83B7\u53D6\u65B9\u5F0F\uFF1A",
+      "    1. \u9489\u9489\u5F00\u53D1\u8005\u540E\u53F0 \u2192 \u7528\u6237\u7BA1\u7406 \u2192 \u70B9\u51FB\u7528\u6237 \u2192 \u67E5\u770B unionId",
+      "    2. \u6216\u5148\u8BBE\u7F6E DINGTALK_USER_ID\uFF08\u5982\u5DE5\u53F7 BG012345\uFF09\uFF0C\u670D\u52A1\u542F\u52A8\u65F6\u4F1A\u81EA\u52A8\u663E\u793A unionId"
+    ].join("\n")
+  );
+}
+function getAppCredentials() {
+  return {
+    appKey: resolveCredential("app-key", "DINGTALK_APP_KEY"),
+    appSecret: resolveCredential("app-secret", "DINGTALK_APP_SECRET")
+  };
+}
+function isApiConfigured() {
+  const appKey = resolveCredential("app-key", "DINGTALK_APP_KEY");
+  const appSecret = resolveCredential("app-secret", "DINGTALK_APP_SECRET");
+  const hasUser = !!resolveCredential("union-id", "DINGTALK_UNION_ID") || !!resolveCredential("user-id", "DINGTALK_USER_ID");
+  return !!(appKey && appSecret && hasUser);
+}
+var _apiAvailable = false;
+function setApiAvailable(val) {
+  _apiAvailable = val;
+}
+function isApiAvailable() {
+  return _apiAvailable;
+}
+async function validateCredentials() {
+  logger.info("\u6B63\u5728\u9A8C\u8BC1\u9489\u9489\u51ED\u8BC1...");
+  try {
+    await getAccessToken();
+    await getOperatorId();
+    logger.info("\u2713 \u9489\u9489\u51ED\u8BC1\u9A8C\u8BC1\u6210\u529F");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`\u9489\u9489\u51ED\u8BC1\u9A8C\u8BC1\u5931\u8D25\uFF1A
+${msg}`, { cause: err });
+  }
+}
+
+// src/client.ts
+var BASE_URL = "https://api.dingtalk.com";
+var DingTalkApiError = class extends Error {
+  constructor(status, code, message) {
+    super(`[${code}] ${message}`);
+    this.status = status;
+    this.code = code;
+    this.name = "DingTalkApiError";
+  }
+};
+async function dingtalkGet(path2, params = {}) {
+  const token = await getAccessToken();
+  const operatorId = await getOperatorId();
+  const query = new URLSearchParams();
+  query.set("operatorId", operatorId);
+  for (const [k, v] of Object.entries(params)) {
+    query.set(k, String(v));
+  }
+  const url = `${BASE_URL}${path2}?${query.toString()}`;
+  const resp = await fetch(url, {
+    headers: { "x-acs-dingtalk-access-token": token }
+  });
+  if (!resp.ok) {
+    let code = "unknown";
+    let message = `HTTP ${resp.status}`;
+    try {
+      const body = await resp.json();
+      code = body.code ?? code;
+      message = body.message ?? message;
+    } catch {
+    }
+    throw new DingTalkApiError(resp.status, code, message);
+  }
+  return resp.json();
+}
+
+// src/tools/list-spaces.ts
+function registerListSpaces(server2) {
+  server2.tool(
+    "dingtalk_list_spaces",
+    "\u5217\u51FA\u5F53\u524D\u7528\u6237\u6709\u6743\u9650\u7684\u6240\u6709\u9489\u9489\u77E5\u8BC6\u5E93\u7A7A\u95F4\uFF0C\u8FD4\u56DE spaceId\u3001\u540D\u79F0\u3001rootNodeId \u548C\u8BBF\u95EE\u94FE\u63A5",
+    {},
+    async () => {
+      try {
+        const spaces = [];
+        let nextToken;
+        do {
+          const params = { maxResults: 30 };
+          if (nextToken) params["nextToken"] = nextToken;
+          const resp = await dingtalkGet("/v2.0/wiki/workspaces", params);
+          spaces.push(...resp.workspaces ?? []);
+          nextToken = resp.nextToken;
+        } while (nextToken);
+        const result = spaces.map((s) => ({
+          spaceId: s.workspaceId,
+          name: s.name,
+          rootNodeId: s.rootNodeId,
+          url: s.url ?? null
+        }));
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (err) {
+        return toToolError(err);
+      }
+    }
+  );
+}
+
+// src/tools/list-nodes.ts
+import { z } from "zod";
+async function fetchNodes(parentNodeId) {
+  const nodes = [];
+  let nextToken;
+  do {
+    const params = {
+      parentNodeId,
+      maxResults: 50
+    };
+    if (nextToken) params["nextToken"] = nextToken;
+    const resp = await dingtalkGet("/v2.0/wiki/nodes", params);
+    nodes.push(...resp.nodes ?? []);
+    nextToken = resp.nextToken;
+  } while (nextToken);
+  return nodes;
+}
+async function fetchNodesRecursive(parentNodeId) {
+  const nodes = await fetchNodes(parentNodeId);
+  const results = [];
+  for (const node of nodes) {
+    const result = {
+      nodeId: node.nodeId,
+      name: node.name,
+      type: node.type,
+      category: node.category ?? null,
+      url: node.url ?? null,
+      hasChildren: node.hasChildren
+    };
+    if (node.hasChildren && node.type === "FOLDER") {
+      result.children = await fetchNodesRecursive(node.nodeId);
+    }
+    results.push(result);
+  }
+  return results;
+}
+function registerListNodes(server2) {
+  server2.tool(
+    "dingtalk_list_nodes",
+    "\u5217\u51FA\u9489\u9489\u77E5\u8BC6\u5E93\u8282\u70B9\u4E0B\u7684\u5B50\u8282\u70B9\u3002nodeId \u53EF\u4ECE dingtalk_list_spaces \u83B7\u53D6\u7684 rootNodeId \u5F00\u59CB\u3002\u652F\u6301 recursive \u9012\u5F52\u5C55\u5F00\u6574\u4E2A\u76EE\u5F55\u6811\uFF08\u8282\u70B9\u6570\u91CF\u591A\u65F6\u8017\u65F6\u8F83\u957F\uFF09",
+    {
+      nodeId: z.string().describe("\u7236\u8282\u70B9 ID\uFF08dentryUuid\uFF09\uFF0C\u5982\u77E5\u8BC6\u5E93\u7684 rootNodeId"),
+      recursive: z.boolean().optional().default(false).describe("\u662F\u5426\u9012\u5F52\u5C55\u5F00\u6240\u6709\u5B50\u8282\u70B9\uFF0C\u9ED8\u8BA4 false")
+    },
+    async ({ nodeId, recursive }) => {
+      try {
+        let result;
+        if (recursive) {
+          result = await fetchNodesRecursive(nodeId);
+        } else {
+          const nodes = await fetchNodes(nodeId);
+          result = nodes.map((node) => ({
+            nodeId: node.nodeId,
+            name: node.name,
+            type: node.type,
+            category: node.category ?? null,
+            url: node.url ?? null,
+            hasChildren: node.hasChildren
+          }));
+        }
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (err) {
+        return toToolError(err);
+      }
+    }
+  );
+}
+
+// src/tools/get-document.ts
+import { z as z2 } from "zod";
+
+// src/stream.ts
+import { DWClient, EventAck } from "dingtalk-stream";
+var DOC_CONTENT_EXPORT_EVENT = "doc_content_export_result";
+var DEFAULT_TIMEOUT_MS = 6e4;
+var pending = /* @__PURE__ */ new Map();
+var recentEvents = /* @__PURE__ */ new Map();
+var RECENT_EVENT_TTL_MS = 6e4;
+var streamClient = null;
+var streamReady = false;
+var docContentCache = /* @__PURE__ */ new Map();
+function initDocStream(appKey, appSecret) {
+  if (streamClient) return;
+  streamClient = new DWClient({ clientId: appKey, clientSecret: appSecret });
+  streamClient.registerAllEventListener((msg) => {
+    logger.info(
+      `[Stream] \u6536\u5230\u4E8B\u4EF6 type=${msg.type} topic=${msg.headers.topic} eventType=${msg.headers.eventType ?? "(none)"}`
+    );
+    if (msg.headers.eventType === DOC_CONTENT_EXPORT_EVENT) {
+      try {
+        logger.info(`[Stream] \u4E8B\u4EF6\u539F\u59CB data: ${msg.data}`);
+        const data = JSON.parse(msg.data);
+        const taskId = Number(data.taskId);
+        const normalized = { ...data, taskId };
+        logger.info(`[Stream] \u6587\u6863\u5BFC\u51FA\u4E8B\u4EF6\u89E3\u6790\u5B8C\u6210\uFF0CtaskId=${taskId}\uFF08\u539F\u59CB: ${String(data.taskId)}\uFF09\uFF0Csuccess=${String(data.success)}\uFF0Cpending\u4E2D\u7684key\u5217\u8868: [${[...pending.keys()].join(", ")}]`);
+        if (normalized.success && normalized.content && normalized.dentryUuid) {
+          cacheDocContent(normalized.dentryUuid, normalized.content);
+        }
+        const resolver = pending.get(taskId);
+        if (resolver) {
+          pending.delete(taskId);
+          resolver(normalized);
+        } else if (normalized.success) {
+          logger.info(`[Stream] taskId ${taskId} \u6682\u5B58\u5230\u8FD1\u671F\u4E8B\u4EF6\u7F13\u5B58`);
+          recentEvents.set(taskId, normalized);
+          setTimeout(() => recentEvents.delete(taskId), RECENT_EVENT_TTL_MS);
+        } else {
+          logger.warn(`[Stream] taskId ${taskId} \u5BFC\u51FA\u5931\u8D25\u4E14\u65E0\u7B49\u5F85\u8BF7\u6C42\uFF0C\u4E22\u5F03`);
+        }
+      } catch (err) {
+        logger.error("\u89E3\u6790\u6587\u6863\u5BFC\u51FA\u4E8B\u4EF6\u5931\u8D25", err);
+      }
+    }
+    return { status: EventAck.SUCCESS };
+  });
+  streamClient.connect().then(() => {
+    streamReady = true;
+    logger.info("\u2713 \u9489\u9489 Stream \u8FDE\u63A5\u5DF2\u5EFA\u7ACB\uFF0C\u5F00\u59CB\u76D1\u542C\u6587\u6863\u5BFC\u51FA\u4E8B\u4EF6");
+  }).catch((err) => {
+    logger.error("\u9489\u9489 Stream \u8FDE\u63A5\u5931\u8D25\uFF0Cget_document \u5DE5\u5177\u5C06\u65E0\u6CD5\u83B7\u53D6\u6587\u6863\u5185\u5BB9", err);
+  });
+}
+function waitForDocExport(taskId, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  if (!streamClient) {
+    return Promise.reject(
+      new Error(
+        "DingTalk Stream \u5BA2\u6237\u7AEF\u672A\u521D\u59CB\u5316\uFF0C\u65E0\u6CD5\u63A5\u6536\u6587\u6863\u5BFC\u51FA\u7ED3\u679C\u3002\u8BF7\u68C0\u67E5\u670D\u52A1\u542F\u52A8\u65E5\u5FD7\u3002"
+      )
+    );
+  }
+  const cached = recentEvents.get(taskId);
+  if (cached) {
+    logger.info(`[Stream] taskId ${taskId} \u547D\u4E2D\u8FD1\u671F\u4E8B\u4EF6\u7F13\u5B58\uFF0C\u76F4\u63A5\u8FD4\u56DE`);
+    recentEvents.delete(taskId);
+    return Promise.resolve(cached);
+  }
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      pending.delete(taskId);
+      reject(
+        new Error(
+          `\u6587\u6863\u5BFC\u51FA\u8D85\u65F6\uFF08taskId: ${taskId}\uFF0C\u7B49\u5F85 ${timeoutMs / 1e3}s\uFF09\u3002
+  \u53EF\u80FD\u539F\u56E0\uFF1AStream \u8FDE\u63A5\u65AD\u5F00\u3001\u5BFC\u51FA\u670D\u52A1\u7E41\u5FD9\uFF0C\u6216\u6587\u6863\u4E0D\u652F\u6301\u5BFC\u51FA\u3002`
+        )
+      );
+    }, timeoutMs);
+    pending.set(taskId, (result) => {
+      clearTimeout(timer);
+      resolve(result);
+    });
+  });
+}
+function isStreamReady() {
+  return streamReady;
+}
+function getCachedDocContent(nodeId) {
+  return docContentCache.get(nodeId);
+}
+function cacheDocContent(nodeId, content) {
+  docContentCache.set(nodeId, content);
+  logger.info(`[Cache] \u6587\u6863\u5185\u5BB9\u5DF2\u7F13\u5B58\uFF0CnodeId: ${nodeId}\uFF0C\u957F\u5EA6: ${content.length} \u5B57\u7B26`);
+}
+
+// src/browser.ts
+import { chromium } from "playwright";
+import path from "path";
+import os from "os";
+import TurndownService from "turndown";
+var USER_DATA_DIR = path.join(os.homedir(), ".insight-mcp", "dingdoc-browser");
+var DOC_BASE_URL = "https://alidocs.dingtalk.com/i/nodes";
+var CONTENT_SELECTORS = [
+  ".ne-viewer-body",
+  ".ne-doc-content",
+  ".ne-engine-body",
+  ".ne-doc",
+  "[class*='viewer-body']",
+  "[class*='docContent']",
+  "[class*='doc-content']",
+  "[class*='editor-body']",
+  "[class*='content-body']",
+  ".wiki-doc-content",
+  "article"
+];
+function isLoginPage(url) {
+  return url.includes("/login") || url.includes("/sso") || url.includes("oauth") || url.includes("dingtalk.com/o/") || url.includes("account.dingtalk.com");
+}
+var browserContext = null;
+var browserContextHeadless = true;
+async function getContext(headless) {
+  if (browserContext && browserContextHeadless === headless) {
+    return browserContext;
+  }
+  if (browserContext) {
+    await browserContext.close();
+    browserContext = null;
+  }
+  logger.info(`[Browser] \u542F\u52A8 Chromium \u6301\u4E45\u5316\u4E0A\u4E0B\u6587\uFF08headless=${String(headless)}\uFF09...`);
+  logger.info(`[Browser] \u6D4F\u89C8\u5668\u6570\u636E\u76EE\u5F55\uFF1A${USER_DATA_DIR}`);
+  browserContext = await chromium.launchPersistentContext(USER_DATA_DIR, {
+    headless,
+    viewport: { width: 1280, height: 900 },
+    locale: "zh-CN"
+  });
+  browserContextHeadless = headless;
+  return browserContext;
+}
+async function fetchDocViaBrowser(nodeId) {
+  const url = `${DOC_BASE_URL}/${nodeId}`;
+  logger.info(`[Browser] \u6B63\u5728\u901A\u8FC7\u6D4F\u89C8\u5668\u8BBF\u95EE\u6587\u6863\uFF0CnodeId: ${nodeId}`);
+  let ctx = await getContext(true);
+  let page = await ctx.newPage();
+  try {
+    await page.goto(url, { waitUntil: "domcontentloaded", timeout: 2e4 });
+    if (isLoginPage(page.url())) {
+      logger.warn(
+        "[Browser] \u68C0\u6D4B\u5230\u767B\u5F55\u9875\uFF0C\u5207\u6362\u5230\u6709\u754C\u9762\u6A21\u5F0F\uFF0C\u8BF7\u5728\u6D4F\u89C8\u5668\u7A97\u53E3\u4E2D\u5B8C\u6210\u9489\u9489\u767B\u5F55..."
+      );
+      await page.close();
+      ctx = await getContext(false);
+      page = await ctx.newPage();
+      await page.goto(url, { waitUntil: "domcontentloaded", timeout: 2e4 });
+      if (isLoginPage(page.url())) {
+        logger.warn("[Browser] \u8BF7\u5728\u6253\u5F00\u7684\u6D4F\u89C8\u5668\u7A97\u53E3\u4E2D\u5B8C\u6210\u767B\u5F55\uFF08\u6700\u591A\u7B49\u5F85 3 \u5206\u949F\uFF09...");
+        await page.waitForURL((u) => u.href.startsWith(url), { timeout: 18e4 });
+        logger.info("[Browser] \u767B\u5F55\u6210\u529F\uFF0C\u7EE7\u7EED\u52A0\u8F7D\u6587\u6863...");
+      }
+    }
+    await page.waitForLoadState("networkidle", { timeout: 2e4 }).catch(() => {
+      logger.warn("[Browser] \u7F51\u7EDC\u672A\u5B8C\u5168\u7A7A\u95F2\uFF0C\u7EE7\u7EED\u5C1D\u8BD5\u63D0\u53D6\u5185\u5BB9...");
+    });
+    const iframeCount = await page.locator("iframe").count();
+    logger.info(`[Browser] \u68C0\u6D4B\u5230 ${iframeCount} \u4E2A iframe`);
+    let iframeContentText = "";
+    if (iframeCount > 0) {
+      for (let i = 0; i < iframeCount; i++) {
+        try {
+          const frame = page.frameLocator("iframe").nth(i);
+          for (const sel of CONTENT_SELECTORS) {
+            const count = await frame.locator(sel).count();
+            if (count > 0) {
+              const text = await frame.locator(sel).first().innerText();
+              if (text.trim().length > 50) {
+                iframeContentText = text;
+                logger.info(`[Browser] \u5728 iframe[${i}] \u7684 "${sel}" \u627E\u5230\u5185\u5BB9\uFF08${text.length} \u5B57\u7B26\uFF09`);
+                break;
+              }
+            }
+          }
+          if (iframeContentText) break;
+          const neViewer = await frame.locator(".ne-viewer-body, .ne-doc, [class*='viewer']").first().innerText().catch(() => "");
+          if (neViewer.trim().length > 100) {
+            iframeContentText = neViewer;
+            logger.info(`[Browser] \u5728 iframe[${i}] ne-viewer \u627E\u5230\u5185\u5BB9\uFF08${neViewer.length} \u5B57\u7B26\uFF09`);
+            break;
+          }
+          const bodyText = await frame.locator("body").innerText().catch(() => "");
+          if (bodyText.trim().length > 100) {
+            iframeContentText = bodyText;
+            logger.info(`[Browser] \u5728 iframe[${i}] body \u627E\u5230\u5185\u5BB9\uFF08${bodyText.length} \u5B57\u7B26\uFF09`);
+            break;
+          }
+        } catch {
+        }
+      }
+    }
+    let contentText = iframeContentText;
+    let usedSelector = "";
+    if (!contentText) {
+      for (const selector of CONTENT_SELECTORS) {
+        try {
+          const el = page.locator(selector).first();
+          const visible = await el.isVisible({ timeout: 2e3 });
+          if (visible) {
+            const text = await el.innerText();
+            if (text.trim().length > 50) {
+              contentText = text;
+              usedSelector = selector;
+              logger.info(`[Browser] \u4F7F\u7528\u9009\u62E9\u5668 "${selector}" \u63D0\u53D6\u5230\u5185\u5BB9\uFF08${text.length} \u5B57\u7B26\uFF09`);
+              break;
+            }
+          }
+        } catch {
+        }
+      }
+    }
+    if (!contentText) {
+      logger.warn("[Browser] \u672A\u627E\u5230\u6587\u6863\u5185\u5BB9\u533A\uFF0C\u56DE\u9000\u5230 body \u5168\u6587\uFF08innerText\uFF09");
+      contentText = await page.locator("body").innerText().catch(() => "");
+    }
+    let result;
+    if (usedSelector) {
+      const html = await page.locator(usedSelector).first().innerHTML();
+      const td = new TurndownService({
+        headingStyle: "atx",
+        codeBlockStyle: "fenced",
+        bulletListMarker: "-"
+      });
+      td.addRule("removeNav", {
+        filter: ["nav", "header", "footer", "aside"],
+        replacement: () => ""
+      });
+      result = td.turndown(html).trim();
+    } else {
+      result = contentText.trim();
+    }
+    logger.info(`[Browser] \u6587\u6863\u63D0\u53D6\u6210\u529F\uFF0C\u957F\u5EA6: ${result.length} \u5B57\u7B26`);
+    return result;
+  } finally {
+    await page.close();
+  }
+}
+process.on("exit", () => {
+  if (browserContext) {
+    void browserContext.close();
+  }
+});
+process.on("SIGINT", () => {
+  if (browserContext) {
+    void browserContext.close().then(() => process.exit(0));
+  }
+});
+
+// src/tools/get-document.ts
+var BROWSER_FALLBACK_CODES = /* @__PURE__ */ new Set(["permissionDenied", "documentNotExist"]);
+var ALIDOC_URL_PATTERN = /alidocs\.dingtalk\.com\/i\/nodes\/([A-Za-z0-9_-]+)/;
+function extractNodeId(url) {
+  return ALIDOC_URL_PATTERN.exec(url)?.[1] ?? null;
+}
+async function triggerAndWaitExport(nodeId, timeoutMs) {
+  logger.info(`\u6B63\u5728\u89E6\u53D1\u6587\u6863\u5BFC\u51FA\uFF0CnodeId: ${nodeId}`);
+  const resp = await dingtalkGet(
+    `/v2.0/doc/query/${nodeId}/contents`,
+    { targetFormat: "markdown" }
+  );
+  const taskId = Number(resp.taskId);
+  logger.info(`\u6587\u6863\u5BFC\u51FA\u4EFB\u52A1\u5DF2\u89E6\u53D1\uFF0CtaskId: ${taskId}\uFF0C\u7B49\u5F85\u5BFC\u51FA\u7ED3\u679C\uFF08\u6700\u957F ${timeoutMs / 1e3}s\uFF09...`);
+  const result = await waitForDocExport(taskId, timeoutMs);
+  if (!result.success) {
+    throw new Error(`\u6587\u6863\u5BFC\u51FA\u5931\u8D25\uFF08taskId: ${taskId}\uFF09`);
+  }
+  const content = result.content ?? "";
+  logger.info(`\u6587\u6863\u5BFC\u51FA\u6210\u529F\uFF0CtaskId: ${taskId}\uFF0C\u5185\u5BB9\u957F\u5EA6: ${content.length} \u5B57\u7B26`);
+  return content;
+}
+async function fetchDocContent(nodeId) {
+  if (!isStreamReady()) {
+    throw new Error(
+      "DingTalk Stream \u8FDE\u63A5\u5C1A\u672A\u5EFA\u7ACB\uFF0C\u65E0\u6CD5\u83B7\u53D6\u6587\u6863\u5185\u5BB9\u3002\n  \u8BF7\u7B49\u5F85\u670D\u52A1\u542F\u52A8\u5B8C\u6210\u540E\u91CD\u8BD5\uFF0C\u6216\u68C0\u67E5\u542F\u52A8\u65E5\u5FD7\u4E2D\u662F\u5426\u6709 Stream \u8FDE\u63A5\u9519\u8BEF\u3002"
+    );
+  }
+  const cached = getCachedDocContent(nodeId);
+  if (cached) {
+    logger.info(`[Cache] \u547D\u4E2D\u6587\u6863\u7F13\u5B58\uFF0CnodeId: ${nodeId}\uFF0C\u76F4\u63A5\u8FD4\u56DE`);
+    return cached;
+  }
+  try {
+    return await triggerAndWaitExport(nodeId, 2e4);
+  } catch (err) {
+    if (err instanceof DingTalkApiError && BROWSER_FALLBACK_CODES.has(err.code)) {
+      throw err;
+    }
+    const reason = err instanceof Error ? err.message : String(err);
+    logger.warn(`\u9996\u6B21\u5BFC\u51FA\u5931\u8D25\uFF0C\u81EA\u52A8\u91CD\u8BD5\uFF08nodeId: ${nodeId}\uFF0C\u539F\u56E0: ${reason}\uFF09...`);
+    return await triggerAndWaitExport(nodeId, 3e4);
+  }
+}
+function registerGetDocument(server2) {
+  server2.tool(
+    "dingtalk_get_document",
+    "\u8BFB\u53D6\u9489\u9489\u77E5\u8BC6\u5E93\u6587\u6863\u5185\u5BB9\uFF0C\u8FD4\u56DE Markdown \u683C\u5F0F\u3002\u652F\u6301\u901A\u8FC7 nodeId \u6216\u6587\u6863 URL\uFF08https://alidocs.dingtalk.com/i/nodes/...\uFF09\u4E24\u79CD\u65B9\u5F0F\u6307\u5B9A\u6587\u6863",
+    {
+      nodeId: z2.string().optional().describe("\u6587\u6863\u8282\u70B9 ID\uFF08\u4E0E url \u4E8C\u9009\u4E00\uFF09"),
+      url: z2.string().optional().describe("\u6587\u6863 URL\uFF0C\u683C\u5F0F\uFF1Ahttps://alidocs.dingtalk.com/i/nodes/{nodeId}\uFF08\u4E0E nodeId \u4E8C\u9009\u4E00\uFF09")
+    },
+    async ({ nodeId, url }) => {
+      let resolvedNodeId;
+      if (nodeId) {
+        resolvedNodeId = nodeId;
+      } else if (url) {
+        const extracted = extractNodeId(url);
+        if (!extracted) {
+          return toToolError(
+            new Error("\u65E0\u6CD5\u4ECE URL \u4E2D\u89E3\u6790 nodeId\uFF0C\u8BF7\u786E\u8BA4\u683C\u5F0F\u4E3A\uFF1Ahttps://alidocs.dingtalk.com/i/nodes/{nodeId}")
+          );
+        }
+        resolvedNodeId = extracted;
+      } else {
+        return toToolError(new Error("\u8BF7\u63D0\u4F9B nodeId \u6216 url \u53C2\u6570\uFF08\u4E8C\u9009\u4E00\uFF09"));
+      }
+      if (!isApiAvailable()) {
+        logger.info(`[Browser] API \u4E0D\u53EF\u7528\uFF0C\u4F7F\u7528\u6D4F\u89C8\u5668\u8BFB\u53D6\u6587\u6863\uFF08nodeId: ${resolvedNodeId}\uFF09`);
+        try {
+          const content = await fetchDocViaBrowser(resolvedNodeId);
+          return { content: [{ type: "text", text: content }] };
+        } catch (err) {
+          return toToolError(err);
+        }
+      }
+      try {
+        const content = await fetchDocContent(resolvedNodeId);
+        return { content: [{ type: "text", text: content }] };
+      } catch (err) {
+        if (err instanceof DingTalkApiError && BROWSER_FALLBACK_CODES.has(err.code)) {
+          logger.warn(`[Fallback] API \u8FD4\u56DE ${err.code}\uFF0C\u5207\u6362\u6D4F\u89C8\u5668\u8BBF\u95EE\uFF08nodeId: ${resolvedNodeId}\uFF09`);
+          try {
+            const content = await fetchDocViaBrowser(resolvedNodeId);
+            return {
+              content: [{ type: "text", text: `> \u26A0\uFE0F API \u65E0\u6743\u8BBF\u95EE\u6B64\u6587\u6863\uFF0C\u4EE5\u4E0B\u5185\u5BB9\u901A\u8FC7\u6D4F\u89C8\u5668\u8BFB\u53D6\u3002
+
+${content}` }]
+            };
+          } catch (browserErr) {
+            return toToolError(
+              new Error(
+                `API \u548C\u6D4F\u89C8\u5668\u5747\u65E0\u6CD5\u83B7\u53D6\u6587\u6863\u5185\u5BB9\uFF1A
+  API: ${err.message}
+  \u6D4F\u89C8\u5668: ${browserErr instanceof Error ? browserErr.message : String(browserErr)}`
+              )
+            );
+          }
+        }
+        return toToolError(err);
+      }
+    }
+  );
+}
+
+// src/tools/index.ts
+function registerDingdocTools(server2, apiAvailable2) {
+  if (apiAvailable2) {
+    registerListSpaces(server2);
+    registerListNodes(server2);
+  } else {
+    logger.info("\u4EC5\u6D4F\u89C8\u5668\u6A21\u5F0F\uFF1A\u4EC5\u6CE8\u518C dingtalk_get_document \u5DE5\u5177\uFF08list_spaces / list_nodes \u9700\u8981 API \u51ED\u8BC1\uFF09");
+  }
+  registerGetDocument(server2);
+}
+
+// src/index.ts
+var toStderr = (...args) => process.stderr.write(args.map(String).join(" ") + "\n");
+console.log = toStderr;
+console.info = toStderr;
+console.warn = toStderr;
+console.error = toStderr;
+console.debug = toStderr;
+var apiAvailable = false;
+if (isApiConfigured()) {
+  try {
+    logger.info("\u6B63\u5728\u9A8C\u8BC1\u9489\u9489\u51ED\u8BC1...");
+    await validateCredentials();
+    apiAvailable = true;
+    setApiAvailable(true);
+    const { appKey, appSecret } = getAppCredentials();
+    if (appKey && appSecret) {
+      logger.info(`\u6B63\u5728\u521D\u59CB\u5316 DingTalk Stream\uFF08appKey: ${appKey.slice(0, 4)}****\uFF09...`);
+      initDocStream(appKey, appSecret);
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    logger.warn(`\u9489\u9489\u51ED\u8BC1\u9A8C\u8BC1\u5931\u8D25\uFF0C\u5207\u6362\u5230\u4EC5\u6D4F\u89C8\u5668\u6A21\u5F0F\uFF1A
+  ${msg}`);
+  }
+} else {
+  logger.info(
+    "\u672A\u68C0\u6D4B\u5230\u9489\u9489 API \u51ED\u8BC1\uFF08DINGTALK_APP_KEY / DINGTALK_APP_SECRET / DINGTALK_UNION_ID\uFF09\uFF0C\u4EE5\u4EC5\u6D4F\u89C8\u5668\u6A21\u5F0F\u542F\u52A8\u3002\n  \u6587\u6863\u8BFB\u53D6\u5C06\u901A\u8FC7 Playwright \u6D4F\u89C8\u5668\u8FDB\u884C\uFF0C\u65E0\u9700 API \u6743\u9650\u3002\n  \u5982\u9700 API \u6A21\u5F0F\uFF08\u652F\u6301\u77E5\u8BC6\u5E93\u6D4F\u89C8\uFF09\uFF0C\u8BF7\u53C2\u8003 README \u914D\u7F6E\u51ED\u8BC1\u3002"
+  );
+}
+var server = createServer({
+  name: "insight-dingdoc",
+  version: "0.1.0",
+  description: "\u9489\u9489\u77E5\u8BC6\u5E93 MCP \u670D\u52A1\u5668\uFF0C\u63D0\u4F9B\u77E5\u8BC6\u5E93\u7A7A\u95F4\u3001\u8282\u70B9\u6D4F\u89C8\u548C\u6587\u6863\u8BFB\u53D6\u80FD\u529B"
+});
+registerDingdocTools(server, apiAvailable);
+logger.info("\u6B63\u5728\u542F\u52A8 insight-dingdoc \u670D\u52A1...");
+launch(server).catch((err) => {
+  logger.error("Server failed to start", err);
+  process.exit(1);
+});