lark-mcp-server 0.0.1

package/README.md

@@ -0,0 +1,7 @@
+# lark-mcp-server
+
+飞书 MCP Server - 内部使用。
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+
+import open from 'open';
+import EventSource from 'eventsource';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+// 解析命令行参数
+const args = process.argv.slice(2);
+const params = {};
+for (const arg of args) {
+  const match = arg.match(/^--(\w+)=(.+)$/);
+  if (match) {
+    params[match[1]] = match[2];
+  }
+}
+
+const SERVER_URL = params.server || 'https://basic.dev.peblla.top/api/feishu';
+const USER_NAME = params.user || 'default';
+
+// 日志输出到 stderr，不影响 stdio 通信
+const log = (...args) => console.error('[lark-mcp-proxy]', ...args);
+
+// Token 本地存储
+const TOKEN_DIR = path.join(os.homedir(), '.lark-mcp');
+const TOKEN_FILE = path.join(TOKEN_DIR, 'tokens.json');
+
+// 加载本地 token
+function loadLocalToken(userName) {
+  try {
+    if (fs.existsSync(TOKEN_FILE)) {
+      const data = JSON.parse(fs.readFileSync(TOKEN_FILE, 'utf-8'));
+      return data[userName] || null;
+    }
+  } catch (e) {
+    log('Failed to load local token:', e.message);
+  }
+  return null;
+}
+
+// 保存 token 到本地
+function saveLocalToken(userName, tokenInfo) {
+  try {
+    // 确保目录存在
+    if (!fs.existsSync(TOKEN_DIR)) {
+      fs.mkdirSync(TOKEN_DIR, { recursive: true, mode: 0o700 });
+    }
+
+    // 读取现有数据
+    let data = {};
+    if (fs.existsSync(TOKEN_FILE)) {
+      data = JSON.parse(fs.readFileSync(TOKEN_FILE, 'utf-8'));
+    }
+
+    // 更新 token
+    data[userName] = {
+      ...tokenInfo,
+      expiresAt: Date.now() + tokenInfo.expiresIn * 1000,
+    };
+
+    // 写入文件（仅当前用户可读写）
+    fs.writeFileSync(TOKEN_FILE, JSON.stringify(data, null, 2), { mode: 0o600 });
+    log(`Token saved locally for user: ${userName}`);
+  } catch (e) {
+    log('Failed to save local token:', e.message);
+  }
+}
+
+// 检查 token 是否即将过期（提前 5 分钟刷新）
+function isTokenExpiringSoon(tokenInfo) {
+  if (!tokenInfo || !tokenInfo.expiresAt) return true;
+  return tokenInfo.expiresAt < Date.now() + 5 * 60 * 1000;
+}
+
+// 刷新本地 token
+async function refreshLocalToken() {
+  const tokenInfo = loadLocalToken(USER_NAME);
+  if (!tokenInfo || !tokenInfo.refreshToken) {
+    log('No refresh token available');
+    return false;
+  }
+
+  try {
+    const res = await fetch(`${SERVER_URL}/refresh-token`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ refresh_token: tokenInfo.refreshToken }),
+    });
+
+    if (!res.ok) {
+      const error = await res.json();
+      throw new Error(error.error || 'Refresh failed');
+    }
+
+    const newToken = await res.json();
+    saveLocalToken(USER_NAME, {
+      ...tokenInfo,
+      accessToken: newToken.accessToken,
+      refreshToken: newToken.refreshToken,
+      expiresIn: newToken.expiresIn,
+    });
+    log('Token refreshed successfully');
+    return true;
+  } catch (e) {
+    log('Token refresh failed:', e.message);
+    return false;
+  }
+}
+
+// 存储 messages endpoint 和授权 URL
+let messagesEndpoint = null;
+let authUrl = null;
+let sseConnected = false;
+let pendingRequests = new Map();
+
+function normalizeEndpoint(endpoint) {
+  try {
+    const url = new URL(endpoint);
+    const isLocal = url.hostname === 'localhost' || url.hostname === '127.0.0.1';
+    if (!isLocal && url.protocol === 'http:') {
+      url.protocol = 'https:';
+      return url.toString();
+    }
+  } catch {
+    // keep original endpoint if parsing fails
+  }
+  return endpoint;
+}
+
+// 连接 SSE
+function connectSSE() {
+  const sseUrl = `${SERVER_URL}/mcp?device_id=${USER_NAME}`;
+  log(`Connecting to ${sseUrl}`);
+
+  const es = new EventSource(sseUrl);
+
+  es.addEventListener('endpoint', (event) => {
+    messagesEndpoint = normalizeEndpoint(event.data);
+    log(`Got endpoint: ${messagesEndpoint}`);
+    sseConnected = true;
+  });
+
+  // 监听 token 事件（OAuth 回调后服务器推送）
+  es.addEventListener('token', (event) => {
+    try {
+      const tokenInfo = JSON.parse(event.data);
+      saveLocalToken(USER_NAME, tokenInfo);
+      log(`Received and saved token for user: ${tokenInfo.name}`);
+    } catch (e) {
+      log('Token event parse error:', e.message);
+    }
+  });
+
+  es.addEventListener('notification', (event) => {
+    try {
+      const data = JSON.parse(event.data);
+      // 保存授权 URL
+      if (data.auth_url) {
+        authUrl = data.auth_url;
+      }
+
+      if (data.type === 'auth_required' && data.auth_url) {
+        log(`Opening browser for auth: ${data.auth_url}`);
+        open(data.auth_url);
+      } else if (data.type === 'connected') {
+        // 检查本地是否有 token
+        const localToken = loadLocalToken(USER_NAME);
+        if (!localToken) {
+          log(`No local token found, opening auth: ${data.auth_url}`);
+          if (data.auth_url) {
+            open(data.auth_url);
+          }
+        } else {
+          log(`Local token found, ready to use`);
+        }
+      } else if (data.type === 'auth_success') {
+        log(`Auth success: ${data.message}`);
+      }
+    } catch (e) {
+      log('Notification parse error:', e.message);
+    }
+  });
+
+  es.addEventListener('message', (event) => {
+    try {
+      const response = JSON.parse(event.data);
+      // 发送响应到 stdout
+      const output = JSON.stringify(response);
+      process.stdout.write(output + '\n');
+      log(`Response sent for id=${response.id}`);
+    } catch (e) {
+      log('Message parse error:', e.message);
+    }
+  });
+
+  es.onerror = (err) => {
+    log('SSE error, reconnecting...');
+    sseConnected = false;
+    es.close();
+    setTimeout(connectSSE, 3000);
+  };
+}
+
+// 发送请求到服务器
+async function sendRequest(request) {
+  if (!messagesEndpoint) {
+    log('Waiting for endpoint...');
+    await new Promise(resolve => {
+      const check = setInterval(() => {
+        if (messagesEndpoint) {
+          clearInterval(check);
+          resolve();
+        }
+      }, 100);
+    });
+  }
+
+  // 获取本地 token
+  let tokenInfo = loadLocalToken(USER_NAME);
+
+  // 检查是否需要刷新 token
+  if (tokenInfo && isTokenExpiringSoon(tokenInfo)) {
+    log('Token expiring soon, refreshing...');
+    const refreshed = await refreshLocalToken();
+    if (refreshed) {
+      tokenInfo = loadLocalToken(USER_NAME);
+    }
+  }
+
+  // 如果没有 token 且不是初始化请求，触发授权
+  const initPhaseMethods = ['initialize', 'notifications/initialized', 'initialized', 'tools/list'];
+  if (!tokenInfo && !initPhaseMethods.includes(request.method)) {
+    if (authUrl) {
+      log(`No token available, opening auth: ${authUrl}`);
+      open(authUrl);
+    }
+  }
+
+  try {
+    const headers = { 'Content-Type': 'application/json' };
+    if (tokenInfo?.accessToken) {
+      headers['Authorization'] = `Bearer ${tokenInfo.accessToken}`;
+    }
+
+    const response = await fetch(messagesEndpoint, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(request),
+    });
+
+    if (response.status === 202) {
+      // 响应会通过 SSE 返回
+      log(`Request sent: ${request.method}, id=${request.id}`);
+    } else {
+      const text = await response.text();
+      log(`Unexpected response: ${response.status} ${text}`);
+    }
+  } catch (e) {
+    log('Request error:', e.message);
+    // 返回错误响应
+    const errorResponse = {
+      jsonrpc: '2.0',
+      id: request.id,
+      error: { code: -32000, message: e.message }
+    };
+    process.stdout.write(JSON.stringify(errorResponse) + '\n');
+  }
+}
+
+// 读取 stdin
+let buffer = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => {
+  buffer += chunk;
+
+  // 尝试解析完整的 JSON 消息
+  let newlineIndex;
+  while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
+    const line = buffer.slice(0, newlineIndex);
+    buffer = buffer.slice(newlineIndex + 1);
+
+    if (line.trim()) {
+      try {
+        const request = JSON.parse(line);
+        log(`Received: ${request.method}, id=${request.id}`);
+        sendRequest(request);
+      } catch (e) {
+        log('Parse error:', e.message);
+      }
+    }
+  }
+});
+
+process.stdin.on('end', () => {
+  log('stdin closed, exiting');
+  process.exit(0);
+});
+
+// 启动
+log(`Starting proxy for user: ${USER_NAME}`);
+log(`Server: ${SERVER_URL}`);
+connectSSE();

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "lark-mcp-server",
+  "version": "0.0.1",
+  "description": "飞书 MCP 本地代理 - 让 AI 编程工具读取飞书文档，Token 本地安全存储",
+  "type": "module",
+  "bin": {
+    "lark-mcp-server": "./index.js"
+  },
+  "files": [
+    "index.js",
+    "README.md"
+  ],
+  "keywords": [
+    "lark",
+    "feishu",
+    "mcp",
+    "proxy",
+    "claude",
+    "cursor",
+    "ai",
+    "document"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wuzhihua/lark-mcp-proxy"
+  },
+  "author": "wuzhihua",
+  "license": "MIT",
+  "dependencies": {
+    "eventsource": "^2.0.2",
+    "open": "^10.1.0"
+  }
+}