feat: feishu

bun.lock

@@ -21,6 +21,7 @@
         "@azure/identity": "^4.13.1",
         "@commander-js/extra-typings": "^14.0.0",
         "@growthbook/growthbook": "^1.6.5",
+        "@larksuite/channel": "^0.1.2",
         "@larksuiteoapi/node-sdk": "^1.60.0",
         "@modelcontextprotocol/sdk": "^1.29.0",
         "@opentelemetry/api": "^1.9.1",
@@ -81,6 +82,7 @@
         "plist": "^3.1.0",
         "proper-lockfile": "^4.1.2",
         "qrcode": "^1.5.4",
+        "qrcode-terminal": "^0.12.0",
         "react": "^19.2.4",
         "react-reconciler": "^0.33.0",
         "semver": "^7.7.4",
@@ -325,6 +327,8 @@
 
     "@js-sdsl/ordered-map": ["@js-sdsl/ordered-map@4.4.2", "", {}, "sha512-iUKgm52T8HOE/makSxjqoWhe95ZJA1/G1sYsGev2JDKUSS14KAgg1LHb+Ba+IPow0xflbnSkOsZcO08C7w1gYw=="],
 
+    "@larksuite/channel": ["@larksuite/channel@0.1.2", "", { "dependencies": { "@larksuiteoapi/node-sdk": "^1.66.1", "https-proxy-agent": "^9.0.0" } }, "sha512-9bhxF8lCFsYiOq+E9Swg1/5nqJLJNPsVLTGIdEE8hcqRKg/Dwazh4UKP0jHjiFf8yI8KKTfsEkA2P6PUFmSZQw=="],
+
     "@larksuiteoapi/node-sdk": ["@larksuiteoapi/node-sdk@1.66.1", "", { "dependencies": { "axios": "~1.13.3", "lodash.identity": "^3.0.0", "lodash.merge": "^4.6.2", "lodash.pickby": "^4.6.0", "protobufjs": "^7.2.6", "qs": "^6.14.2", "ws": "^8.19.0" } }, "sha512-W1rIAs/8Oc/rEYuWc0sxGvR8iLwd8p5D2RS4ODMqs8htIxK8yIa8sb22EDv/OEBqUpKXZaNLydTz7Oq8HOQROg=="],
 
     "@mixmark-io/domino": ["@mixmark-io/domino@2.2.0", "", {}, "sha512-Y28PR25bHXUg88kCV7nivXrP2Nj2RueZ3/l/jdx6J9f8J4nsEGcgX0Qe6lt7Pa+J79+kPiJU3LguR6O/6zrLOw=="],
@@ -939,10 +943,14 @@
 
     "proxy-addr": ["proxy-addr@2.0.7", "", { "dependencies": { "forwarded": "0.2.0", "ipaddr.js": "1.9.1" } }, "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg=="],
 
+    "proxy-agent-negotiate": ["proxy-agent-negotiate@1.1.0", "", { "peerDependencies": { "kerberos": "^2.0.0" }, "optionalPeers": ["kerberos"] }, "sha512-N8IBcM3UgCVzz2L2Lqv8DVntDnnC8/hiV4nEDUPkqq72TPUgYWjQc+bdZlBPZK9LzPAvOY//gAt0S0DApoOXWQ=="],
+
     "proxy-from-env": ["proxy-from-env@2.1.0", "", {}, "sha512-cJ+oHTW1VAEa8cJslgmUZrc+sjRKgAKl3Zyse6+PV38hZe/V6Z14TbCuXcan9F9ghlz4QrFr2c92TNF82UkYHA=="],
 
     "qrcode": ["qrcode@1.5.4", "", { "dependencies": { "dijkstrajs": "^1.0.1", "pngjs": "^5.0.0", "yargs": "^15.3.1" }, "bin": { "qrcode": "bin/qrcode" } }, "sha512-1ca71Zgiu6ORjHqFBDpnSMTR2ReToX4l1Au1VFLyVeBTFavzQnv5JxMFr3ukHVKpSrSA2MCk0lNJSykjUfz7Zg=="],
 
+    "qrcode-terminal": ["qrcode-terminal@0.12.0", "", { "bin": { "qrcode-terminal": "./bin/qrcode-terminal.js" } }, "sha512-EXtzRZmC+YGmGlDFbXKxQiMZNwCLEO6BANKXG4iCtSIM0yqc/pappSx3RIKr4r0uh5JsBckOXeKrB3Iz7mdQpQ=="],
+
     "qs": ["qs@6.15.2", "", { "dependencies": { "side-channel": "^1.1.0" } }, "sha512-Rzq0KEyX/w/tEybncDgdkZrJgVUsUMk3xjh3t5bv3S1HTAtg+uOYt72+ZfwiQwKdysThkTBdL/rTi6HDmX9Ddw=="],
 
     "range-parser": ["range-parser@1.2.1", "", {}, "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg=="],
@@ -1227,6 +1235,8 @@
 
     "@inquirer/select/ansi-escapes": ["ansi-escapes@4.3.2", "", { "dependencies": { "type-fest": "^0.21.3" } }, "sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ=="],
 
+    "@larksuite/channel/https-proxy-agent": ["https-proxy-agent@9.1.0", "", { "dependencies": { "agent-base": "9.0.0", "debug": "^4.3.4", "proxy-agent-negotiate": "1.1.0" } }, "sha512-ag87y7cJJ9/3+GxFr8Oy4O5faDsGRGnBGsJj/YjOSsSx/5eadKLYTMPlzuR6obgoCDDm0abAAZitXXQkMOPSpA=="],
+
     "@larksuiteoapi/node-sdk/axios": ["axios@1.13.6", "", { "dependencies": { "follow-redirects": "^1.15.11", "form-data": "^4.0.5", "proxy-from-env": "^1.1.0" } }, "sha512-ChTCHMouEe2kn713WHbQGcuYrr6fXTBiu460OTwWrWob16g1bXn4vtz07Ope7ewMozJAnEquLk5lWQWtBig9DQ=="],
 
     "@opentelemetry/exporter-logs-otlp-grpc/@opentelemetry/core": ["@opentelemetry/core@2.6.1", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-8xHSGWpJP9wBxgBpnqGL0R3PbdWQndL1Qp50qrg71+B28zK5OQmUgcDKLJgzyAAV38t4tOyLMGDD60LneR5W8g=="],
@@ -1427,6 +1437,8 @@
 
     "@inquirer/select/ansi-escapes/type-fest": ["type-fest@0.21.3", "", {}, "sha512-t0rzBq87m3fVcduHDUFhKmyyX+9eo6WQjZvf51Ea/M0Q7+T374Jp1aUiyUl0GKxp8M/OETVHSDvmkyPgvX+X2w=="],
 
+    "@larksuite/channel/https-proxy-agent/agent-base": ["agent-base@9.0.0", "", {}, "sha512-TQf59BsZnytt8GdJKLPfUZ54g/iaUL2OWDSFCCvMOhsHduDQxO8xC4PNeyIkVcA5KwL2phPSv0douC0fgWzmnA=="],
+
     "@larksuiteoapi/node-sdk/axios/proxy-from-env": ["proxy-from-env@1.1.0", "", {}, "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg=="],
 
     "@smithy/eventstream-codec/@aws-crypto/crc32/@aws-crypto/util": ["@aws-crypto/util@3.0.0", "", { "dependencies": { "@aws-sdk/types": "^3.222.0", "@aws-sdk/util-utf8-browser": "^3.0.0", "tslib": "^1.11.1" } }, "sha512-2OJlpeJpCR48CC8r+uKVChzs9Iungj9wkZrl8Z041DWEWvyIHILYKCPNzJghKsivj+S3mLo6BVc7mBNzdxA46w=="],

package.json

@@ -39,6 +39,7 @@
     "@azure/identity": "^4.13.1",
     "@commander-js/extra-typings": "^14.0.0",
     "@growthbook/growthbook": "^1.6.5",
+    "@larksuite/channel": "^0.1.2",
     "@larksuiteoapi/node-sdk": "^1.60.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@opentelemetry/api": "^1.9.1",
@@ -99,6 +100,7 @@
     "plist": "^3.1.0",
     "proper-lockfile": "^4.1.2",
     "qrcode": "^1.5.4",
+    "qrcode-terminal": "^0.12.0",
     "react": "^19.2.4",
     "react-reconciler": "^0.33.0",
     "semver": "^7.7.4",

src/commands/feishu/feishu.tsx

@@ -12,6 +12,7 @@ import {
   maskFeishuAppSecret,
   saveFeishuConfig,
 } from '../../services/feishu/feishuConfig.js'
+import QRCode from 'qrcode'
 
 type Step =
   | { type: 'menu' }
@@ -20,7 +21,11 @@ type Step =
   | { type: 'edit-encrypt-key' }
   | { type: 'edit-verification-token' }
   | { type: 'edit-allowed-users' }
+  | { type: 'edit-admins' }
+  | { type: 'edit-allowed-chats' }
+  | { type: 'edit-mention-policy' }
   | { type: 'confirm-clear' }
+  | { type: 'scanning' }
 
 type Notice = {
   text: string
@@ -177,6 +182,18 @@ function FeishuDialog({
         label: '设置允许访问的用户',
         action: () => setStep({ type: 'edit-allowed-users' }),
       },
+      {
+        label: '设置管理员',
+        action: () => setStep({ type: 'edit-admins' }),
+      },
+      {
+        label: '设置允许响应的群',
+        action: () => setStep({ type: 'edit-allowed-chats' }),
+      },
+      {
+        label: `@提及要求: ${config?.requireMentionInGroup !== false ? '需 @bot' : '所有消息'}`,
+        action: () => setStep({ type: 'edit-mention-policy' }),
+      },
       {
         label:
           serviceState.status === 'running' ? '停止当前飞书 Bot' : '启动当前飞书 Bot',
@@ -207,6 +224,10 @@ function FeishuDialog({
         label: '清空飞书配置',
         action: () => setStep({ type: 'confirm-clear' }),
       },
+      {
+        label: '扫码登录（创建应用）',
+        action: () => setStep({ type: 'scanning' }),
+      },
       {
         label: '关闭',
         action: () => onDone(undefined, { display: 'skip' }),
@@ -353,6 +374,75 @@ function FeishuDialog({
     [refreshConfig],
   )
 
+  const saveAdmins = React.useCallback(
+    async (value: string) => {
+      const users = value.split(/[,\s]+/).map(s => s.trim()).filter(Boolean)
+      setBusy(true)
+      try {
+        const current = getFeishuConfig()
+        saveFeishuConfig({ ...current, admins: users.length > 0 ? users : undefined })
+        refreshConfig()
+        setNotice({ text: '管理员列表已保存。', tone: 'success' })
+      } catch (error) {
+        setNotice({
+          text: error instanceof Error ? error.message : '保存失败',
+          tone: 'error',
+        })
+      } finally {
+        setBusy(false)
+        setStep({ type: 'menu' })
+      }
+    },
+    [refreshConfig],
+  )
+
+  const saveAllowedChats = React.useCallback(
+    async (value: string) => {
+      const chats = value.split(/[,\s]+/).map(s => s.trim()).filter(Boolean)
+      setBusy(true)
+      try {
+        const current = getFeishuConfig()
+        saveFeishuConfig({ ...current, allowedChats: chats.length > 0 ? chats : undefined })
+        refreshConfig()
+        setNotice({ text: '允许响应的群列表已保存。', tone: 'success' })
+      } catch (error) {
+        setNotice({
+          text: error instanceof Error ? error.message : '保存失败',
+          tone: 'error',
+        })
+      } finally {
+        setBusy(false)
+        setStep({ type: 'menu' })
+      }
+    },
+    [refreshConfig],
+  )
+
+  const toggleMentionPolicy = React.useCallback(
+    async () => {
+      setBusy(true)
+      try {
+        const current = getFeishuConfig()
+        const next = current.requireMentionInGroup !== false ? false : true
+        saveFeishuConfig({ ...current, requireMentionInGroup: next })
+        refreshConfig()
+        setNotice({
+          text: next ? '群聊已设为需 @bot 才响应。' : '群聊已设为响应所有消息。',
+          tone: 'success',
+        })
+      } catch (error) {
+        setNotice({
+          text: error instanceof Error ? error.message : '保存失败',
+          tone: 'error',
+        })
+      } finally {
+        setBusy(false)
+        setStep({ type: 'menu' })
+      }
+    },
+    [refreshConfig],
+  )
+
   const clearConfigAndStop = React.useCallback(async () => {
     setBusy(true)
     try {
@@ -372,6 +462,18 @@ function FeishuDialog({
   }, [refreshConfig])
 
   useInput((_, key) => {
+    if (step.type === 'edit-mention-policy') {
+      if (key.escape) {
+        setStep({ type: 'menu' })
+        return
+      }
+      if (key.return) {
+        void toggleMentionPolicy()
+        return
+      }
+      return
+    }
+
     if (step.type !== 'menu' || busy) return
 
     if (key.escape) {
@@ -475,6 +577,55 @@ function FeishuDialog({
     )
   }
 
+  if (step.type === 'edit-admins') {
+    return (
+      <Dialog title="管理员" onCancel={() => setStep({ type: 'menu' })}>
+        <TextInput
+          title="管理员 open_id"
+          hint="管理员拥有全部权限，可执行 /stop、/config 等管理命令。输入 open_id，多个以空格或逗号分隔。"
+          initialValue={config?.admins?.join(', ')}
+          onSubmit={value => { void saveAdmins(value) }}
+          onCancel={() => setStep({ type: 'menu' })}
+        />
+      </Dialog>
+    )
+  }
+
+  if (step.type === 'edit-allowed-chats') {
+    return (
+      <Dialog title="允许响应的群聊" onCancel={() => setStep({ type: 'menu' })}>
+        <TextInput
+          title="群聊 chat_id"
+          hint="输入群聊 chat_id，多个以空格或逗号分隔。仅在白名单中的群聊 bot 才会响应。"
+          initialValue={config?.allowedChats?.join(', ')}
+          onSubmit={value => { void saveAllowedChats(value) }}
+          onCancel={() => setStep({ type: 'menu' })}
+        />
+      </Dialog>
+    )
+  }
+
+  if (step.type === 'edit-mention-policy') {
+    return (
+      <Dialog title="@提及要求" onCancel={() => setStep({ type: 'menu' })}>
+        <Box flexDirection="column" gap={1}>
+          <Text bold>群聊 @bot 要求</Text>
+          <Text dimColor>
+            当前: {config?.requireMentionInGroup !== false ? '需 @bot 才响应' : '响应所有群消息'}
+          </Text>
+          <Text dimColor marginTop={1}>
+            切换后：
+            {'\n'}- 需 @bot: 仅在群聊中被 @ 时才处理消息
+            {'\n'}- 响应所有: 群聊中所有消息都会处理
+          </Text>
+          <Box marginTop={1}>
+            <Text>按 Enter 切换，按 Esc 取消</Text>
+          </Box>
+        </Box>
+      </Dialog>
+    )
+  }
+
   if (step.type === 'confirm-clear') {
     return (
       <Dialog title="清空飞书配置" onCancel={() => setStep({ type: 'menu' })}>
@@ -486,6 +637,13 @@ function FeishuDialog({
     )
   }
 
+  if (step.type === 'scanning') {
+    return <ScanningDialog onCancel={() => setStep({ type: 'menu' })} onSuccess={() => {
+      refreshConfig()
+      setStep({ type: 'menu' })
+    }} />
+  }
+
   return (
     <Dialog title="飞书 (Feishu)" onCancel={() => onDone(undefined, { display: 'skip' })}>
       <Box flexDirection="column" gap={1}>
@@ -518,6 +676,23 @@ function FeishuDialog({
             ? config.allowedUsers.join(', ')
             : '未配置（使用配对码授权）'}
         </Text>
+        <Text>
+          管理员:
+          {' '}
+          {config?.admins?.length
+            ? config.admins.join(', ')
+            : '未配置'}
+        </Text>
+        <Text>
+          允许群聊:
+          {' '}
+          {config?.allowedChats?.length
+            ? `${config.allowedChats.length} 个`
+            : '未配置'}
+        </Text>
+        <Text>
+          群聊 @提及: {config?.requireMentionInGroup !== false ? '需 @bot' : '所有消息'}
+        </Text>
         {config?.pairedUsers?.length ? (
           <Text>
             已配对用户: {config.pairedUsers.map(u => u.displayName || u.userId).join(', ')}
@@ -541,6 +716,161 @@ function FeishuDialog({
   )
 }
 
+function ScanningDialog({
+  onCancel,
+  onSuccess,
+}: {
+  onCancel: () => void
+  onSuccess: () => void
+}) {
+  const [qrUrl, setQrUrl] = React.useState<string | null>(null)
+  const [expireIn, setExpireIn] = React.useState<number>(0)
+  const [status, setStatus] = React.useState<string>('正在连接飞书...')
+  const [error, setError] = React.useState<string | null>(null)
+  const [success, setSuccess] = React.useState(false)
+  const [completed, setCompleted] = React.useState(false)
+
+  // Refs to avoid re-triggering the effect when parent passes inline callbacks
+  const onSuccessRef = React.useRef(onSuccess)
+  onSuccessRef.current = onSuccess
+  const onCancelRef = React.useRef(onCancel)
+  onCancelRef.current = onCancel
+
+  React.useEffect(() => {
+    let cancelled = false
+
+    const run = async () => {
+      try {
+        const { registerApp } = await import('@larksuite/channel')
+
+        const result = await registerApp({
+          source: 'versperclaw',
+          onQRCodeReady: (info) => {
+            if (cancelled) return
+            setQrUrl(info.url)
+            setExpireIn(info.expireIn)
+            setStatus('请用飞书 App 扫描二维码，并在打开的页面中点击"授权"完成创建')
+          },
+          onStatusChange: (info) => {
+            if (cancelled) return
+            if (info.status === 'domain_switched') {
+              setStatus('已切换到国际版 (larksuite.com)，请继续...')
+            } else if (info.status === 'slow_down') {
+              setStatus('等待授权确认中...')
+            } else if (info.status === 'polling') {
+              setStatus('等待授权确认中，请确保已在飞书中点击了"授权"...')
+            }
+          },
+        })
+
+        if (cancelled) return
+
+        // Save credentials
+        saveFeishuConfig({
+          appId: result.client_id,
+          appSecret: result.client_secret,
+          tenant: (result as { user_info?: { tenant_brand?: string } }).user_info?.tenant_brand,
+        })
+
+        setSuccess(true)
+        setStatus('应用创建成功！正在启动 Bot...')
+        setCompleted(true)
+
+        // Start the bot
+        await feishuService.stop()
+        await feishuService.startFromSavedConfig()
+
+        if (!cancelled) {
+          setTimeout(() => onSuccessRef.current(), 1500)
+        }
+      } catch (err) {
+        if (!cancelled) {
+          setError(err instanceof Error ? err.message : '扫码登录失败')
+        }
+      }
+    }
+
+    run()
+
+    return () => {
+      cancelled = true
+    }
+  }, []) // Run once on mount only — refs avoid dep instability
+
+  useInput((_, key) => {
+    if (key.escape && !completed) {
+      onCancelRef.current()
+    }
+  })
+
+  const [qrAscii, setQrAscii] = React.useState<string>('')
+  const [qrError, setQrError] = React.useState<string | null>(null)
+
+  React.useEffect(() => {
+    if (!qrUrl) return
+
+    QRCode.toString(qrUrl, { type: 'terminal', small: true })
+      .then(ascii => {
+        setQrAscii(ascii)
+        setQrError(null)
+      })
+      .catch(err => {
+        console.error('[Feishu] QR generation error:', err)
+        setQrError('无法生成二维码，请使用下方链接')
+      })
+  }, [qrUrl])
+
+  return (
+    <Dialog title="扫码登录飞书" onCancel={completed ? undefined : onCancel}>
+      <Box flexDirection="column" gap={1}>
+        {error ? (
+          <>
+            <Text color="red">错误: {error}</Text>
+            <Text dimColor>按 Esc 返回</Text>
+          </>
+        ) : success ? (
+          <>
+            <Text color="green">✓ {status}</Text>
+          </>
+        ) : qrError ? (
+          <>
+            <Text bold color="yellow">二维码生成失败</Text>
+            <Text dimColor marginTop={1}>请使用下方链接完成授权：</Text>
+            <Box marginTop={1}>
+              <Text selectText>{qrUrl}</Text>
+            </Box>
+            <Text dimColor marginTop={1}>{status}</Text>
+            <Text dimColor marginTop={1}>按 Esc 取消</Text>
+          </>
+        ) : qrAscii ? (
+          <>
+            <Text bold>请用飞书 App 扫描下方二维码</Text>
+            <Text dimColor>扫描后，请在打开的页面中点击【授权】完成应用创建</Text>
+            <Box marginTop={1}>
+              <Text>{qrAscii}</Text>
+            </Box>
+            <Text dimColor marginTop={1}>
+              二维码有效期：约 {Math.max(1, Math.round(expireIn / 60))} 分钟
+            </Text>
+            {qrUrl && (
+              <Text dimColor marginTop={1}>
+                或打开链接：{qrUrl.slice(0, 70)}...
+              </Text>
+            )}
+            <Text color="cyan" marginTop={1}>{status}</Text>
+            <Text dimColor marginTop={1}>按 Esc 取消</Text>
+          </>
+        ) : (
+          <>
+            <Text>{status}</Text>
+            <Text dimColor>请稍候...</Text>
+          </>
+        )}
+      </Box>
+    </Dialog>
+  )
+}
+
 export async function call(
   onDone: LocalJSXCommandOnDone,
   _context: LocalJSXCommandContext,

src/hooks/useFeishuBridge.ts

@@ -1,23 +1,124 @@
 /**
- * useFeishuBridge — auto-starts Feishu service if configured.
+ * useFeishuBridge — Feishu inbound/outbound bridge hook.
+ *
+ * - Auto-starts Feishu service if credentials are saved.
+ * - Tracks AI response turns for Feishu-originated messages.
+ * - Sends generated responses back to the originating Feishu chat.
  */
 
 import { useEffect, useRef } from 'react'
 import { feishuService } from '../services/feishu/FeishuService.js'
 import { getFeishuConfig } from '../services/feishu/feishuConfig.js'
+import { getContentText } from '../utils/messages.js'
+import type { Message } from '../types/message.js'
 
-export function useFeishuBridge(): void {
-  const attempted = useRef(false)
+type Props = {
+  messages: Message[]
+  isLoading: boolean
+}
 
+type ActiveFeishuTurn = {
+  chatId: string
+  responseParts: string[]
+}
+
+const FEISHU_CHANNEL_SERVER = 'feishu'
+
+export function useFeishuBridge({ messages, isLoading }: Props): void {
+  const autoStartAttemptedRef = useRef(false)
+  const pendingInboundRef = useRef<{ chatId: string }[]>([])
+  const activeTurnRef = useRef<ActiveFeishuTurn | null>(null)
+  const lastProcessedMessageCountRef = useRef(messages.length)
+  const previousLoadingRef = useRef(isLoading)
+
+  // Auto-start if configured
   useEffect(() => {
-    if (attempted.current) return
-    attempted.current = true
+    if (autoStartAttemptedRef.current) return
+    autoStartAttemptedRef.current = true
 
     const config = getFeishuConfig()
     if (!config.appId || !config.appSecret) return
 
-    void feishuService.startFromSavedConfig().catch((e) => {
+    void feishuService.startFromSavedConfig().catch(e => {
       console.warn('[feishu] auto-start failed:', e instanceof Error ? e.message : String(e))
     })
   }, [])
-}
+
+  // Subscribe to inbound events (stores chatId for turn tracking)
+  useEffect(() => {
+    return feishuService.subscribeToInbound(event => {
+      pendingInboundRef.current.push({ chatId: event.chatId })
+    })
+  }, [])
+
+  // Process new messages — detect Feishu-originated user messages and collect
+  // assistant responses
+  useEffect(() => {
+    const newMessages = messages.slice(lastProcessedMessageCountRef.current)
+
+    for (const message of newMessages) {
+      if (
+        message.type === 'user' &&
+        typeof message.origin === 'object' &&
+        message.origin !== null &&
+        (message.origin as Record<string, unknown>).kind === 'channel' &&
+        (message.origin as Record<string, unknown>).server === FEISHU_CHANNEL_SERVER
+      ) {
+        const inbound = pendingInboundRef.current.shift()
+        if (inbound) {
+          activeTurnRef.current = {
+            chatId: inbound.chatId,
+            responseParts: [],
+          }
+        }
+        continue
+      }
+
+      if (message.type === 'assistant' && activeTurnRef.current) {
+        const text = getContentText(message.message.content)
+        if (text) {
+          activeTurnRef.current.responseParts.push(text)
+        }
+        continue
+      }
+
+      if (
+        message.type === 'system' &&
+        message.subtype === 'local_command' &&
+        activeTurnRef.current
+      ) {
+        const text = message.content
+        if (text) {
+          activeTurnRef.current.responseParts.push(text)
+        }
+      }
+    }
+
+    lastProcessedMessageCountRef.current = messages.length
+  }, [messages])
+
+  // When loading completes, send accumulated response back to Feishu
+  useEffect(() => {
+    const wasLoading = previousLoadingRef.current
+    previousLoadingRef.current = isLoading
+
+    if (!wasLoading || isLoading || !activeTurnRef.current) return
+
+    const completedTurn = activeTurnRef.current
+    activeTurnRef.current = null
+
+    void (async () => {
+      try {
+        const reply =
+          completedTurn.responseParts.join('\n\n').trim() ||
+          '这一轮没有可回传的文本结果，请查看本地终端会话。'
+        await feishuService.sendText(completedTurn.chatId, reply)
+      } catch (error) {
+        console.warn(
+          '[feishu] failed to send outbound reply:',
+          error instanceof Error ? error.message : String(error),
+        )
+      }
+    })()
+  }, [isLoading])
+}

src/screens/REPL.tsx

@@ -111,6 +111,7 @@ import {
 } from '../utils/swarm/leaderPermissionBridge.js'
 import { endInteractionSpan } from '../utils/telemetry/sessionTracing.js'
 import { useLogMessages } from '../hooks/useLogMessages.js'
+import { useFeishuBridge } from '../hooks/useFeishuBridge.js'
 import { useReplBridge } from '../hooks/useReplBridge.js'
 import {
   type Command,
@@ -5396,6 +5397,8 @@ export function REPL({
 
   useMailboxBridge({ isLoading, onSubmitMessage: handleIncomingPrompt })
 
+  useFeishuBridge({ messages, isLoading })
+
   // Scheduled tasks from .claude/scheduled_tasks.json (CronCreate/Delete/List)
   if (feature('AGENT_TRIGGERS')) {
     // Assistant mode bypasses the isLoading gate (the proactive tick →

src/services/feishu/FeishuService.ts

@@ -1,102 +1,427 @@
 /**
- * FeishuService — in-process Feishu bot using @larksuiteoapi/node-sdk
- *
- * Uses Lark.WSClient to receive events, enqueues messages to REPL,
- * collects responses via polling AppState, sends back to Feishu.
+ * FeishuService — in-process Feishu bot using @larksuite/channel
+ * Refactored to use vendor modules from lark-coding-agent-bridge.
  */
 
-import * as Lark from '@larksuiteoapi/node-sdk'
-import { getFeishuConfig, type FeishuRuntimeConfig } from './feishuConfig.js'
-import { logForDebugging } from '../../utils/debug.js'
+import {
+  createLarkChannel,
+  type LarkChannel,
+  type NormalizedMessage,
+  registerApp,
+} from '@larksuite/channel'
+import {
+  getFeishuConfig,
+  saveFeishuConfig,
+  type FeishuRuntimeConfig,
+} from './feishuConfig.js'
+
+// Vendor modules (from lark-coding-agent-bridge)
+import { log } from './vendor/core/logger.js'
+import { PendingQueue } from './vendor/bot/pending-queue.js'
+import { startKeepalive } from './vendor/bot/keepalive.js'
+
+import { ChatModeCache } from './vendor/bot/chat-mode-cache.js'
+import { createOwnerRefreshController } from './vendor/policy/owner.js'
+import { fetchQuotedContext, renderQuotedBlock } from './vendor/bot/quote.js'
+
+// ──────────────────────────────────────────────
+// Minimal RuntimeControls interface (matches vendor/policy/access.ts)
+// ──────────────────────────────────────────────
+
+interface RuntimeControls {
+  botOwnerId?: string
+  ownerRefreshState: 'ok' | 'failed' | 'unknown'
+  ownerRefreshedAt?: number
+  ownerRefreshError?: string
+}
+
+// ──────────────────────────────────────────────
+// Types
+// ──────────────────────────────────────────────
 
 type FeishuServiceState = {
   status: 'stopped' | 'starting' | 'running' | 'error'
   appId?: string
+  botName?: string
+  ownerId?: string
   lastError?: string
 }
 
 type Listener = () => void
 
-function normalizeError(error: unknown): string {
-  if (error instanceof Error) return error.message
-  return String(error)
+/** Inbound event for bridge hook consumption */
+type FeishuInboundEvent = {
+  chatId: string
+  text: string
+  senderId: string
+}
+
+type InboundListener = (event: FeishuInboundEvent) => void
+
+type AccessDecision = {
+  ok: boolean
+  reason: string
+}
+
+// Minimal RuntimeControls implementation for owner refresh
+class FeishuRuntimeControls implements RuntimeControls {
+  botOwnerId?: string
+  ownerRefreshState: 'ok' | 'failed' | 'unknown' = 'unknown'
+  ownerRefreshedAt?: number
+  ownerRefreshError?: string
+}
+
+// ──────────────────────────────────────────────
+// Access control helpers
+// ──────────────────────────────────────────────
+
+function isOwner(controls: FeishuRuntimeControls, senderId: string): boolean {
+  if (controls.ownerRefreshState === 'unknown') return false
+  return Boolean(controls.botOwnerId) && controls.botOwnerId === senderId
+}
+
+function canUseDm(
+  config: FeishuRuntimeConfig,
+  controls: FeishuRuntimeControls,
+  senderId: string,
+): AccessDecision {
+  if (isOwner(controls, senderId)) return { ok: true, reason: 'owner' }
+  if (config.admins?.includes(senderId)) return { ok: true, reason: 'admin' }
+  if (!config.allowedUsers || config.allowedUsers.length === 0) {
+    return { ok: true, reason: 'open-dm' }
+  }
+  if (config.allowedUsers.includes(senderId)) return { ok: true, reason: 'allowed-user' }
+  return { ok: false, reason: 'denied-user' }
+}
+
+function canUseGroup(
+  config: FeishuRuntimeConfig,
+  controls: FeishuRuntimeControls,
+  chatId: string,
+  senderId: string,
+): AccessDecision {
+  if (isOwner(controls, senderId)) return { ok: true, reason: 'owner' }
+  if (config.admins?.includes(senderId)) return { ok: true, reason: 'admin' }
+  if (config.allowedChats?.includes(chatId)) return { ok: true, reason: 'allowed-chat' }
+  return { ok: false, reason: 'denied-chat' }
+}
+
+function canRunAdminCommand(
+  config: FeishuRuntimeConfig,
+  controls: FeishuRuntimeControls,
+  senderId: string,
+): AccessDecision {
+  if (isOwner(controls, senderId)) return { ok: true, reason: 'owner' }
+  if (config.admins?.includes(senderId)) return { ok: true, reason: 'admin' }
+  return { ok: false, reason: 'denied-admin' }
 }
 
+// ──────────────────────────────────────────────
+// Slash command handler type
+// ──────────────────────────────────────────────
+
+type CommandHandler = (
+  args: string,
+  chatId: string,
+  senderId: string,
+  channel: LarkChannel,
+) => Promise<boolean>
+
+// ──────────────────────────────────────────────
+// Main service
+// ──────────────────────────────────────────────
+
 class FeishuService {
   private listeners = new Set<Listener>()
+  private inboundListeners = new Set<InboundListener>()
   private state: FeishuServiceState = { status: 'stopped' }
   private config?: FeishuRuntimeConfig
-  private client?: Lark.Client
-  private wsClient?: { stop?: () => void }
+  private channel?: LarkChannel
+  private pending?: PendingQueue
+  private keepalive?: { stop(): void }
+  private ownerRefresh?: { start(): Promise<void>; stop(): void }
+  private chatModeCache?: ChatModeCache
+  private controls = new FeishuRuntimeControls()
   private runId = 0
+  private commandHandlers = new Map<string, CommandHandler>()
+
+  constructor() {
+    this.registerDefaultCommands()
+  }
+
+  // ── Default slash commands ──────────────────
+
+  private registerDefaultCommands(): void {
+    this.commandHandlers.set('/stop', async (_args, chatId, _senderId, channel) => {
+      await channel.send(chatId, { text: '⏹ 停止命令已收到。' })
+      return true
+    })
+
+    this.commandHandlers.set('/reset', async (_args, chatId, _senderId, channel) => {
+      await channel.send(chatId, { text: '🔄 已重置会话。' })
+      return true
+    })
+
+    this.commandHandlers.set(
+      '/status',
+      async (_args, chatId, _senderId, channel) => {
+        const cfg = this.config
+        const lines = [
+          `状态: ${this.state.status}`,
+          `App ID: ${cfg?.appId ?? '未配置'}`,
+          `Bot: ${this.state.botName ?? '未知'}`,
+          `Owner: ${this.controls.botOwnerId ?? '未知'}`,
+          `DM 策略: ${
+            !cfg?.allowedUsers || cfg.allowedUsers.length === 0
+              ? '所有人'
+              : '白名单'
+          }`,
+          `群聊策略: ${
+            cfg?.requireMentionInGroup !== false ? '需 @bot' : '所有消息'
+          }`,
+          `配置群白名单: ${cfg?.allowedChats?.length ?? 0} 个`,
+        ]
+        await channel.send(chatId, { text: lines.join('\n') })
+        return true
+      },
+    )
+
+    this.commandHandlers.set('/help', async (_args, chatId, _senderId, channel) => {
+      const help = [
+        '飞书 Bot 命令:',
+        '/stop — 中断当前任务',
+        '/reset — 重置会话',
+        '/status — 查看状态',
+        '/help — 显示此帮助',
+      ]
+      await channel.send(chatId, { text: help.join('\n') })
+      return true
+    })
+  }
+
+  // ── React sync external store interface ─────
 
   subscribe = (listener: Listener): (() => void) => {
     this.listeners.add(listener)
     return () => this.listeners.delete(listener)
   }
 
+  subscribeToInbound = (listener: InboundListener): (() => void) => {
+    this.inboundListeners.add(listener)
+    return () => this.inboundListeners.delete(listener)
+  }
+
   getStateSnapshot = (): FeishuServiceState => this.state
 
+  // ── Lifecycle ───────────────────────────────
+
   async start(config: FeishuRuntimeConfig): Promise<void> {
-    if (this.state.status === 'running' &&
-        this.config?.appId === config.appId &&
-        this.config?.appSecret === config.appSecret) {
+    if (
+      this.state.status === 'running' &&
+      this.config?.appId === config.appId
+    ) {
       return
     }
 
     await this.stop()
     const runId = ++this.runId
     this.config = config
-    this.client = new Lark.Client({
+
+    this.setState({
+      status: 'starting',
       appId: config.appId,
-      appSecret: config.appSecret,
-      appType: Lark.AppType.SelfBuild,
-      domain: Lark.Domain.Feishu,
+      lastError: undefined,
     })
 
-    this.setState({ status: 'starting', appId: config.appId, lastError: undefined })
-
     try {
-      // Verify credentials
-      await this.client.request({
-        method: 'GET',
-        url: '/open-apis/bot/v3/info',
+      const domain =
+        config.tenant === 'lark'
+          ? 'https://open.larksuite.com'
+          : 'https://open.feishu.cn'
+
+      const channel = createLarkChannel({
+        appId: config.appId!,
+        appSecret: config.appSecret!,
+        domain,
+        source: 'versperclaw',
+        // Use default logger level (info)
+        respectProxyEnv: true,
+        wsConfig: { pingTimeout: 3 },
+        handshakeTimeoutMs: 8000,
+        httpTimeoutMs: 30000,
+        policy: {
+          dmMode: 'open',
+          requireMention: false,
+          respondToMentionAll: false,
+        },
+        safety: { chatQueue: { enabled: false } },
+        includeRawEvent: true,
       })
-      if (runId !== this.runId) return
 
-      logForDebugging('[feishu] connected successfully')
+      const chatModeCache = new ChatModeCache()
+      const cfg = config // local ref for closure
+
+      // Pending queue with block/unblock support
+      const pending = new PendingQueue(600, async (scope, batch) => {
+        const first = batch[0]
+        if (!first) return
+
+        const chatId = first.chatId
+        const senderId = first.senderId
+        const text = batch.map(m => m.content).join('\n---\n')
+
+        log.info('flush', 'start', { scope, batchSize: batch.length })
+
+        try {
+          const mode = await chatModeCache.resolve(channel, chatId)
+          const isGroup = mode !== 'p2p'
 
-      const dispatcher = new Lark.EventDispatcher({
-        encryptKey: config.encryptKey,
-        verificationToken: config.verificationToken,
+          // Access check
+          if (isGroup) {
+            const access = canUseGroup(cfg, this.controls, chatId, senderId)
+            if (!access.ok) {
+              if (first.mentionedBot) {
+                await channel.send(chatId, {
+                  text: '当前群未加入响应列表。请联系 Bot owner 或管理员使用 /invite group 加入白名单。',
+                })
+              }
+              log.info('intake', 'denied-group', {
+                chatId,
+                senderId,
+                reason: access.reason,
+              })
+              return
+            }
+            // @mention policy — default requires mention in groups
+            if (cfg.requireMentionInGroup !== false && !first.mentionedBot) {
+              log.info('intake', 'skip-no-mention', { chatId })
+              return
+            }
+          } else {
+            const access = canUseDm(cfg, this.controls, senderId)
+            if (!access.ok) {
+              log.info('intake', 'denied-dm', {
+                chatId,
+                senderId,
+                reason: access.reason,
+              })
+              return
+            }
+          }
+
+          // Slash command routing
+          if (text.startsWith('/')) {
+            const parts = text.split(/\s+/)
+            const cmdName = parts[0] ?? ''
+            const args = parts.slice(1).join(' ')
+            const handler = this.commandHandlers.get(cmdName)
+            if (handler) {
+              await handler(args, chatId, senderId, channel)
+              return // handled locally
+            }
+            // Unknown command — let it pass through to the agent
+          }
+
+          // Build prompt with optional quoted context
+          let fullText = text
+          const replyToId = first.replyToMessageId
+          if (replyToId) {
+            const quote = await fetchQuotedContext(channel, replyToId)
+            if (quote) {
+              const quotedBlock = renderQuotedBlock([quote])
+              if (quotedBlock) {
+                fullText = `${quotedBlock}\n\n${text}`
+              }
+            }
+          }
+
+          // Notify inbound listeners (bridge hook uses this for chatId tracking)
+          for (const listener of this.inboundListeners) {
+            listener({ chatId, text: fullText, senderId })
+          }
+
+          // Enqueue to REPL
+          const { enqueue } = await import(
+            '../../utils/messageQueueManager.js'
+          )
+          enqueue({
+            value: fullText,
+            mode: 'prompt',
+            skipSlashCommands: true,
+            bridgeOrigin: true,
+            origin: { kind: 'channel', server: 'feishu' },
+          })
+        } finally {
+          log.info('flush', 'end')
+        }
       })
 
-      dispatcher.register({
-        'im.message.receive_v1': async (data: any) => {
+      channel.on({
+        message: async (msg: NormalizedMessage) => {
           if (runId !== this.runId) return
           try {
-            await this.handleInbound(data)
+            pending.push(msg.chatId, msg)
           } catch (err) {
-            logForDebugging(`[feishu] inbound error: ${normalizeError(err)}`)
+            log.fail('intake', err, {
+              chatId: msg.chatId,
+              msgId: msg.messageId,
+            })
           }
         },
-      } as any)
-
-      // @ts-ignore - WSClient instance type varies
-      this.wsClient = new Lark.WSClient({
-        appId: config.appId,
-        appSecret: config.appSecret,
-        domain: Lark.Domain.Feishu,
-        loggerLevel: Lark.LoggerLevel.warn,
+        error: (err: unknown) => {
+          log.warn('ws', 'error', { err: String(err) })
+        },
+        reconnecting: () => {
+          log.warn('ws', 'reconnecting')
+        },
+        reconnected: () => {
+          log.info('ws', 'reconnected')
+        },
       })
 
-      await this.wsClient.start?.({ eventDispatcher: dispatcher })
+      await channel.connect()
       if (runId !== this.runId) return
 
-      this.setState({ status: 'running', appId: config.appId })
+      this.channel = channel
+      this.pending = pending
+      this.chatModeCache = chatModeCache
+
+      // Keepalive �� defense-in-depth against silent WS issues
+      this.keepalive = startKeepalive({
+        channel,
+        domain,
+        forceReconnect: async () => {
+          log.info('keepalive', 'reconnect-requested')
+          await channel.disconnect()
+          await channel.connect()
+        },
+      })
+
+      // Owner refresh — periodically fetches app owner from Feishu API
+      this.ownerRefresh = createOwnerRefreshController({
+        controls: this.controls,
+        source: channel,
+        appId: config.appId ?? '(unknown)',
+      })
+      await this.ownerRefresh.start()
+
+      const botName = channel.botIdentity?.name ?? config.appId
+      log.info('ws', 'connected', {
+        bot: botName,
+        openId: channel.botIdentity?.openId,
+        appId: config.appId,
+      })
+      this.setState({
+        status: 'running',
+        appId: config.appId,
+        botName,
+        ownerId: this.controls.botOwnerId,
+      })
     } catch (err) {
       if (runId !== this.runId) return
-      this.setState({ status: 'error', appId: config.appId, lastError: normalizeError(err) })
+      const msg = err instanceof Error ? err.message : String(err)
+      log.fail('start', err, { appId: config.appId })
+      this.setState({ status: 'error', appId: config.appId, lastError: msg })
       throw err
     }
   }
@@ -109,86 +434,81 @@ class FeishuService {
     await this.start(config)
   }
 
+  async runRegistrationWizard(): Promise<{ appId: string; appSecret: string }> {
+    const result = await registerApp({
+      source: 'versperclaw',
+      onQRCodeReady: info => {
+        log.info('wizard', 'qr-ready', {
+          url: info.url,
+          expireIn: info.expireIn,
+        })
+      },
+      onStatusChange: info => {
+        log.info('wizard', 'status', { status: info.status })
+      },
+    })
+
+    log.info('wizard', 'complete', { appId: result.client_id })
+
+    saveFeishuConfig({
+      appId: result.client_id,
+      appSecret: result.client_secret,
+    })
+
+    return {
+      appId: result.client_id,
+      appSecret: result.client_secret,
+    }
+  }
+
   async stop(): Promise<void> {
     this.runId++
-    try { this.wsClient?.stop?.() } catch {}
-    this.wsClient = undefined
-    this.client = undefined
+    if (this.ownerRefresh) {
+      this.ownerRefresh.stop()
+      this.ownerRefresh = undefined
+    }
+    if (this.keepalive) {
+      this.keepalive.stop()
+      this.keepalive = undefined
+    }
+    if (this.pending) {
+      this.pending.cancelAll()
+      this.pending = undefined
+    }
+    if (this.channel) {
+      try {
+        await this.channel.disconnect()
+      } catch {}
+      this.channel = undefined
+    }
+    this.chatModeCache = undefined
     this.config = undefined
+    this.controls = new FeishuRuntimeControls()
     if (this.state.status !== 'stopped') {
-      this.setState({ ...this.state, status: 'stopped' })
+      this.setState({ status: 'stopped' })
     }
   }
 
   async sendText(chatId: string, text: string): Promise<void> {
-    if (!this.client) return
-    const MAX = 4000
-    for (let i = 0; i < text.length; i += MAX) {
-      const chunk = text.slice(i, i + MAX)
-      await this.client.im.message.create({
-        data: {
-          receive_id: chatId,
-          receive_id_type: 'open_id',
-          msg_type: 'text',
-          content: JSON.stringify({ text: chunk }),
-        },
-      }).catch((e) => logForDebugging(`[feishu] send error: ${e}`))
+    if (!this.channel) return
+    try {
+      await this.channel.send(chatId, { text })
+    } catch (err) {
+      log.fail('send', err, { chatId, textLen: text.length })
     }
   }
 
-  /** Called from useFeishuBridge with REPL message state */
-  onMessagesChange(messages: any[], isLoading: boolean): void {
-    // Currently a no-op — responses are handled by the bridge pattern
-    // where messages go through enqueue → REPL → AppState → back to Feishu
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  onMessagesChange(_messages: unknown[], _isLoading: boolean): void {
+    // No-op
   }
 
-  private async handleInbound(data: any): Promise<void> {
-    // Debug: log what we receive
-    console.log('[feishu] raw inbound:', JSON.stringify(data).slice(0, 500))
-
-    const event = data.event as any
-    const sender = event?.sender as any
-    const message = event?.message as any
-    console.log('[feishu] event:', JSON.stringify(event)?.slice(0,200))
-    console.log('[feishu] sender:', JSON.stringify(sender)?.slice(0,200))
-    console.log('[feishu] message:', JSON.stringify(message)?.slice(0,200))
-
-    const chatId = sender?.sender_id?.open_id
-    const userId = sender?.sender_id?.open_id
-    let text = ''
-    try {
-      if (message.content) {
-        text = JSON.parse(message.content).text?.trim() ?? ''
-      }
-    } catch {}
-
-    if (!text || !chatId || !userId) return
-
-    // Check allowed users
-    if (this.config?.allowedUsers?.length && !this.config.allowedUsers.includes(userId)) {
-      await this.sendText(chatId, '你没有权限���用此飞书机器人。')
-      return
-    }
-
-    logForDebugging(`[feishu] inbound: ${text.slice(0, 50)}`)
-    console.log('[feishu] enqueueing:', text.slice(0, 50))
-
-    // Enqueue to REPL — will be picked up by the command queue
-    const { enqueue } = await import('../../utils/messageQueueManager.js')
-    enqueue({
-      value: text,
-      mode: 'prompt',
-      skipSlashCommands: true,
-      bridgeOrigin: true,
-      origin: { kind: 'channel', server: 'feishu' },
-    })
-    console.log('[feishu] enqueued, queue length now:', (await import('../../utils/messageQueueManager.js')).getCommandQueueSnapshot().length)
-  }
+  // ── Internal ────────────────────────────────
 
-  private setState(next: FeishuServiceState): void {
+  private setState(next: Partial<FeishuServiceState>): void {
     this.state = { ...this.state, ...next }
     for (const listener of this.listeners) listener()
   }
 }
 
-export const feishuService = new FeishuService()
+export const feishuService = new FeishuService()

src/services/feishu/feishuConfig.ts

@@ -12,13 +12,32 @@ export type PairedUser = {
   pairedAt: number
 }
 
+export type AuthorizedUser = {
+  userId: string
+  displayName: string
+  authorizedAt: number
+}
+
 export type FeishuRuntimeConfig = {
   appId?: string
   appSecret?: string
+  /** 'feishu' | 'lark' — saved from registerApp result.user_info?.tenant_brand */
+  tenant?: string
   encryptKey?: string
   verificationToken?: string
+  /** DM 白名单用户 open_id 列表（空 = 所有人可私聊） */
   allowedUsers?: string[]
+  /** 管理员 open_id 列表 */
+  admins?: string[]
+  /** 允许响应的群聊 chat_id 列表（空 = 所有群都不响应） */
+  allowedChats?: string[]
+  /** 群聊中是否要求 @bot 才响应（默认 true） */
+  requireMentionInGroup?: boolean
+  /** 已配对的用户 */
   pairedUsers?: PairedUser[]
+  /** 已授权的用户 */
+  authorizedUsers?: AuthorizedUser[]
+  /** 是否使用卡片回复模式 */
   streamingCard?: boolean
 }