@modesto_ma/dsh-channels 0.5.0-beta.5 → 0.5.0-beta.7

package/src/routing/inbound.ts

@@ -47,7 +47,13 @@ import { ensureWorkspace, stagingPathFor, topicTokenFor } from '../workspaces.ts
 
 /** The command plane the inbound router delegates admission-time work to. */
 export interface CommandPlanePort {
-  /** Slash-command admission + dispatch. */
+  /**
+   * Whether a `/`-prefixed line names a channel command (including aliases).
+   * Other slash lines are ordinary prompts, so DSH can expand user-invocable
+   * skills such as `/guanxiang`.
+   */
+  owns(line: string): boolean
+  /** Slash-command admission + dispatch for a line {@link owns} accepted. */
   handleSlash(msg: NormalizedMessage, line: string): Promise<void>
 }
 
@@ -386,10 +392,12 @@ export class InboundRouter {
       this.ctx.logger?.warn?.('dsh-channels: recording processed message %s failed: %s', msg.messageId, String(error))
     }
 
-    // Slash admission stays behind message-id dedup but ahead of every route,
-    // mention, workspace, Session, card-stream, and model side effect. The
-    // command plane applies its own administrator/bootstrap rules.
-    if (content.startsWith('/')) {
+    // Channel-command admission stays behind message-id dedup but ahead of
+    // every route, mention, workspace, Session, card-stream, and model side
+    // effect. The command plane applies its own administrator/bootstrap rules.
+    // A slash line that names no channel command continues as an ordinary
+    // prompt through the channel-plane admission below.
+    if (content.startsWith('/') && this.deps.commands.owns(content)) {
       await this.deps.commands.handleSlash(msg, content)
       return
     }

package/src/service.ts

@@ -53,7 +53,7 @@ import { FEISHU_USER_ID_PATTERN, feishuDomain, sessionDirOf } from './domain.ts'
 import type {
   AccessGroupRecord, AccessRequestRecord, AccessUserRecord,
   AnalyzeRequestRecord, ExpiredRouteRecord, FeishuDomainGlobal, FeishuDomainHandle, InflightSnapshot,
-  ProcessedRecord, RawDomainHandle, RouteRecord,
+  ProcessedRecord, RawDomainHandle, RouteRecord, SessionOriginRecord,
 } from './domain.ts'
 import { RouteStore } from './session/routes.ts'
 import { AnalyzeLauncher } from './analyze/launcher.ts'
@@ -97,7 +97,9 @@ import { ACTIVITY_BUILD_MARKER, TurnStreamer } from './streamer.ts'
 import type { ProjectedStats, StreamerHooks } from './streamer.ts'
 import type { FeishuConfig } from './config.ts'
 import type {
-  AccessMutationResponse, AccessRequestWire, AccessUserWire, AccessWire, CredentialField, ScopeCheckWire, SlashCommandSyncWire,
+  AccessMutationResponse, AccessRequestWire, AccessUserWire, AccessWire, CredentialField, FeishuProfilesWire, FeishuProfileWire,
+  ScopeCheckWire, SessionOriginWire,
+  SlashCommandSyncWire,
 } from './settings/contract.ts'
 import { checkScopes } from './feishu/scopes.ts'
 import { desiredSlashCommands, syncSlashCommands } from './feishu/slash-commands.ts'
@@ -141,6 +143,21 @@ interface ModelAdmission {
   controller: RequestPolicyController
 }
 
+/**
+ * How long one resolved user or chat profile is reused. Short enough that
+ * every page entry shows current Feishu data; long enough that the session
+ * header and its sidebar tab opening together cost one lookup.
+ */
+const PROFILE_TTL_MS = 30 * 1000
+
+/** The Feishu `code=<n> <msg>` of a failed API call, else the error text. */
+function feishuReason(error: unknown): string {
+  return error instanceof FeishuApiError ? error.detail : messageOf(error)
+}
+
+/** Feishu `chat_id`s the profile lookup accepts. */
+const FEISHU_CHAT_ID_PATTERN = /^oc_[A-Za-z0-9_-]+$/u
+
 /** Wrap the host's storage facility open behind a stable local type. */
 async function openFeishuDomain(ctx: HostContext): Promise<FeishuDomainHandle> {
   const domain = await ctx.storageDomain.open(feishuDomain) as unknown as RawDomainHandle
@@ -153,6 +170,7 @@ async function openFeishuDomain(ctx: HostContext): Promise<FeishuDomainHandle> {
   const accessRequestsRaw = domain.table('access_requests')
   const accessWikiUsersRaw = domain.table('access_wiki_users')
   const analyzeRequestsRaw = domain.table('analyze_requests')
+  const sessionOriginsRaw = domain.table('session_origins')
   return {
     routes: {
       get: key => table.get(key) as RouteRecord | undefined,
@@ -207,6 +225,10 @@ async function openFeishuDomain(ctx: HostContext): Promise<FeishuDomainHandle> {
       put: (key, value) => analyzeRequestsRaw.put(key, value),
       entries: () => analyzeRequestsRaw.entries() as IterableIterator<[string, AnalyzeRequestRecord]>,
     },
+    sessionOrigins: {
+      get: key => sessionOriginsRaw.get(key) as SessionOriginRecord | undefined,
+      put: (key, value) => sessionOriginsRaw.put(key, value),
+    },
     getGlobal: () => (domain.global.get() ?? {}) as FeishuDomainGlobal,
     setGlobal: value => domain.global.set(value),
     close: () => domain.close(),
@@ -361,6 +383,8 @@ export class FeishuService {
    * is unset. Cleared on shutdown so a reconnect looks it up again.
    */
   private appOwner: AppOwnerState | undefined
+  /** Live-resolved user and chat profiles, by `user:`/`chat:` key; misses are kept as `{}`. */
+  private readonly profileCache = new Map<string, { profile: FeishuProfileWire; at: number }>()
   /** Post-connect scope self-check; cleared on shutdown. */
   private scopeCheckState: ScopeCheckWire | undefined
   /** Post-connect slash-command panel sync; cleared on shutdown. */
@@ -564,7 +588,13 @@ export class FeishuService {
       streamer: () => this.streamer,
       questionAnswerer: () => this.questionAnswerer,
       approvalAnswerer: () => this.approvalAnswerer,
-      commands: { handleSlash: (msg, line) => this.handleSlashMessage(msg, line) },
+      commands: {
+        owns: (line) => {
+          const parsed = parseSlashCommand(line)
+          return parsed !== undefined && commandSpec(parsed.name) !== undefined
+        },
+        handleSlash: (msg, line) => this.handleSlashMessage(msg, line),
+      },
     })
     this.analyzeLauncher = new AnalyzeLauncher({
       ctx: this.ctx,
@@ -1103,6 +1133,119 @@ export class FeishuService {
     }
   }
 
+  /** Panel: Feishu origin of one Session, or null when Feishu never routed it. */
+  async sessionOrigin(sessionId: string): Promise<SessionOriginWire | null> {
+    const origin = this.routes.origin(sessionId)
+    if (origin === undefined) return null
+    const route = this.routes.findBySession(sessionId)
+    const bound = route !== undefined
+    const group = origin.chatType === 'group'
+    const profiles = await this.feishuProfiles([origin.senderUserId], group ? [origin.chatId] : [])
+    const chat = profiles.chats[origin.chatId] ?? {}
+    const sender = profiles.users[origin.senderUserId] ?? {}
+    const senderName = sender.name ?? (group ? await this.memberName(origin.senderUserId, origin.chatId) : undefined)
+    return {
+      sessionId,
+      chatType: origin.chatType,
+      kind: origin.kind,
+      chatId: origin.chatId,
+      ...(chat.name === undefined ? {} : { chatName: chat.name }),
+      ...(chat.avatarUrl === undefined ? {} : { chatAvatarUrl: chat.avatarUrl }),
+      senderUserId: origin.senderUserId,
+      ...(senderName === undefined ? {} : { senderName }),
+      ...(sender.avatarUrl === undefined ? {} : { senderAvatarUrl: sender.avatarUrl }),
+      shared: origin.shared === true,
+      createdAt: origin.createdAt,
+      bound,
+      ...(bound ? { lastActivityAt: route.lastActivityAt } : {}),
+      chatLink: `https://applink.feishu.cn/client/chat/open?openChatId=${encodeURIComponent(origin.chatId)}`,
+    }
+  }
+
+  /**
+   * Live Feishu names and avatars for the panel and the session-origin view,
+   * through a {@link PROFILE_TTL_MS} cache. Ids that are not Feishu
+   * `user_id`s / `chat_id`s are skipped; a disconnected channel and failed
+   * lookups leave ids absent, and failures are reported in `warning` and not
+   * cached.
+   * @param userIds - user `user_id`s to resolve.
+   * @param chatIds - chat `chat_id`s to resolve.
+   * @returns the resolved profiles by id.
+   */
+  async feishuProfiles(userIds: readonly string[], chatIds: readonly string[]): Promise<FeishuProfilesWire> {
+    const result: FeishuProfilesWire = { users: {}, chats: {} }
+    const warnings: string[] = []
+    const now = Date.now()
+    for (const [key, cached] of this.profileCache) {
+      if (now - cached.at >= PROFILE_TTL_MS) this.profileCache.delete(key)
+    }
+    const fresh = (key: string): FeishuProfileWire | undefined => this.profileCache.get(key)?.profile
+    const keep = (target: Record<string, FeishuProfileWire>, id: string, profile: FeishuProfileWire): void => {
+      if (profile.name !== undefined || profile.avatarUrl !== undefined) target[id] = profile
+    }
+    const users = [...new Set(userIds)].filter(id => FEISHU_USER_ID_PATTERN.test(id))
+    const chats = [...new Set(chatIds)].filter(id => FEISHU_CHAT_ID_PATTERN.test(id))
+    const missingUsers: string[] = []
+    for (const id of users) {
+      const cached = fresh(`user:${id}`)
+      if (cached === undefined) missingUsers.push(id)
+      else keep(result.users, id, cached)
+    }
+    const missingChats: string[] = []
+    for (const id of chats) {
+      const cached = fresh(`chat:${id}`)
+      if (cached === undefined) missingChats.push(id)
+      else keep(result.chats, id, cached)
+    }
+    const channel = this.channel
+    if (channel === undefined) return result
+    const lookups: Array<Promise<void>> = []
+    if (missingUsers.length > 0 && channel.userProfiles !== undefined) {
+      lookups.push(channel.userProfiles(missingUsers).then(
+        (found) => {
+          for (const id of missingUsers) {
+            const profile = found.get(id) ?? {}
+            this.profileCache.set(`user:${id}`, { profile, at: now })
+            keep(result.users, id, profile)
+          }
+        },
+        (error: unknown) => { warnings.push(`读取用户资料失败：${feishuReason(error)}`) },
+      ))
+    }
+    const chatProfile = channel.chatProfile?.bind(channel)
+    if (chatProfile !== undefined) {
+      let chatError: string | undefined
+      for (const id of missingChats) {
+        lookups.push(chatProfile(id).then(
+          (profile) => {
+            this.profileCache.set(`chat:${id}`, { profile, at: now })
+            keep(result.chats, id, profile)
+          },
+          (error: unknown) => {
+            if (chatError !== undefined) return
+            chatError = `读取群信息失败：${feishuReason(error)}`
+            warnings.push(chatError)
+          },
+        ))
+      }
+    }
+    await Promise.all(lookups)
+    if (warnings.length > 0) {
+      result.warning = warnings.join('；')
+      this.ctx.logger?.debug?.('dsh-channels: Feishu profile lookup: %s', result.warning)
+    }
+    return result
+  }
+
+  /** Chat-member-list name for a user the contact profile cannot name. */
+  private async memberName(userId: string, chatId: string): Promise<string | undefined> {
+    const cached = this.profileCache.get(`member:${chatId}:${userId}`)
+    if (cached !== undefined && Date.now() - cached.at < PROFILE_TTL_MS) return cached.profile.name
+    const name = await this.channel?.memberName?.(userId, chatId)
+    this.profileCache.set(`member:${chatId}:${userId}`, { profile: name === undefined ? {} : { name }, at: Date.now() })
+    return name
+  }
+
   /** Panel: decide one pending authorization request (same path as the card). */
   async resolveAccessRequest(token: string, decision: 'allow' | 'deny'): Promise<AccessMutationResponse> {
     const requests = this.accessRequests
@@ -1779,6 +1922,7 @@ export class FeishuService {
         await this.delivery.standaloneReply(msg, standaloneInfoCard('**🔐 访问授权状态**', [
           `**准入模式**：\`${this.config.accessMode}\``,
           `**管理员**：${this.adminStatusLine()}`,
+          `**私聊**：${this.config.dmAllowWhitelist ? '管理员与白名单用户' : '仅管理员'}`,
           ...(msg.chatType === 'group'
             ? [`**本群**：${this.accessStore.hasGroup(msg.chatId) ? '已授权' : '未授权'}（\`${msg.chatId}\`）`]
             : []),

package/src/session/routes.ts

@@ -2,15 +2,16 @@
  * Durable route store: thread/chat keys → bound DSH session records.
  *
  * Owns the hot cache over the `channels_routes` domain tables, the TTL
- * retirement that leaves a persistent tombstone, and session → route lookup.
+ * retirement that leaves a persistent tombstone, session → route lookup, and
+ * the durable session → Feishu origin records every route write feeds.
  * The domain handle is late-bound (`domain()`), because the service opens it
  * during `start()` while the store is constructed earlier.
  *
  * @module dsh-channels/session/routes
  */
 
-import type { ExpiredRouteRecord, FeishuDomainHandle, RouteRecord } from '../domain.ts'
-import { normalizeRouteRecord } from '../domain.ts'
+import type { ExpiredRouteRecord, FeishuDomainHandle, RouteRecord, SessionOriginRecord } from '../domain.ts'
+import { normalizeRouteRecord, normalizeSessionHistory } from '../domain.ts'
 
 export interface RouteStoreDeps {
   /** The opened domain handle, or undefined before `start()` / after shutdown. */
@@ -44,6 +45,11 @@ export class RouteStore {
       this.expired.set(key, record)
       this.active.delete(key)
     }
+    // Routes written before origins existed get theirs now; a failure only
+    // leaves those Sessions without a Web origin view.
+    for (const record of this.active.values()) {
+      void this.recordOrigins(record)
+    }
   }
 
   /** One active route by key (cache-first, normalized). */
@@ -70,7 +76,14 @@ export class RouteStore {
   /** Persist one active route and refresh the cache. */
   async put(key: string, record: RouteRecord): Promise<void> {
     await this.deps.domain()?.routes.put(key, record)
-    this.active.set(key, normalizeRouteRecord(record))
+    const normalized = normalizeRouteRecord(record)
+    this.active.set(key, normalized)
+    await this.recordOrigins(normalized)
+  }
+
+  /** Feishu origin of one Session any route ever named, retired routes included. */
+  origin(sessionId: string): SessionOriginRecord | undefined {
+    return this.deps.domain()?.sessionOrigins.get(sessionId)
   }
 
   /** Delete one active route from the medium and the cache. */
@@ -104,6 +117,34 @@ export class RouteStore {
     this.expired.clear()
   }
 
+  /**
+   * Write an origin for every Session in the route's history that has none.
+   * Existing origins are never rewritten: the first route naming a Session
+   * is where it started. Failures are logged and never fail the route write.
+   */
+  private async recordOrigins(record: RouteRecord): Promise<void> {
+    const table = this.deps.domain()?.sessionOrigins
+    if (table === undefined) return
+    for (const entry of normalizeSessionHistory(record)) {
+      if (table.get(entry.sessionId) !== undefined) continue
+      const origin: SessionOriginRecord = {
+        key: entry.sessionId,
+        routeKey: record.key,
+        kind: record.kind,
+        chatId: record.chatId,
+        chatType: record.chatType,
+        senderUserId: record.senderUserId,
+        createdAt: entry.createdAt,
+        ...(record.shared === true ? { shared: true as const } : {}),
+      }
+      try {
+        await table.put(entry.sessionId, origin)
+      } catch (error) {
+        this.deps.warn('dsh-channels: recording the origin of session %s failed: %s', entry.sessionId, String(error))
+      }
+    }
+  }
+
   /** Whether one active route has crossed the configured inactivity deadline. */
   private hasExpired(record: RouteRecord, now: number): boolean {
     const ttlMs = this.deps.ttlMs()

package/src/settings/contract.ts

@@ -38,6 +38,71 @@ export const ACCESS_REQUESTS_ROUTE = '/dsh-channels/access/requests'
  * [`EditableFieldWire.browse`]，保留手写输入。
  */
 export const PICK_DIRECTORY_ROUTE = '/dsh-channels/pick-directory'
+/** 会话的飞书来源（GET/HEAD，`?sessionId=`）：对话右侧栏「飞书来源」标签与会话头部入口使用。 */
+export const SESSION_ORIGIN_ROUTE = '/dsh-channels/session-origin'
+
+/** Where one Feishu-routed Session came from; names are resolved live and may be absent. */
+export interface SessionOriginWire {
+  sessionId: string
+  /** `p2p` = 私聊，`group` = 群聊。 */
+  chatType: 'p2p' | 'group'
+  /** `thread` = 话题内会话，`chat` = 整个聊天一个会话（话题不可用时的降级）。 */
+  kind: 'thread' | 'chat'
+  chatId: string
+  /** 群名（群聊且能读取群信息时）。 */
+  chatName?: string
+  /** 群头像 URL（群聊且能读取群信息时）。 */
+  chatAvatarUrl?: string
+  /** 发起人 user_id（日志平台分析话题为请求人）。 */
+  senderUserId: string
+  /** 发起人姓名（通讯录或群成员列表能查到时）。 */
+  senderName?: string
+  /** 发起人头像 URL（通讯录能查到时）。 */
+  senderAvatarUrl?: string
+  /** 日志平台分析话题：群内成员都可以继续。 */
+  shared: boolean
+  /** Epoch ms when the Session was bound to its Feishu route. */
+  createdAt: number
+  /** Whether the Feishu route still points at this Session (false after `/renew`, `/new` or route expiry). */
+  bound: boolean
+  /** Epoch ms of the route's last activity, while bound. */
+  lastActivityAt?: number
+  /** 在飞书客户端打开该聊天的链接。 */
+  chatLink: string
+}
+
+/**
+ * `GET PROFILES_ROUTE?users=<user_id,...>&chats=<chat_id,...>`: live Feishu
+ * names and avatars for the users and chats the panel shows. At most
+ * {@link PROFILES_MAX_IDS} ids per list.
+ */
+export const PROFILES_ROUTE = '/dsh-channels/profiles'
+
+/** Most `user_id`s, and separately most `chat_id`s, one profiles request may name. */
+export const PROFILES_MAX_IDS = 200
+
+/** Display name and avatar of one Feishu user or chat. */
+export interface FeishuProfileWire {
+  name?: string
+  /** `https:` image URL on the Feishu CDN. */
+  avatarUrl?: string
+}
+
+/**
+ * `GET PROFILES_ROUTE` response. Ids Feishu could not resolve, and ids that
+ * are not valid Feishu ids, are absent; `warning` carries the Feishu reason
+ * when a lookup failed (typically a missing scope).
+ */
+export interface FeishuProfilesWire {
+  users: Record<string, FeishuProfileWire>
+  chats: Record<string, FeishuProfileWire>
+  warning?: string
+}
+
+/** `GET SESSION_ORIGIN_ROUTE` response: `origin` is null for a Session not started from Feishu. */
+export interface SessionOriginResponse {
+  origin: SessionOriginWire | null
+}
 
 /**
  * 可由 Web 面板覆盖的配置项。顶层键对应 `src/config.ts` 的字段；`feishuTools.*`
@@ -99,6 +164,7 @@ export const EDITABLE_KEYS = [
   'promptContextTimeoutMs',
   // 准入与授权（白名单由「访问授权」tab 的列表管理）
   'accessMode',
+  'dmAllowWhitelist',
   'adminUserId',
   'authRequestTtlDays',
   // 知识库（顶层 `wikiRoots` 字符串列表；为空时不挂载任何知识库工具）
@@ -744,7 +810,10 @@ export const PANEL_COPY = {
   // ---- access -------------------------------------------------------------
   debugModeWarning: '调试模式已打开：应用可用范围内的任何人都能和机器人对话。用完请在「访问授权」关闭。',
   accessAdminMissingWarning: '没有可用的管理员，所有对话都会被拒绝。请在下方填写管理员 user_id（私聊机器人发送 /userid 获取）。',
-  accessAdminOwnerSummary: '未单独设置，正在使用应用所有者 {id}',
+  accessAdminCurrent: '当前管理员',
+  accessAdminSourceConfig: '已配置',
+  accessAdminSourceOwner: '应用所有者',
+  profilesWarning: '部分飞书名字和头像未能读取：{reason}',
   accessNotLoaded: '飞书连接建立后加载授权列表',
   accessRequestsTitle: '待处理申请',
   accessGroupsTitle: '已授权群',

package/src/settings/routes.ts

@@ -27,7 +27,10 @@ import {
   CREDENTIALS_ROUTE,
   PANEL_ROUTE,
   PICK_DIRECTORY_ROUTE,
+  PROFILES_MAX_IDS,
+  PROFILES_ROUTE,
   RECONNECT_ROUTE,
+  SESSION_ORIGIN_ROUTE,
   STATUS_ROUTE,
 } from './contract.ts'
 import type {
@@ -141,6 +144,12 @@ async function readJsonBody(req: IncomingMessage): Promise<unknown> {
   }
 }
 
+/** Distinct non-empty entries of one comma-separated id query parameter. */
+function idList(raw: string | null): string[] {
+  if (raw === null) return []
+  return [...new Set(raw.split(',').map(id => id.trim()).filter(id => id !== ''))]
+}
+
 /**
  * Parse one JSON-object body for an access write. HttpErrors are answered
  * here (415/413/400); `undefined` means "already responded, stop".
@@ -251,6 +260,44 @@ export function registerSettingsRoutes(
         ))
       }),
     }),
+    server.register({
+      kind: 'exact',
+      path: SESSION_ORIGIN_ROUTE,
+      handler: guarded(async (req, res) => {
+        if (!allowOnly(req, res, ['GET', 'HEAD'])) return
+        if (methodOf(req) === 'HEAD') {
+          res.writeHead(200, { 'cache-control': 'no-store' })
+          res.end()
+          return
+        }
+        const sessionId = new URL(req.url ?? '/', 'http://dsh.local').searchParams.get('sessionId')?.trim()
+        if (sessionId === undefined || sessionId === '') {
+          sendJson(res, 400, { ok: false, error: '缺少 sessionId 参数' })
+          return
+        }
+        sendJson(res, 200, await surface.sessionOrigin(sessionId))
+      }),
+    }),
+    server.register({
+      kind: 'exact',
+      path: PROFILES_ROUTE,
+      handler: guarded(async (req, res) => {
+        if (!allowOnly(req, res, ['GET', 'HEAD'])) return
+        if (methodOf(req) === 'HEAD') {
+          res.writeHead(200, { 'cache-control': 'no-store' })
+          res.end()
+          return
+        }
+        const params = new URL(req.url ?? '/', 'http://dsh.local').searchParams
+        const userIds = idList(params.get('users'))
+        const chatIds = idList(params.get('chats'))
+        if (userIds.length > PROFILES_MAX_IDS || chatIds.length > PROFILES_MAX_IDS) {
+          sendJson(res, 400, { ok: false, error: `每次最多查询 ${PROFILES_MAX_IDS} 个用户和 ${PROFILES_MAX_IDS} 个群` })
+          return
+        }
+        sendJson(res, 200, await surface.feishuProfiles(userIds, chatIds))
+      }),
+    }),
     server.register({
       kind: 'exact',
       path: CONFIG_ROUTE,

package/src/settings/surface.ts

@@ -37,6 +37,7 @@ import type {
   EditableFieldWire,
   EditableKey,
   EditableValues,
+  FeishuProfilesWire,
   FieldIssueWire,
   FieldGroup,
   FieldOptionWire,
@@ -48,6 +49,8 @@ import type {
   SaveCredentialsRequest,
   SaveCredentialsResponse,
   ScopeCheckWire,
+  SessionOriginResponse,
+  SessionOriginWire,
   SlashCommandSyncWire,
   StringListItemFormat,
 } from './contract.ts'
@@ -116,6 +119,10 @@ export interface SettingsTarget {
   removeWikiUser(userId: string): Promise<AccessMutationResponse>
   /** Settle one pending request (panel shares this path with the Feishu DM card). */
   resolveAccessRequest(token: string, decision: 'allow' | 'deny'): Promise<AccessMutationResponse>
+  /** Feishu origin of one Session, or null when Feishu never routed it. */
+  sessionOrigin(sessionId: string): Promise<SessionOriginWire | null>
+  /** Live Feishu names and avatars of the given users and chats. */
+  feishuProfiles(userIds: readonly string[], chatIds: readonly string[]): Promise<FeishuProfilesWire>
 }
 
 /** Presence/source/writability facts returned by the credentials seam. */
@@ -146,6 +153,7 @@ const BOOLEAN_KEYS = new Set<EditableKey>([
   'welcomeOnboarding',
   'slashCommandPanel',
   'allowPermissionSwitch',
+  'dmAllowWhitelist',
   'acceptAttachments',
   'prefetchImages',
   'feishuTools.attachmentFetch',
@@ -394,7 +402,13 @@ const FIELD_META: Record<EditableKey, FieldMeta> = {
     label: '调试模式',
     group: 'access',
     summary: '打开后所有人都能聊，不安全，只在调试时用',
-    help: '关闭时（默认）：管理员随时可用；非管理员私聊会被拒绝；群聊要同时满足群已授权、发言人在用户白名单里。授权入口有三个：群里 /auth 命令、授权卡、本页。撤销立即生效。',
+    help: '关闭时（默认）：管理员随时可用；非管理员私聊会被拒绝（打开「白名单用户可私聊」后白名单用户也可以）；群聊要同时满足群已授权、发言人在用户白名单里。授权入口有三个：群里 /auth 命令、授权卡、本页。撤销立即生效。',
+  },
+  dmAllowWhitelist: {
+    label: '白名单用户可私聊',
+    group: 'access',
+    summary: '关闭时私聊仅管理员可用',
+    help: '打开后「已授权用户」里的人也可以私聊机器人，各自使用独立的私聊工作区，能力与群聊相同；不在白名单的人仍收到固定提示。撤销用户立即生效。',
   },
   adminUserId: {
     label: '管理员 user_id',
@@ -720,6 +734,21 @@ export class SettingsSurface {
    * the draft provider/model changes). A broken lookup degrades to the
    * free-text form instead of failing the panel.
    */
+  /** Feishu origin of one Session for the conversation sidebar. */
+  async sessionOrigin(sessionId: string): Promise<SessionOriginResponse> {
+    return { origin: await this.target.sessionOrigin(sessionId) }
+  }
+
+  /**
+   * Live Feishu names and avatars for the panel's users and chats.
+   * @param userIds - user `user_id`s.
+   * @param chatIds - chat `chat_id`s.
+   * @returns the profiles Feishu resolved.
+   */
+  async feishuProfiles(userIds: readonly string[], chatIds: readonly string[]): Promise<FeishuProfilesWire> {
+    return this.target.feishuProfiles(userIds, chatIds)
+  }
+
   async catalogFor(provider?: string, model?: string): Promise<CatalogWire> {
     if (this.catalog === undefined) return emptyCatalog()
     try {