@miphamai/cli 0.46.0 → 0.47.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.46.0",
+  "version": "0.47.0",
   "description": "Mipham Code — Multi-model open-core intelligent coding terminal by MiphamAI",
   "keywords": [
     "ai",
@@ -41,6 +41,7 @@
     "test": "vitest run"
   },
   "dependencies": {
+    "@larksuiteoapi/node-sdk": "^1.73.0",
     "commander": "^13.1.0",
     "ink": "^5.2.1",
     "ink-text-input": "^6.0.0",

package/src/daemon/feishu/adapter.ts

@@ -0,0 +1,79 @@
+import { createFeishuApi } from './api.js'
+import { createFeishuEventDispatcher } from './events.js'
+import type { FeishuConfig, FeishuTextMessage } from './types.js'
+import type { SessionManager } from '../session-manager'
+import type { SessionWorker } from '../session-worker'
+import type { RateLimiter } from '../rate-limiter'
+
+export interface FeishuAdapterDeps {
+  sm: SessionManager
+  getOrCreateWorker: (sessionId: string) => SessionWorker | null
+  rateLimiter: RateLimiter
+  cwd: string
+  provider: string
+  model: string
+}
+
+export interface FeishuAdapter {
+  handleEvent(request: Request): Promise<Response>
+  isAllowed(openId: string): boolean
+}
+
+export function createFeishuAdapter(config: FeishuConfig, deps: FeishuAdapterDeps): FeishuAdapter {
+  const api = createFeishuApi(config)
+  const allowed = new Set(config.allowedOpenIds)
+
+  const onMessage = async (msg: FeishuTextMessage) => {
+    try {
+      if (!allowed.has(msg.openId)) return
+      if (!deps.rateLimiter.check(`feishu:${msg.openId}`).allowed) return
+
+      const session = deps.sm.getOrCreateByFeishuOpenId(
+        msg.openId,
+        deps.cwd,
+        deps.provider,
+        deps.model,
+      )
+      const worker = deps.getOrCreateWorker(session.id)
+      if (!worker) {
+        await api.sendText(msg.openId, '（会话初始化失败，请稍后重试）')
+        return
+      }
+      await worker.processPrompt(msg.text)
+      const result = worker.getLastAssistantContent()
+      await api.sendText(msg.openId, result ? result.slice(0, 4000) : '（无回复）')
+    } catch (err) {
+      console.error('[feishu] message handling failed:', err)
+      try {
+        await api.sendText(msg.openId, '（处理失败，请稍后重试）')
+      } catch {
+        /* 忽略回送失败，确保不 rethrow → Feishu 不重试 */
+      }
+    }
+  }
+
+  const dispatcher = createFeishuEventDispatcher(config, onMessage)
+
+  return {
+    isAllowed: (openId) => allowed.has(openId),
+    async handleEvent(request: Request): Promise<Response> {
+      let body: unknown = {}
+      try {
+        body = await request.json()
+      } catch {
+        /* 非 JSON body 容忍 */
+      }
+      // URL 验证：回显 challenge（未加密）
+      if (body && typeof body === 'object' && 'challenge' in (body as object)) {
+        return Response.json({ challenge: (body as { challenge: string }).challenge })
+      }
+      const headers: Record<string, string> = {}
+      request.headers.forEach((v, k) => (headers[k] = v))
+      const result = await dispatcher.invoke(body, headers)
+      if (!result.ok) {
+        return Response.json({ code: 1, msg: result.reason }, { status: 400 })
+      }
+      return Response.json({ code: 0 })
+    },
+  }
+}

package/src/daemon/feishu/api.ts

@@ -0,0 +1,23 @@
+import * as lark from '@larksuiteoapi/node-sdk'
+import type { FeishuConfig } from './types.js'
+
+export interface FeishuApi {
+  sendText(openId: string, text: string): Promise<void>
+}
+
+export function createFeishuApi(config: FeishuConfig): FeishuApi {
+  const client = new lark.Client({
+    appId: config.appId,
+    appSecret: config.appSecret,
+    appType: lark.AppType.SelfBuild,
+    domain: lark.Domain.Feishu,
+  })
+  return {
+    async sendText(openId: string, text: string): Promise<void> {
+      await client.im.message.create({
+        params: { receive_id_type: 'open_id' },
+        data: { receive_id: openId, msg_type: 'text', content: JSON.stringify({ text }) },
+      })
+    },
+  }
+}

package/src/daemon/feishu/env.ts

@@ -0,0 +1,22 @@
+import type { FeishuConfig } from './types.js'
+
+export function parseFeishuEnv(): FeishuConfig | null {
+  const appId = process.env.FEISHU_APP_ID
+  const appSecret = process.env.FEISHU_APP_SECRET
+  const encryptKey = process.env.FEISHU_ENCRYPT_KEY || ''
+  const verificationToken = process.env.FEISHU_VERIFICATION_TOKEN || ''
+  // Fail-closed：encryptKey 必填。lark SDK 对 im.message.receive_v1 事件流的签名验证
+  // 只依赖 encryptKey（checkIsEventValidated 在空 key 时静默返回 true）；
+  // verificationToken 仅用于 URL challenge 握手，不保护事件流，故保持可选。
+  if (!appId || !appSecret || !encryptKey) return null
+  return {
+    appId,
+    appSecret,
+    encryptKey,
+    verificationToken,
+    allowedOpenIds: (process.env.FEISHU_ALLOWED_OPEN_IDS || '')
+      .split(',')
+      .map((s) => s.trim())
+      .filter(Boolean),
+  }
+}

package/src/daemon/feishu/events.ts

@@ -0,0 +1,53 @@
+import * as lark from '@larksuiteoapi/node-sdk'
+import type { FeishuConfig, FeishuTextMessage } from './types.js'
+
+export type OnFeishuMessage = (msg: FeishuTextMessage) => Promise<void>
+
+export type FeishuInvokeResult =
+  { ok: true } | { ok: false; reason: 'invalid_signature' | 'no_handler' | 'parse_failed' }
+
+export interface FeishuEventDispatcher {
+  invoke(body: unknown, headers: Record<string, string>): Promise<FeishuInvokeResult>
+}
+
+export function createFeishuEventDispatcher(
+  config: FeishuConfig,
+  onMessage: OnFeishuMessage,
+): FeishuEventDispatcher {
+  const dispatcher = new lark.EventDispatcher({
+    encryptKey: config.encryptKey,
+    verificationToken: config.verificationToken,
+  }).register({
+    'im.message.receive_v1': async (data: any): Promise<true> => {
+      const message = data?.message
+      if (message?.message_type !== 'text') return true
+      let text = ''
+      try {
+        text = JSON.parse(message.content).text ?? ''
+      } catch {
+        return true
+      }
+      const openId = data?.sender?.sender_id?.open_id
+      if (!openId || !text) return true
+      await onMessage({ chatId: message.chat_id, messageId: message.message_id, openId, text })
+      return true
+    },
+  })
+
+  return {
+    async invoke(body, headers): Promise<FeishuInvokeResult> {
+      const assigned = Object.assign(Object.create({ headers }), body)
+      let raw: unknown
+      try {
+        raw = await dispatcher.invoke(assigned)
+      } catch {
+        return { ok: false, reason: 'parse_failed' }
+      }
+      if (raw === undefined) return { ok: false, reason: 'invalid_signature' }
+      if (typeof raw === 'string' && raw.startsWith('no ')) {
+        return { ok: false, reason: 'no_handler' }
+      }
+      return { ok: true }
+    },
+  }
+}

package/src/daemon/feishu/types.ts

@@ -0,0 +1,14 @@
+export interface FeishuConfig {
+  appId: string
+  appSecret: string
+  encryptKey: string
+  verificationToken: string
+  allowedOpenIds: string[]
+}
+
+export interface FeishuTextMessage {
+  chatId: string
+  messageId: string
+  openId: string
+  text: string
+}

package/src/daemon/index.ts

@@ -23,6 +23,9 @@ import { RateLimiter } from './rate-limiter'
 import { PACKAGE_VERSION } from '../shared/package-info'
 import type { DaemonStatus } from './types'
 import { logger } from './logger'
+import { parseFeishuEnv } from './feishu/env.js'
+import type { FeishuConfig } from './feishu/types.js'
+import { loadConfig } from '../config/loader'
 
 const HOME = homedir()
 const MIPHAM_HOME = join(HOME, '.mipham')
@@ -163,6 +166,21 @@ export async function startDaemon(): Promise<{ port: number; token: string }> {
   const rateLimiter = new RateLimiter(100, 60_000)
   activeRateLimiter = rateLimiter
 
+  // Feishu remote-control adapter（env 未配置时跳过；配置则解析 session 默认 provider/model）
+  const feishuConfig = parseFeishuEnv()
+  let feishu: { config: FeishuConfig; cwd: string; provider: string; model: string } | undefined
+  if (feishuConfig) {
+    const cfg = loadConfig()
+    // 取第一个非 upcoming（即非「待上线」）的 provider 及其首个 model
+    const provider = cfg.providers.find((p) => p.status !== 'upcoming') ?? cfg.providers[0]
+    feishu = {
+      config: feishuConfig,
+      cwd: process.env.FEISHU_CWD || process.cwd(),
+      provider: provider?.id ?? 'anthropic',
+      model: provider?.models?.[0]?.id ?? 'claude-sonnet-5',
+    }
+  }
+
   // Start HTTP server (Bun.serve starts listening immediately)
   const server = createServer({
     db,
@@ -177,6 +195,7 @@ export async function startDaemon(): Promise<{ port: number; token: string }> {
     goalManager,
     scheduleManager,
     rateLimiter,
+    feishu,
   })
   activeServer = server
 

package/src/daemon/server.ts

@@ -23,6 +23,8 @@ import { createToolRegistry } from '../tools'
 import { PermissionSystem } from '../core/permission'
 import type { ProviderRegistry } from '../providers/registry'
 import type { ToolDefinition, PermissionMode } from '../shared/types'
+import { createFeishuAdapter } from './feishu/adapter.js'
+import type { FeishuConfig } from './feishu/types.js'
 
 interface ServerConfig {
   db: DaemonDatabase
@@ -37,6 +39,7 @@ interface ServerConfig {
   goalManager: GoalManager
   scheduleManager: ScheduleManager
   rateLimiter: RateLimiter
+  feishu?: { config: FeishuConfig; cwd: string; provider: string; model: string }
 }
 
 interface WsData {
@@ -78,6 +81,7 @@ export function createServer(config: ServerConfig): Server<WsData> {
     goalManager,
     scheduleManager,
     rateLimiter,
+    feishu,
   } = config
 
   const wsClients = new Map<string, Set<ServerWebSocket<WsData>>>()
@@ -198,6 +202,18 @@ export function createServer(config: ServerConfig): Server<WsData> {
     }
   }
 
+  // ── Feishu remote-control adapter（独立签名验证，复用同一 worker 池）──
+  const feishuAdapter = feishu
+    ? createFeishuAdapter(feishu.config, {
+        sm,
+        getOrCreateWorker,
+        rateLimiter,
+        cwd: feishu.cwd,
+        provider: feishu.provider,
+        model: feishu.model,
+      })
+    : undefined
+
   const server = Bun.serve<WsData>({
     port,
     hostname,
@@ -211,6 +227,11 @@ export function createServer(config: ServerConfig): Server<WsData> {
       const method = req.method
       logger.info('request', { method, path })
 
+      // ── Feishu event callback（独立签名验证，不经过 daemon Bearer 鉴权）──
+      if (feishuAdapter && method === 'POST' && path === '/feishu/event') {
+        return await feishuAdapter.handleEvent(req)
+      }
+
       // ── Rate limiting (skip health endpoint) ──────────
       if (path !== '/api/v1/health') {
         const ip = server.requestIP(req)?.address || 'unknown'

package/src/daemon/session-manager.ts

@@ -23,6 +23,18 @@ export class SessionManager {
     return this.db.listSessions(status)
   }
 
+  getOrCreateByFeishuOpenId(
+    openId: string,
+    cwd: string,
+    provider: string,
+    model: string,
+  ): DaemonSession {
+    const name = `feishu-${openId}`
+    const existing = this.db.listSessions().find((s) => s.name === name && s.status !== 'closed')
+    if (existing) return existing
+    return this.db.createSession({ name, cwd, provider, model })
+  }
+
   closeSession(id: string): void {
     this.db.closeSession(id)
     for (const cb of this.closeCallbacks) {

package/src/daemon/session-worker.ts

@@ -253,6 +253,11 @@ export class SessionWorker {
     return this.session.id
   }
 
+  /** Get the last assistant text content from the underlying engine. */
+  getLastAssistantContent(): string | undefined {
+    return this.engine.getLastAssistantContent()
+  }
+
   // ── Persistence ────────────────────────────────────────────────────────
 
   /**

package/src/shared/package-info.ts

@@ -9,7 +9,7 @@
 export const PACKAGE_NAME = '@miphamai/cli' as const
 
 /** 当前发布版本 */
-export const PACKAGE_VERSION = '0.46.0' as const
+export const PACKAGE_VERSION = '0.47.0' as const
 
 /** npm install 全局安装命令 */
 export const NPM_INSTALL_COMMAND = `npm install -g ${PACKAGE_NAME}` as const