@xmoxmo/bncr 0.6.1 → 0.6.3

package/README.md

@@ -93,9 +93,73 @@ openclaw devices approve --latest
 - 入站会话按正式 scene / route 语义接入 OpenClaw，区分私聊与群聊会话。
 - 非管理员私聊支持受控的本地命令能力：`/whoami`、`/status`、`/new`、`/reset`，以及对应的 `/bncr ...` 入口。
 - 非管理员私聊中，不在支持范围内的 slash 命令会由 bncr 直接拒绝，不再 fallback 到 agent。
-- 群聊里的管理型 / 控制型命令对非管理员按静默拒绝处理，不给用户可见回复。
+- 群聊非管理员执行场景管理命令（`mode` / `allow` / `deny` / `bind` / `revoke` / `list` / `history-*` / `download-media`）时，统一返回 `Admin permission required.`，不再附带用法提示。
+- 群聊非管理员执行 `/bncr new`、`/bncr reset`、`/bncr verbose` 时仍按静默拒绝处理。
 - `/bncr list pending` 与 `/bncr list scenes` 采用按私聊 / 群聊分组的摘要展示格式，便于现场排查 scene 状态。
 
+### `/bncr help` 权限过滤
+
+`/bncr help` 现在按当前身份动态展示：
+
+- 管理员：展示全部命令
+- 私聊非管理员：展示当前可用命令，不展示管理类命令
+- 群聊非管理员：仅展示基础命令，不展示 `mode`、`history-*`、`download-media` 等管理命令
+
+示例：
+
+管理员：
+
+```text
+🦞 Bncr command usage
+
+📌 Bncr builtins
+  • /bncr whoami
+  • /bncr status
+  • /bncr new
+  • /bncr reset
+  • /bncr verbose on|off|full
+
+🛡 Scene approval
+  • /bncr allow [<SceneId>]
+  • /bncr deny [<SceneId>]
+  • /bncr bind <agentId> [<SceneId>]
+  • /bncr mode help
+  • /bncr mode <admin|mention|hybrid|all|clear> [<SceneId>]
+  • /bncr revoke [<SceneId>]
+  • /bncr list pending [filters...]
+  • /bncr list scenes [filters...]
+
+📋 Conversation history
+  • /bncr history-help
+  • /bncr history-limit [<number>|clear] [<SceneId>]
+  • /bncr history-force on|off|clear [<SceneId>]
+
+🌐 Remote media
+  • /bncr download-media on|off|clear|default on|off [<SceneId>]
+```
+
+私聊非管理员：
+
+```text
+🦞 Bncr command usage
+
+📌 Bncr builtins
+  • /bncr whoami
+  • /bncr status
+  • /bncr new
+  • /bncr reset
+```
+
+群聊非管理员：
+
+```text
+🦞 Bncr command usage
+
+📌 Bncr builtins
+  • /bncr whoami
+  • /bncr status
+```
+
 ---
 
 ## 5. 架构定位

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmoxmo/bncr",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "private": false,
   "type": "module",
   "license": "MIT",

package/scripts/check-pack.mjs

@@ -158,6 +158,7 @@ const requiredSourceFiles = [
   'src/plugin/setup.ts',
   'src/plugin/state-transient-runtime-group.ts',
   'src/plugin/state-store.ts',
+  'src/plugin/sqlite-state.ts',
   'src/plugin/target-runtime.ts',
   'src/plugin/target-status-runtime-group.ts',
   'src/plugin/transient-state-runtime.ts',
@@ -174,7 +175,9 @@ const requiredSourceFiles = [
   'src/bootstrap/register-runtime-singleton.ts',
   'src/core/value-sanitize.ts',
   'src/messaging/inbound/contracts.ts',
-  'src/messaging/inbound/group-history.ts',
+  'src/messaging/inbound/conversation-history.ts',
+  'src/messaging/inbound/conversation-history-serial.ts',
+  'src/messaging/inbound/history-shard-worker.ts',
   'src/messaging/inbound/native-command-runtime.ts',
   'src/messaging/inbound/reply-dispatch-serial.ts',
   'src/messaging/inbound/scene-admin.ts',

package/scripts/selfcheck.mjs

@@ -63,7 +63,9 @@ const requiredSourceFiles = [
   'src/messaging/inbound/dispatch-prep.ts',
   'src/messaging/inbound/dispatch.ts',
   'src/messaging/inbound/gate.ts',
-  'src/messaging/inbound/group-history.ts',
+  'src/messaging/inbound/conversation-history.ts',
+  'src/messaging/inbound/conversation-history-serial.ts',
+  'src/messaging/inbound/history-shard-worker.ts',
   'src/messaging/inbound/last-route.ts',
   'src/messaging/inbound/media-url-download.ts',
   'src/messaging/inbound/native-command-runtime.ts',
@@ -191,6 +193,7 @@ const requiredSourceFiles = [
   'src/plugin/scene-registry.ts',
   'src/plugin/setup.ts',
   'src/plugin/state-store.ts',
+  'src/plugin/sqlite-state.ts',
   'src/plugin/state-transient-runtime-group.ts',
   'src/plugin/status-runtime.ts',
   'src/plugin/status.ts',

package/src/channel.ts

@@ -43,9 +43,22 @@ import type {
   FileSendTransferState,
   OutboxEntry,
 } from './core/types.ts';
-import type { BncrGroupHistoryMap } from './messaging/inbound/group-history.ts';
+import {
+  type BncrConversationHistoryMap,
+  resolveBncrHistoryLimit,
+} from './messaging/inbound/conversation-history.ts';
+import {
+  clearConversationHistorySerialLocks,
+  readConversationHistorySerialHistoryKeys,
+} from './messaging/inbound/conversation-history-serial.ts';
+import { dispatchBncrOutboundHistoryFlush } from './messaging/inbound/dispatch.ts';
+import {
+  type BncrHistoryShardDispatchPayload,
+  processBncrHistoryShardSlot,
+} from './messaging/inbound/history-shard-worker.ts';
 import type { BncrOutboundReplayCache } from './messaging/inbound/outbound-replay-cache.ts';
 import type { parseBncrInboundParams } from './messaging/inbound/parse.ts';
+import { runBncrInboundReplyDispatch } from './messaging/inbound/reply-dispatch.ts';
 import { buildEnqueueFromReplyDebugInfo } from './messaging/outbound/diagnostics.ts';
 import { buildBncrMediaOutboundFrame } from './messaging/outbound/media.ts';
 import {
@@ -126,6 +139,8 @@ import {
   FILE_TRANSFER_ACK_TTL_MS,
   FILE_TRANSFER_KEEP_MS,
   FILE_TRANSFER_TERMINAL_KEEP_MS,
+  HISTORY_SHARD_WORKER_BATCH_LIMIT,
+  HISTORY_SHARD_WORKER_INTERVAL_MS,
   INBOUND_FILE_TRANSFER_MAX_BYTES,
   INBOUND_FILE_TRANSFER_MAX_CHUNKS,
   MAX_ACCOUNT_ACTIVITY_ENTRIES,
@@ -187,6 +202,7 @@ import {
   createBncrRuntimeAckObservabilityBuilder,
 } from './plugin/runtime-diagnostics-snapshot.ts';
 import { BNCR_SETUP_SURFACE } from './plugin/setup.ts';
+import type { BncrHistoryShardRow } from './plugin/sqlite-state.ts';
 import { createBncrStateTransientRuntimeGroup } from './plugin/state-transient-runtime-group.ts';
 import { createBncrTargetStatusRuntimeGroup } from './plugin/target-status-runtime-group.ts';
 import { shouldEmitDedupLog as shouldEmitDedupLogFromRuntime } from './runtime/log-dedupe.ts';
@@ -293,7 +309,7 @@ class BncrBridgeRuntime {
   getSceneRegistry(): Map<string, BncrSceneRecord> {
     return this.sceneRegistry;
   }
-  private groupHistories: BncrGroupHistoryMap = new Map();
+  private conversationHistories: BncrConversationHistoryMap = new Map();
   private outboundReplayCache: BncrOutboundReplayCache = new Map();
   private routeAliases = new Map<
     string,
@@ -340,6 +356,8 @@ class BncrBridgeRuntime {
   // Timers / background workers ---------------------------------------------
   private saveTimer: NodeJS.Timeout | null = null;
   private pushTimer: NodeJS.Timeout | null = null;
+  private historyShardWorkerTimer: NodeJS.Timeout | null = null;
+  private historyShardWorkerRunning = false;
   private pushDrainRunningAccounts = new Set<string>();
   private pushDrainRunningSinceByAccount = new Map<string, number>();
   private pushDrainStuckWarnedAtByAccount = new Map<string, number>();
@@ -836,6 +854,7 @@ class BncrBridgeRuntime {
         initializeCanonicalAgentId: (cfg) => this.initializeCanonicalAgentId(cfg),
         logWarn: (scope, message, options) => this.logWarn(scope, message, options),
         loadState: () => this.loadState(),
+        cutoverToSqlite: () => this.stateStore.cutoverToSqlite(),
         setDebugFlag: (value) => {
           BNCR_DEBUG_VERBOSE = value;
         },
@@ -850,6 +869,7 @@ class BncrBridgeRuntime {
       ctx,
       debug,
     );
+    this.startHistoryShardWorker();
   };
 
   stopService = async () => {
@@ -867,6 +887,7 @@ class BncrBridgeRuntime {
   }
 
   private cleanupRuntimeWaitersAndTimers(reason: string) {
+    this.stopHistoryShardWorker(reason);
     this.clientRpcRuntime.shutdown();
     cleanupBncrBridgeRuntime(
       {
@@ -1077,13 +1098,85 @@ class BncrBridgeRuntime {
   }
 
   private async loadState() {
-    await this.stateStore.loadState();
+    // A hot bridge rebuild must not recover shards whose old serial task is
+    // still uploading in this process. Normal process restarts have no active
+    // keys and therefore recover every in-flight shard.
+    const activeHistoryKeys = readConversationHistorySerialHistoryKeys();
+    clearConversationHistorySerialLocks(
+      'runtime-restart',
+      `${this.bridgeId}:${Date.now()}:${Math.random().toString(16).slice(2, 8)}`,
+    );
+    await this.stateStore.recoverInFlightHistoryShards(activeHistoryKeys);
+    await this.stateStore.loadState(activeHistoryKeys);
   }
 
   private async flushState() {
     await this.stateStore.flushState();
   }
 
+  private startHistoryShardWorker() {
+    if (this.historyShardWorkerTimer) {
+      clearInterval(this.historyShardWorkerTimer);
+      this.historyShardWorkerTimer = null;
+    }
+    if (this.stopped) return;
+    this.historyShardWorkerTimer = setInterval(() => {
+      void this.tickHistoryShardWorker();
+    }, HISTORY_SHARD_WORKER_INTERVAL_MS);
+    this.historyShardWorkerTimer.unref?.();
+  }
+
+  private stopHistoryShardWorker(reason: string) {
+    if (this.historyShardWorkerTimer) {
+      clearInterval(this.historyShardWorkerTimer);
+      this.historyShardWorkerTimer = null;
+    }
+    this.logInfo(
+      'history-shard',
+      `history-shard worker stopped|bridge=${this.bridgeId}|reason=${reason}`,
+      { debugOnly: true },
+    );
+  }
+
+  private async tickHistoryShardWorker() {
+    if (this.historyShardWorkerRunning || this.stopped) return;
+    this.historyShardWorkerRunning = true;
+    try {
+      for (let i = 0; i < HISTORY_SHARD_WORKER_BATCH_LIMIT; i += 1) {
+        const shard = this.stateStore.historyShardQueue.claimNextHistoryShard();
+        if (!shard) break;
+        await this.processHistoryShard(shard);
+      }
+    } catch (error) {
+      this.logWarn('inbound', `history shard worker tick failed: ${String(error)}`);
+    } finally {
+      this.historyShardWorkerRunning = false;
+    }
+  }
+
+  private async processHistoryShard(shard: BncrHistoryShardRow) {
+    const cfg = getOpenClawRuntimeConfig(this.api);
+    await processBncrHistoryShardSlot({
+      shard,
+      historyShardQueue: this.stateStore.historyShardQueue,
+      conversationHistories: this.conversationHistories,
+      outboundReplayCache: this.outboundReplayCache,
+      runDispatch: (payload: BncrHistoryShardDispatchPayload) =>
+        runBncrInboundReplyDispatch({
+          api: this.api,
+          channelId: CHANNEL_ID,
+          cfg,
+          ...payload,
+          setInboundActivity: (accountId, at) => {
+            this.lastInboundByAccount.set(accountId, at);
+            this.markActivity(accountId, at);
+          },
+          scheduleSave: () => this.scheduleSave(),
+          enqueueFromReply: (args) => this.enqueueFromReply(args),
+        }),
+    });
+  }
+
   private resolveMessageAck(messageId: string, result: 'acked' | 'timeout' = 'acked') {
     return this.messageAckRuntime.resolveMessageAck(messageId, result);
   }
@@ -1901,7 +1994,7 @@ class BncrBridgeRuntime {
     maxSessionRouteEntries: MAX_SESSION_ROUTE_ENTRIES,
     maxAccountActivityEntries: MAX_ACCOUNT_ACTIVITY_ENTRIES,
     sceneRegistry: this.sceneRegistry,
-    groupHistories: this.groupHistories,
+    conversationHistories: this.conversationHistories,
     outboundReplayCache: this.outboundReplayCache,
     outbox: this.outbox,
     getDeadLetter: () => this.deadLetter,
@@ -2168,6 +2261,21 @@ class BncrBridgeRuntime {
     deadLetterSinceStartByAccount: this.deadLetterSinceStartByAccount,
     lastOutboundByAccount: this.lastOutboundByAccount,
     outboundReplayCache: this.outboundReplayCache,
+    conversationHistories: this.conversationHistories,
+    resolveOutboundHistoryLimit: (entry) => {
+      const platform = entry.route?.platform || '';
+      const groupId = entry.route?.groupId || '0';
+      const userId = entry.route?.userId || '0';
+      const sceneKey = groupId !== '0' ? `${platform}:${groupId}` : `${platform}:${userId}`;
+      return resolveBncrHistoryLimit(this.sceneRegistry.get(sceneKey)?.historyLimit);
+    },
+    resolveOutboundHistoryForce: (entry) => {
+      const platform = entry.route?.platform || '';
+      const groupId = entry.route?.groupId || '0';
+      const userId = entry.route?.userId || '0';
+      const sceneKey = groupId !== '0' ? `${platform}:${groupId}` : `${platform}:${userId}`;
+      return this.sceneRegistry.get(sceneKey)?.historyForce !== false;
+    },
     resolveOutboundSender: (entry) => {
       try {
         const account = resolveAccount(getOpenClawRuntimeConfig(this.api), entry.accountId);
@@ -2176,6 +2284,8 @@ class BncrBridgeRuntime {
         return { sender: 'OpenClaw', senderId: entry.accountId };
       }
     },
+    onConversationHistoryOverflow: (entry, historyVersion) =>
+      this.flushConversationHistoryFromOutbound(entry, historyVersion),
     isOutboundAckRequired: (accountId) => this.isOutboundAckRequired(accountId),
     scheduleSave: () => this.scheduleSave(),
     flushPushQueueBestEffort: (args) => this.flushPushQueueBestEffort(args),
@@ -2763,6 +2873,35 @@ class BncrBridgeRuntime {
     this.bridgeOutboxFacade.markRecentOutboundAcked(entry);
   }
 
+  private flushConversationHistoryFromOutbound(entry: OutboxEntry, historyVersion?: number) {
+    const cfg = getOpenClawRuntimeConfig(this.api);
+    const canonicalAgentId = this.canonicalAgentId || 'main';
+    void dispatchBncrOutboundHistoryFlush({
+      api: this.api,
+      channelId: CHANNEL_ID,
+      cfg,
+      entry,
+      ...(historyVersion !== undefined ? { historyVersion } : {}),
+      canonicalAgentId,
+      sceneRegistry: this.sceneRegistry,
+      conversationHistories: this.conversationHistories,
+      outboundReplayCache: this.outboundReplayCache,
+      defaultAdminAgentId: canonicalAgentId,
+      defaultPublicAgentId: this.defaultPublicAgentId(),
+      now,
+      rememberSessionRoute: (sessionKey, accountId, route) =>
+        this.rememberSessionRoute(sessionKey, accountId, route),
+      enqueueFromReply: (args) => this.enqueueFromReply(args),
+      setInboundActivity: (accountId, at) => {
+        this.lastInboundByAccount.set(accountId, at);
+        this.markActivity(accountId, at);
+      },
+      scheduleSave: () => this.scheduleSave(),
+    }).catch((err) => {
+      this.logWarn('inbound', `outbound history flush failed: ${String(err)}`);
+    });
+  }
+
   private logEnqueueFromReply(args: {
     accountId: string;
     sessionKey: string;
@@ -2893,7 +3032,7 @@ class BncrBridgeRuntime {
       defaultAdminAgentId: (args) => this.defaultAdminAgentId(args),
       defaultPublicAgentId: () => this.defaultPublicAgentId(),
       sceneRegistry: this.sceneRegistry,
-      groupHistories: this.groupHistories,
+      conversationHistories: this.conversationHistories,
       outboundReplayCache: this.outboundReplayCache,
       prepareInboundAcceptance: (args) => this.prepareInboundAcceptance(args),
       logInboundSummary: (args) => this.logInboundSummary(args),

package/src/messaging/inbound/commands.ts

@@ -224,7 +224,10 @@ export async function handleBncrNativeCommand(params: {
   });
 
   const nativeVerbose = resolveBncrNativeVerboseCommand(command);
-  const nativeHelp = resolveBncrNativeHelpCommand(command);
+  const nativeHelp = resolveBncrNativeHelpCommand(command, {
+    isAdmin: parsed.isAdmin,
+    peerKind: parsed.peer.kind as 'direct' | 'group',
+  });
   const nativeWhoami = resolveBncrNativeWhoamiCommand({
     command,
     platform: parsed.platform,
@@ -244,7 +247,10 @@ export async function handleBncrNativeCommand(params: {
     resolvedAgentId: resolvedRoute.agentId || canonicalAgentId,
     sessionKey,
   });
-  const nativeSessionReset = resolveBncrNativeSessionResetCommand({ command });
+  const nativeSessionReset = resolveBncrNativeSessionResetCommand({
+    command,
+    peerKind: parsed.peer.kind as 'direct' | 'group',
+  });
   if (nativeHelp) {
     logBncrNativeCommandSummary(
       buildBncrNativeCommandSummary({
@@ -336,7 +342,7 @@ export async function handleBncrNativeCommand(params: {
   }
 
   if (nativeSessionReset) {
-    const allowLocalSessionReset = parsed.peer.kind === 'direct';
+    const allowLocalSessionReset = parsed.peer.kind === 'direct' || parsed.isAdmin;
     if (!allowLocalSessionReset) {
       logBncrNativeCommandSummary(
         buildBncrNativeCommandSummary({
@@ -481,8 +487,7 @@ export async function handleBncrNativeCommand(params: {
 
   const sceneAdmin = parseSceneAdminCommand(command);
   if (sceneAdmin.matched) {
-    const silentNonAdminGroupReject = !parsed.isAdmin && parsed.peer.kind === 'group';
-    if (!sceneAdmin.valid) {
+    if (!parsed.isAdmin) {
       logBncrNativeCommandSummary(
         buildBncrNativeCommandSummary({
           kind: 'scene-admin',
@@ -493,17 +498,50 @@ export async function handleBncrNativeCommand(params: {
           result: 'rejected',
         }),
       );
-      if (!silentNonAdminGroupReject) {
-        await enqueueFromReply({
+      await recordAndPatchBncrInboundSessionEntry({
+        storePath,
+        sessionKey,
+        ctx: ctxPayload,
+        patch: sessionIdentityPatch,
+      });
+      await enqueueFromReply({
+        accountId,
+        sessionKey,
+        route,
+        payload: {
+          text: 'Admin permission required.',
+          replyToId: msgId || undefined,
+        },
+      });
+      return { handled: true, command: command.command, sessionKey };
+    }
+
+    if (!sceneAdmin.valid) {
+      logBncrNativeCommandSummary(
+        buildBncrNativeCommandSummary({
+          kind: 'scene-admin',
+          command: command.command,
           accountId,
-          sessionKey,
-          route,
-          payload: {
-            text: sceneAdmin.text,
-            replyToId: msgId || undefined,
-          },
-        });
-      }
+          to: displayTo,
+          msgId: msgId ?? null,
+          result: 'rejected',
+        }),
+      );
+      await recordAndPatchBncrInboundSessionEntry({
+        storePath,
+        sessionKey,
+        ctx: ctxPayload,
+        patch: sessionIdentityPatch,
+      });
+      await enqueueFromReply({
+        accountId,
+        sessionKey,
+        route,
+        payload: {
+          text: sceneAdmin.text,
+          replyToId: msgId || undefined,
+        },
+      });
       return { handled: true, command: command.command, sessionKey };
     }
 
@@ -531,17 +569,15 @@ export async function handleBncrNativeCommand(params: {
       ctx: ctxPayload,
       patch: sessionIdentityPatch,
     });
-    if (!(silentNonAdminGroupReject && !outcome.ok)) {
-      await enqueueFromReply({
-        accountId,
-        sessionKey,
-        route,
-        payload: {
-          text: outcome.text,
-          replyToId: msgId || undefined,
-        },
-      });
-    }
+    await enqueueFromReply({
+      accountId,
+      sessionKey,
+      route,
+      payload: {
+        text: outcome.text,
+        replyToId: msgId || undefined,
+      },
+    });
     return { handled: true, command: command.command, sessionKey };
   }