@miphamai/cli 0.45.1 → 0.47.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@miphamai/cli",
-  "version": "0.45.1",
+  "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.45.1' 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

package/src/tools/exec/task.ts

@@ -1,6 +1,6 @@
 import type { ToolDefinition } from '../../shared/index.ts'
 
-interface Task {
+export interface Task {
   id: string
   subject: string
   description: string
@@ -20,6 +20,11 @@ interface Task {
 const tasks = new Map<string, Task>()
 let taskCounter = 0
 
+/** Read accessor for the session task store — returns all non-deleted tasks. */
+export function getTasks(): Task[] {
+  return Array.from(tasks.values()).filter((t) => t.status !== 'deleted')
+}
+
 function formatTask(t: Task): string {
   const meta = t.metadata ? ` ${JSON.stringify(t.metadata)}` : ''
   const blocks = t.blocks.length ? ` blocks:[${t.blocks.join(',')}]` : ''

package/src/ui/app.tsx

@@ -20,6 +20,7 @@ import { AgentFooter, type AgentEntry } from './agent-footer'
 import { AgentViewDashboard } from '../agent-view/dashboard'
 import type { AgentViewManager } from '../agent-view/agent-view-manager'
 import { WorkflowProgress } from './workflow-progress.js'
+import { GoalProgress } from './goal-progress.js'
 import {
   getCommand,
   looksLikeSlashCommand,
@@ -828,6 +829,17 @@ export function App({
         {/* Workflow progress — auto-detects active workflows, renders nothing when idle */}
         <WorkflowProgress />
 
+        {/* Goal progress — live goal + subtasks + done/total · elapsed · tokens (auto-hides when no goal) */}
+        <GoalProgress
+          goal={goalText}
+          getTokens={() => {
+            const tracker = engine.getUsageTracker()
+            if (!tracker) return 0
+            if ('totalApiTokens' in tracker) return tracker.totalApiTokens
+            return Object.values(tracker.getStats()).reduce((a, b) => a + b, 0)
+          }}
+        />
+
         {/* Agent View Dashboard — Ctrl+G overlay (replaces chat + input) */}
         {agentViewOpen && agentViewManager ? (
           <AgentViewDashboard
@@ -935,11 +947,6 @@ export function App({
 
             {/* Status line — Claude Code style */}
             <Box marginTop={1} flexDirection="column">
-              {goalText && (
-                <Box>
-                  <Text color="green">🎯 Goal: {goalText}</Text>
-                </Box>
-              )}
               <Box flexDirection="row">
                 <Text color={PERMISSION_COLORS[permissionMode]}>
                   ⏵⏵ {PERMISSION_LABELS[permissionMode]}

package/src/ui/goal-progress.tsx

@@ -0,0 +1,137 @@
+import { useState, useEffect, useRef } from 'react'
+import { Box, Text } from 'ink'
+import { getTasks } from '../tools/exec/task.js'
+import type { Task } from '../tools/exec/task.js'
+
+export interface GoalProgressProps {
+  goal: string
+  /** Read current session token total; defaults to 0. */
+  getTokens?: () => number
+  /** Read current tasks; defaults to the real task store. */
+  listTasks?: () => Task[]
+}
+
+export interface TaskSummary {
+  total: number
+  done: number
+  inProgress: number
+  pending: number
+  failed: number
+}
+
+/** Count tasks by status, ignoring deleted. */
+export function summarizeTasks(tasks: Task[]): TaskSummary {
+  const summary: TaskSummary = { total: 0, done: 0, inProgress: 0, pending: 0, failed: 0 }
+  for (const t of tasks) {
+    if (t.status === 'deleted') continue
+    summary.total++
+    if (t.status === 'completed') summary.done++
+    else if (t.status === 'in_progress') summary.inProgress++
+    else if (t.status === 'pending') summary.pending++
+    else if (t.status === 'failed') summary.failed++
+  }
+  return summary
+}
+
+/** Format a token count: raw under 1000, `1.2K` style above. */
+export function formatTokens(n: number): string {
+  if (n >= 1000) return `${(n / 1000).toFixed(1)}K`
+  return String(n)
+}
+
+function formatElapsed(ms: number): string {
+  const s = Math.floor(ms / 1000)
+  if (s < 60) return `${s}s`
+  const m = Math.floor(s / 60)
+  return `${m}m ${s % 60}s`
+}
+
+function taskIcon(status: Task['status']): { icon: string; color?: string; dim?: boolean } {
+  switch (status) {
+    case 'completed':
+      return { icon: '✓', color: 'green' }
+    case 'in_progress':
+      return { icon: '⏳', color: 'yellow' }
+    case 'failed':
+      return { icon: '✗', color: 'red' }
+    default:
+      return { icon: '📋', dim: true }
+  }
+}
+
+/** Live goal progress panel — mirrors ZCode's goal view: title + subtasks + done/total · elapsed · tokens. */
+export function GoalProgress({ goal, getTokens, listTasks }: GoalProgressProps) {
+  const [tasks, setTasks] = useState<Task[]>([])
+  const [tokens, setTokens] = useState(0)
+  const [elapsedMs, setElapsedMs] = useState(0)
+
+  // Hold latest callbacks in refs so the interval doesn't churn on re-render.
+  const listTasksRef = useRef(listTasks ?? getTasks)
+  const getTokensRef = useRef(getTokens ?? (() => 0))
+  listTasksRef.current = listTasks ?? getTasks
+  getTokensRef.current = getTokens ?? (() => 0)
+
+  useEffect(() => {
+    if (!goal) {
+      setTasks([])
+      setTokens(0)
+      setElapsedMs(0)
+      return
+    }
+    const start = Date.now()
+    const tick = () => {
+      setTasks(listTasksRef.current())
+      setTokens(getTokensRef.current())
+      setElapsedMs(Date.now() - start)
+    }
+    tick()
+    const timer = setInterval(tick, 1000)
+    return () => clearInterval(timer)
+  }, [goal])
+
+  if (!goal) return null
+
+  const summary = summarizeTasks(tasks)
+  const visibleTasks = tasks.filter((t) => t.status !== 'deleted')
+
+  return (
+    <Box
+      flexDirection="column"
+      borderStyle="round"
+      borderColor="cyan"
+      paddingX={1}
+      marginBottom={1}
+    >
+      <Text bold color="green">
+        🎯 Goal: {goal}
+      </Text>
+
+      {visibleTasks.length === 0 ? (
+        <Text dimColor> (no subtasks yet)</Text>
+      ) : (
+        visibleTasks.map((t) => {
+          const meta = taskIcon(t.status)
+          return (
+            <Box key={t.id} marginLeft={1}>
+              <Text color={meta.color} dimColor={meta.dim}>
+                {meta.icon} {t.subject}
+              </Text>
+            </Box>
+          )
+        })
+      )}
+
+      <Box marginTop={1}>
+        <Text dimColor>
+          ═══ {summary.done}/{summary.total} done
+          {summary.inProgress > 0 && ` · ${summary.inProgress} in progress`}
+          {summary.failed > 0 && ` · ${summary.failed} failed`}
+          {' · '}
+          {formatElapsed(elapsedMs)}
+          {tokens > 0 && ` · ${formatTokens(tokens)} tokens`}
+          {' ═══'}
+        </Text>
+      </Box>
+    </Box>
+  )
+}