@leviyuan/lodestar 0.1.0 → 2.0.14

package/feishu-mcp.ts

@@ -0,0 +1,482 @@
+#!/usr/bin/env bun
+/**
+ * Feishu MCP Server for DeepSeek TUI.
+ *
+ * Stateless design: every tool receives a `chat_id` parameter. No file-based
+ * message queues, no Claude-specific channel notifications. DeepSeek loads
+ * this server as a global MCP tool provider via ~/.deepseek/mcp.json.
+ *
+ * Tools: feishu_reply / feishu_react / feishu_send_file / feishu_fetch_history
+ *
+ * State paths migrated to ~/.deepseek/lodestar/.
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import {
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js'
+import { z } from 'zod'
+import * as lark from '@larksuiteoapi/node-sdk'
+import {
+  readFileSync, writeFileSync, mkdirSync, statSync, unlinkSync,
+  realpathSync, chmodSync, existsSync,
+} from 'fs'
+import { homedir } from 'os'
+import { join, extname, basename, sep } from 'path'
+
+// ── State paths ──────────────────────────────────────────────────────────────
+
+const STATE_DIR = join(homedir(), '.deepseek', 'lodestar')
+
+const APP_ID = process.env.FEISHU_APP_ID
+const APP_SECRET = process.env.FEISHU_APP_SECRET
+
+if (!APP_ID || !APP_SECRET) {
+  process.stderr.write(
+    `feishu mcp: FEISHU_APP_ID and FEISHU_APP_SECRET required\n` +
+    `  set in ~/.deepseek/lodestar.toml under [feishu]\n`,
+  )
+  process.exit(1)
+}
+
+// ── Retry helper ────────────────────────────────────────────────────────────
+
+async function withRetry<T>(fn: () => Promise<T>, maxAttempts = 3, baseDelayMs = 500): Promise<T> {
+  for (let attempt = 1; ; attempt++) {
+    try {
+      return await fn()
+    } catch (err) {
+      if (attempt >= maxAttempts) throw err
+      const delay = baseDelayMs * attempt
+      process.stderr.write(`feishu mcp: retry ${attempt}/${maxAttempts} after ${delay}ms: ${err}\n`)
+      await new Promise(r => setTimeout(r, delay))
+    }
+  }
+}
+
+// ── Lark client ──────────────────────────────────────────────────────────────
+
+const client = new lark.Client({
+  appId: APP_ID,
+  appSecret: APP_SECRET,
+  disableTokenCache: false,
+})
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+const MAX_TEXT_LENGTH = 4000
+const MAX_CARD_CONTENT_LENGTH = 28000
+const MAX_ATTACHMENT_BYTES = 50 * 1024 * 1024
+
+function hasMarkdown(text: string): boolean {
+  return /(?:^#{1,6}\s|^[-*]\s|^\d+\.\s|```|\*\*.+\*\*|`[^`]+`|^\|.+\|)/m.test(text)
+}
+
+function markdownToCard(text: string): string {
+  const elements: any[] = []
+  const parts = chunk(text, MAX_CARD_CONTENT_LENGTH)
+  for (const part of parts) {
+    elements.push({
+      tag: 'markdown',
+      content: part,
+    })
+  }
+  return JSON.stringify({
+    schema: '2.0',
+    config: { wide_screen_mode: true },
+    body: { elements },
+  })
+}
+
+function chunk(text: string, limit: number): string[] {
+  if (text.length <= limit) return [text]
+  const out: string[] = []
+  let rest = text
+  while (rest.length > limit) {
+    const para = rest.lastIndexOf('\n\n', limit)
+    const line = rest.lastIndexOf('\n', limit)
+    const space = rest.lastIndexOf(' ', limit)
+    const cut = para > limit / 2 ? para : line > limit / 2 ? line : space > 0 ? space : limit
+    out.push(rest.slice(0, cut))
+    rest = rest.slice(cut).replace(/^\n+/, '')
+  }
+  if (rest) out.push(rest)
+  return out
+}
+
+function assertSendable(f: string): void {
+  let real: string, stateReal: string
+  try {
+    real = realpathSync(f)
+    stateReal = realpathSync(STATE_DIR)
+  } catch { return }
+  if (real.startsWith(stateReal + sep)) {
+    throw new Error(`refusing to send channel state: ${f}`)
+  }
+}
+
+const IMAGE_EXTS = new Set(['.jpg', '.jpeg', '.png', '.gif', '.webp', '.bmp'])
+
+// ── Feishu API helpers ──────────────────────────────────────────────────────
+
+async function getTenantToken(): Promise<string> {
+  const res = await fetch('https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ app_id: APP_ID, app_secret: APP_SECRET }),
+  })
+  const json = await res.json() as any
+  return json.tenant_access_token ?? ''
+}
+
+async function uploadImage(filePath: string): Promise<string> {
+  const token = await getTenantToken()
+  const buf = readFileSync(filePath)
+  const form = new FormData()
+  form.append('image_type', 'message')
+  form.append('image', new File([buf], basename(filePath)))
+  const res = await fetch('https://open.feishu.cn/open-apis/im/v1/images', {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${token}` },
+    body: form,
+  })
+  const json = await res.json() as any
+  return json?.data?.image_key ?? ''
+}
+
+async function uploadFile(filePath: string): Promise<string> {
+  const token = await getTenantToken()
+  const buf = readFileSync(filePath)
+  const form = new FormData()
+  form.append('file_type', 'stream')
+  form.append('file_name', basename(filePath))
+  form.append('file', new File([buf], basename(filePath)))
+  const res = await fetch('https://open.feishu.cn/open-apis/im/v1/files', {
+    method: 'POST',
+    headers: { Authorization: `Bearer ${token}` },
+    body: form,
+  })
+  const json = await res.json() as any
+  return json?.data?.file_key ?? ''
+}
+
+// ── MCP Server ───────────────────────────────────────────────────────────────
+
+const mcp = new Server(
+  { name: 'feishu', version: '1.0.0' },
+  {
+    capabilities: {
+      tools: {},
+    },
+  },
+)
+
+// ── Tool definitions ─────────────────────────────────────────────────────────
+
+mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'feishu_reply',
+      description:
+        'Send a reply to the Feishu group. Text with markdown formatting is rendered as an interactive card. ' +
+        'Optionally attach files (images are sent inline, others as file attachments).',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          chat_id: { type: 'string', description: 'The Feishu chat ID to send to.' },
+          text: { type: 'string', description: 'The message text (supports markdown).' },
+          reply_to: { type: 'string', description: 'Message ID to reply to (optional).' },
+          files: {
+            type: 'array',
+            items: { type: 'string' },
+            description: 'Absolute file paths to attach (optional).',
+          },
+        },
+        required: ['chat_id', 'text'],
+      },
+    },
+    {
+      name: 'feishu_react',
+      description:
+        'Add or remove a reaction (emoji) on a Feishu message. Used for status indication (e.g. 👌 OK, ✅ done).',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          chat_id: { type: 'string', description: 'The Feishu chat ID (for context, not required by API).' },
+          message_id: { type: 'string', description: 'The message ID to react to.' },
+          emoji_type: { type: 'string', description: 'Emoji type name (e.g. OK, CheckMark, CrossMark, HEART).' },
+          action: {
+            type: 'string',
+            enum: ['add', 'remove'],
+            description: 'Whether to add or remove the reaction.',
+          },
+        },
+        required: ['message_id', 'emoji_type', 'action'],
+      },
+    },
+    {
+      name: 'feishu_send_file',
+      description:
+        'Upload and send a file or image to the Feishu group. Images are sent as inline images, other files as attachments.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          chat_id: { type: 'string', description: 'The Feishu chat ID to send to.' },
+          file_path: { type: 'string', description: 'Absolute path to the file to send.' },
+        },
+        required: ['chat_id', 'file_path'],
+      },
+    },
+    {
+      name: 'feishu_fetch_history',
+      description:
+        'Fetch recent messages from a Feishu group chat. Useful for understanding conversation context.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          chat_id: { type: 'string', description: 'The Feishu chat ID to fetch history from.' },
+          limit: {
+            type: 'number',
+            description: 'Maximum number of messages to fetch (default 20, max 50).',
+          },
+        },
+        required: ['chat_id'],
+      },
+    },
+  ],
+}))
+
+// ── Tool handlers ────────────────────────────────────────────────────────────
+
+mcp.setRequestHandler(CallToolRequestSchema, async req => {
+  const args = (req.params.arguments ?? {}) as Record<string, unknown>
+  try {
+    switch (req.params.name) {
+      case 'feishu_reply': {
+        const chat_id = args.chat_id as string
+        if (!chat_id) throw new Error('chat_id is required')
+        const text = args.text as string
+        const files = (args.files as string[] | undefined) ?? []
+        const reply_to = args.reply_to as string | undefined
+
+        for (const f of files) {
+          assertSendable(f)
+          const st = statSync(f)
+          if (st.size > MAX_ATTACHMENT_BYTES) {
+            throw new Error(`file too large: ${f} (${(st.size / 1024 / 1024).toFixed(1)}MB, max 50MB)`)
+          }
+        }
+
+        const chunks = chunk(text, MAX_TEXT_LENGTH)
+        const sentIds: string[] = []
+
+        const useCard = hasMarkdown(text)
+        process.stderr.write(`feishu mcp: reply useCard=${useCard} textLen=${text.length}\n`)
+        if (useCard) {
+          const cardParts = chunk(text, MAX_CARD_CONTENT_LENGTH)
+          for (const part of cardParts) {
+            const card = markdownToCard(part)
+            const res = await withRetry(() => client.im.message.create({
+              params: { receive_id_type: 'chat_id' },
+              data: {
+                receive_id: chat_id,
+                msg_type: 'interactive',
+                content: card,
+                ...(reply_to ? { root_id: reply_to } : {}),
+              },
+            }))
+            if (res.data?.message_id) sentIds.push(res.data.message_id)
+          }
+        } else {
+          for (const c of chunks) {
+            const res = await withRetry(() => client.im.message.create({
+              params: { receive_id_type: 'chat_id' },
+              data: {
+                receive_id: chat_id,
+                msg_type: 'text',
+                content: JSON.stringify({ text: c }),
+                ...(reply_to ? { root_id: reply_to } : {}),
+              },
+            }))
+            if (res.data?.message_id) sentIds.push(res.data.message_id)
+          }
+        }
+
+        for (const f of files) {
+          const ext = extname(f).toLowerCase()
+          if (IMAGE_EXTS.has(ext)) {
+            const imageKey = await uploadImage(f)
+            if (imageKey) {
+              const res = await withRetry(() => client.im.message.create({
+                params: { receive_id_type: 'chat_id' },
+                data: {
+                  receive_id: chat_id,
+                  msg_type: 'image',
+                  content: JSON.stringify({ image_key: imageKey }),
+                  ...(reply_to ? { root_id: reply_to } : {}),
+                },
+              }))
+              if (res.data?.message_id) sentIds.push(res.data.message_id)
+            }
+          } else {
+            const fileKey = await uploadFile(f)
+            if (fileKey) {
+              const res = await withRetry(() => client.im.message.create({
+                params: { receive_id_type: 'chat_id' },
+                data: {
+                  receive_id: chat_id,
+                  msg_type: 'file',
+                  content: JSON.stringify({ file_key: fileKey }),
+                  ...(reply_to ? { root_id: reply_to } : {}),
+                },
+              }))
+              if (res.data?.message_id) sentIds.push(res.data.message_id)
+            }
+          }
+        }
+
+        const result = sentIds.length === 1
+          ? `sent (id: ${sentIds[0]})`
+          : `sent ${sentIds.length} parts (ids: ${sentIds.join(', ')})`
+        return { content: [{ type: 'text', text: result }] }
+      }
+
+      case 'feishu_react': {
+        const message_id = args.message_id as string
+        const emoji_type = args.emoji_type as string
+        const action = (args.action as string) || 'add'
+
+        if (!message_id) throw new Error('message_id is required')
+        if (!emoji_type) throw new Error('emoji_type is required')
+
+        if (action === 'add') {
+          const res: any = await client.im.messageReaction.create({
+            path: { message_id },
+            data: { reaction_type: { emoji_type } },
+          })
+          const rid = res?.data?.reaction_id
+          return { content: [{ type: 'text', text: `added reaction ${emoji_type} (reaction_id: ${rid})` }] }
+        } else {
+          // For remove, we need reaction_id — but that requires knowing it first.
+          // In practice, daemon handles reactions directly. This tool exists for
+          // DeepSeek to add reactions when useful.
+          return { content: [{ type: 'text', text: `remove not yet supported (daemon handles react lifecycle)` }], isError: true }
+        }
+      }
+
+      case 'feishu_send_file': {
+        const chat_id = args.chat_id as string
+        const file_path = args.file_path as string
+
+        if (!chat_id) throw new Error('chat_id is required')
+        if (!file_path) throw new Error('file_path is required')
+        assertSendable(file_path)
+
+        const st = statSync(file_path)
+        if (st.size > MAX_ATTACHMENT_BYTES) {
+          throw new Error(`file too large: ${file_path} (${(st.size / 1024 / 1024).toFixed(1)}MB, max 50MB)`)
+        }
+
+        const ext = extname(file_path).toLowerCase()
+        if (IMAGE_EXTS.has(ext)) {
+          const imageKey = await uploadImage(file_path)
+          if (!imageKey) throw new Error('image upload failed')
+          const res = await withRetry(() => client.im.message.create({
+            params: { receive_id_type: 'chat_id' },
+            data: {
+              receive_id: chat_id,
+              msg_type: 'image',
+              content: JSON.stringify({ image_key: imageKey }),
+            },
+          }))
+          return { content: [{ type: 'text', text: `image sent (id: ${res.data?.message_id})` }] }
+        } else {
+          const fileKey = await uploadFile(file_path)
+          if (!fileKey) throw new Error('file upload failed')
+          const res = await withRetry(() => client.im.message.create({
+            params: { receive_id_type: 'chat_id' },
+            data: {
+              receive_id: chat_id,
+              msg_type: 'file',
+              content: JSON.stringify({ file_key: fileKey }),
+            },
+          }))
+          return { content: [{ type: 'text', text: `file sent (id: ${res.data?.message_id})` }] }
+        }
+      }
+
+      case 'feishu_fetch_history': {
+        const chat_id = args.chat_id as string
+        if (!chat_id) throw new Error('chat_id is required')
+        const limit = Math.min((args.limit as number) || 20, 50)
+
+        const res = await client.im.message.list({
+          params: {
+            receive_id_type: 'chat_id',
+            receive_id: chat_id,
+            page_size: limit,
+          },
+        })
+
+        const messages = (res.data?.items ?? []).map((m: any) => {
+          let content = ''
+          try {
+            const obj = JSON.parse(m.body?.content ?? '{}')
+            content = obj.text ?? JSON.stringify(obj)
+          } catch { content = m.body?.content ?? '' }
+
+          return {
+            message_id: m.message_id,
+            sender: m.sender?.id ?? 'unknown',
+            content,
+            create_time: m.create_time,
+            msg_type: m.msg_type,
+          }
+        })
+
+        return {
+          content: [{ type: 'text', text: JSON.stringify(messages, null, 2) }],
+        }
+      }
+
+      default:
+        return { content: [{ type: 'text', text: `unknown tool: ${req.params.name}` }], isError: true }
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err)
+    return { content: [{ type: 'text', text: `${req.params.name} failed: ${msg}` }], isError: true }
+  }
+})
+
+// ── Boot ─────────────────────────────────────────────────────────────────────
+
+process.on('unhandledRejection', err => {
+  process.stderr.write(`feishu mcp: unhandled rejection: ${err}\n`)
+})
+process.on('uncaughtException', err => {
+  process.stderr.write(`feishu mcp: uncaught exception: ${err}\n`)
+})
+
+async function main() {
+  await mcp.connect(new StdioServerTransport())
+  process.stderr.write('feishu mcp: ready\n')
+}
+
+let shuttingDown = false
+function shutdown(): void {
+  if (shuttingDown) return
+  shuttingDown = true
+  process.stderr.write('feishu mcp: shutting down\n')
+  setTimeout(() => process.exit(0), 2000)
+}
+process.stdin.on('end', shutdown)
+process.stdin.on('close', shutdown)
+process.on('SIGTERM', shutdown)
+process.on('SIGINT', shutdown)
+
+main().catch(err => {
+  process.stderr.write(`feishu mcp: fatal: ${err}\n`)
+  process.exit(1)
+})

package/package.json

@@ -1,52 +1,51 @@
 {
   "name": "@leviyuan/lodestar",
-  "version": "0.1.0",
-  "publishConfig": {
-    "access": "public"
-  },
-  "description": "Lodestar (夜航星) — IM-native frontend for Claude Code via Feishu Card Kit streaming",
-  "type": "module",
+  "version": "2.0.14",
+  "description": "夜航星 (Lodestar) — DeepSeek TUI 飞书群协作通道",
   "license": "MIT",
-  "author": "leviyuan",
-  "homepage": "https://github.com/leviyuan/lodestar#readme",
-  "bugs": "https://github.com/leviyuan/lodestar/issues",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/leviyuan/lodestar.git"
-  },
-  "keywords": [
-    "feishu",
-    "lark",
-    "claude-code",
-    "claude",
-    "ai",
-    "agent",
-    "im",
-    "chat",
-    "card-kit",
-    "streaming",
-    "lodestar"
-  ],
-  "scripts": {
-    "start": "bun daemon.ts"
-  },
+  "type": "module",
   "bin": {
-    "lodestar-daemon": "./daemon.ts"
+    "lodestar": "./cli.ts"
   },
   "files": [
+    "cli.ts",
+    "config.ts",
     "daemon.ts",
-    "src/",
+    "feishu-mcp.ts",
+    "runtime-api.ts",
+    "email-worker.ts",
+    "status-dashboard.ts",
+    "env-bootstrap.ts",
+    "scripts/runtime-thread.sh",
+    "package.json",
     "README.md",
     "LICENSE"
   ],
-  "engines": {
-    "bun": ">=1.0.0"
+  "scripts": {
+    "postinstall": "bun cli.ts configure --silent 2>/dev/null || true"
   },
   "dependencies": {
-    "@larksuiteoapi/node-sdk": "^1.44.0"
+    "@larksuiteoapi/node-sdk": "^1.44.0",
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "imapflow": "^1.0.0",
+    "mailparser": "^3.9.8",
+    "nodemailer": "^6.9.0",
+    "zod": "^3.23.0"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
   },
-  "devDependencies": {
-    "@types/bun": "latest",
-    "typescript": "^5.5.0"
+  "keywords": [
+    "feishu",
+    "lark",
+    "deepseek",
+    "ai",
+    "collaboration",
+    "夜航星",
+    "lodestar"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/leviyuan/lodestar.git"
   }
 }