@xmoxmo/bncr 0.4.6 → 0.4.7

package/src/messaging/inbound/reply-dispatch-serial.ts

@@ -0,0 +1,62 @@
+import { emitBncrLogLine } from '../../core/logging.ts';
+
+const bncrReplyDispatchChains = new Map<string, Promise<void>>();
+
+export async function runBncrReplyDispatchSerial<T>(
+  sessionKey: string,
+  task: () => Promise<T>,
+  meta?: { msgId?: string | null; to?: string | null; debugEnabled?: boolean },
+) {
+  const key = String(sessionKey || '').trim();
+  if (!key) return await task();
+
+  const metaSuffix = `|msgId=${String(meta?.msgId || '-')}|to=${String(meta?.to || '-')}`;
+
+  const previous = bncrReplyDispatchChains.get(key) || Promise.resolve();
+  let release!: () => void;
+  const current = new Promise<void>((resolve) => {
+    release = resolve;
+  });
+  const chain = previous.then(() => current);
+  bncrReplyDispatchChains.set(key, chain);
+
+  const debugGate = () => meta?.debugEnabled === true;
+
+  emitBncrLogLine(
+    'info',
+    `[bncr] reply-serial queued|sessionKey=${key}${metaSuffix}`,
+    { debugOnly: true },
+    debugGate,
+  );
+  await previous;
+  emitBncrLogLine(
+    'info',
+    `[bncr] reply-serial acquired|sessionKey=${key}${metaSuffix}`,
+    { debugOnly: true },
+    debugGate,
+  );
+  try {
+    return await task();
+  } finally {
+    emitBncrLogLine(
+      'info',
+      `[bncr] reply-serial releasing|sessionKey=${key}${metaSuffix}`,
+      { debugOnly: true },
+      debugGate,
+    );
+    release();
+    if (bncrReplyDispatchChains.get(key) === chain) {
+      bncrReplyDispatchChains.delete(key);
+    }
+    emitBncrLogLine(
+      'info',
+      `[bncr] reply-serial released|sessionKey=${key}${metaSuffix}`,
+      { debugOnly: true },
+      debugGate,
+    );
+  }
+}
+
+export function resetBncrReplyDispatchSerialForTest() {
+  bncrReplyDispatchChains.clear();
+}

package/src/messaging/inbound/reply-dispatch.ts

@@ -1,6 +1,7 @@
 import { emitBncrLogLine } from '../../core/logging.ts';
 import { resolveBncrChannelPolicy } from '../../core/policy.ts';
 import {
+  readBncrSessionUpdatedAt,
   recordBncrInboundSession,
   resolveBncrPinnedMainDmOwnerFromAllowlist,
 } from '../../openclaw/inbound-session-runtime.ts';
@@ -17,9 +18,97 @@ import type {
   ParsedInbound,
 } from './dispatch-prep.ts';
 import { buildBncrInboundRecordUpdateLastRoute } from './last-route.ts';
+import { parseBncrNativeCommand } from './native-command.ts';
 import { buildBncrReplyConfig } from './reply-config.ts';
+import { runBncrReplyDispatchSerial } from './reply-dispatch-serial.ts';
 import { resolveBncrChannelInboundRuntime } from './runtime-compat.ts';
-import { wrapBncrInboundRecordSessionLabelCorrection } from './session-label.ts';
+import {
+  buildBncrInboundSessionIdentityPatch,
+  correctBncrInboundSessionLabel,
+  wrapBncrInboundRecordSessionLabelCorrection,
+} from './session-label.ts';
+import { createBncrSessionMetaTaskBarrier } from './session-meta-task.ts';
+
+function mergeBncrCommandOwnerAllowFrom(args: {
+  cfg: BncrInboundConfig;
+  parsed: ParsedInbound;
+  isBncrNativeCommand: boolean;
+  senderIdForContext: string;
+}) {
+  const { cfg, parsed, isBncrNativeCommand, senderIdForContext } = args;
+  if (parsed.isAdmin !== true || isBncrNativeCommand) return cfg;
+  const senderId = String(senderIdForContext || '').trim();
+  if (!senderId) return cfg;
+
+  const currentCommands = (cfg.commands || {}) as { ownerAllowFrom?: string[] };
+  const currentOwnerAllowFrom = Array.isArray(currentCommands.ownerAllowFrom)
+    ? currentCommands.ownerAllowFrom
+    : [];
+  if (currentOwnerAllowFrom.includes(senderId)) return cfg;
+
+  return {
+    ...cfg,
+    commands: {
+      ...currentCommands,
+      ownerAllowFrom: [...currentOwnerAllowFrom, senderId],
+    },
+  } satisfies BncrInboundConfig;
+}
+
+function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitForBncrReplySessionQuiescence(args: {
+  api: BncrInboundApi;
+  storePath: string;
+  sessionKey: string;
+  msgId?: string | null;
+  to: string;
+  debugEnabled?: boolean;
+}) {
+  const settleWindowMs = 120;
+  const pollIntervalMs = 40;
+  const maxWaitMs = 1500;
+  const startedAt = Date.now();
+  const debugGate = () => args.debugEnabled === true;
+  let lastUpdatedAt = null as number | null;
+  let stableSince = Date.now();
+
+  const readUpdatedAt = async () => {
+    try {
+      const updatedAt = await readBncrSessionUpdatedAt(args.api, {
+        storePath: args.storePath,
+        sessionKey: args.sessionKey,
+      });
+      return typeof updatedAt === 'number' && Number.isFinite(updatedAt) ? updatedAt : null;
+    } catch {
+      return null;
+    }
+  };
+
+  lastUpdatedAt = await readUpdatedAt();
+
+  while (Date.now() - startedAt < maxWaitMs) {
+    await sleep(pollIntervalMs);
+    const currentUpdatedAt = await readUpdatedAt();
+    if (currentUpdatedAt !== lastUpdatedAt) {
+      lastUpdatedAt = currentUpdatedAt;
+      stableSince = Date.now();
+      continue;
+    }
+    if (Date.now() - stableSince >= settleWindowMs) {
+      return;
+    }
+  }
+
+  emitBncrLogLine(
+    'warn',
+    `[bncr] reply-dispatch settle timeout|sessionKey=${args.sessionKey}|msgId=${args.msgId || '-'}|to=${args.to}|waitMs=${Date.now() - startedAt}`,
+    { debugOnly: true },
+    debugGate,
+  );
+}
 
 export async function runBncrInboundReplyDispatch(args: {
   api: BncrInboundApi;
@@ -34,6 +123,8 @@ export async function runBncrInboundReplyDispatch(args: {
   resolution: BncrInboundConversationResolution;
   replyRouteFact: BncrInboundReplyRouteFact;
   senderIdForContext: string;
+  senderDisplayName: string;
+  shouldDispatch: boolean;
   setInboundActivity: (accountId: string, at: number) => void;
   scheduleSave: () => void;
   enqueueFromReply: BncrEnqueueFromReply;
@@ -51,12 +142,20 @@ export async function runBncrInboundReplyDispatch(args: {
     resolution,
     replyRouteFact,
     senderIdForContext,
+    shouldDispatch,
     setInboundActivity,
     scheduleSave,
     enqueueFromReply,
   } = args;
 
   const effectiveReply = buildBncrReplyConfig(cfg);
+  const sessionIdentityPatch = buildBncrInboundSessionIdentityPatch({
+    channelId,
+    accountId: resolution.accountId,
+    chatType: resolution.chatType,
+    displayTo: resolution.canonicalTo,
+    senderId: senderIdForContext,
+  });
   const channelPolicy = resolveBncrChannelPolicy(cfg?.channels?.bncr || {});
   const pinnedMainDmOwner =
     peer.kind === 'direct'
@@ -76,87 +175,163 @@ export async function runBncrInboundReplyDispatch(args: {
     sessionKey: resolution.dispatchSessionKey,
     pinnedMainDmOwner,
   });
+  const isBncrNativeCommand =
+    parseBncrNativeCommand(rawBody, {
+      allowBareWhoami: parsed.isAdmin !== true,
+    }) !== null;
+  const commandDispatchCfg = mergeBncrCommandOwnerAllowFrom({
+    cfg,
+    parsed,
+    isBncrNativeCommand,
+    senderIdForContext,
+  });
 
-  await resolveBncrChannelInboundRuntime(api).run({
-    channel: channelId,
-    accountId: resolution.accountId,
-    raw: parsed,
-    adapter: {
-      ingest: () => ({
-        id: msgId ?? `${resolution.canonicalTo}:${Date.now()}`,
-        timestamp: Date.now(),
-        rawText: rawBody,
-        textForAgent: ctxPayload.BodyForAgent,
-        textForCommands: ctxPayload.CommandBody,
-        raw: parsed,
-      }),
-      resolveTurn: () => ({
+  if (!shouldDispatch) {
+    await wrapBncrInboundRecordSessionLabelCorrection({
+      recordInboundSession: recordBncrInboundSession as (
+        ...args: unknown[]
+      ) => Promise<unknown> | unknown,
+      expectedPatch: sessionIdentityPatch,
+    })({
+      storePath,
+      sessionKey: resolution.resolvedRoute.sessionKey,
+      ctx: ctxPayload,
+      updateLastRoute,
+      onRecordError: (err: unknown) => {
+        emitBncrLogLine('warn', `[bncr] inbound record session failed: ${String(err)}`);
+      },
+    });
+
+    const inboundAt = Date.now();
+    setInboundActivity(resolution.accountId, inboundAt);
+    scheduleSave();
+    return;
+  }
+
+  await runBncrReplyDispatchSerial(
+    resolution.dispatchSessionKey,
+    async () =>
+      resolveBncrChannelInboundRuntime(api).run({
         channel: channelId,
         accountId: resolution.accountId,
-        routeSessionKey: resolution.resolvedRoute.sessionKey,
-        storePath,
-        ctxPayload,
-        recordInboundSession: wrapBncrInboundRecordSessionLabelCorrection({
-          recordInboundSession: recordBncrInboundSession as (
-            ...args: unknown[]
-          ) => Promise<unknown> | unknown,
-          expectedLabel: resolution.canonicalTo,
-        }),
-        record: {
-          updateLastRoute,
-          onRecordError: (err: unknown) => {
-            emitBncrLogLine('warn', `[bncr] inbound record session failed: ${String(err)}`);
-          },
-        },
-        runDispatch: () =>
-          dispatchOpenClawReplyWithBufferedBlockDispatcher(api, {
-            ctx: ctxPayload,
-            cfg: effectiveReply.replyCfg,
-            dispatcherOptions: {
-              deliver: async (
-                payload: {
-                  text?: string;
-                  mediaUrl?: string;
-                  mediaUrls?: string[];
-                  audioAsVoice?: boolean;
-                },
-                info?: { kind?: 'tool' | 'block' | 'final' },
-              ) => {
-                const kind = info?.kind;
-                const shouldForwardTool = effectiveReply.blockStreaming && effectiveReply.allowTool;
-
-                if (kind === 'tool' && !shouldForwardTool) {
-                  return;
-                }
-
-                await enqueueFromReply({
-                  accountId: replyRouteFact.accountId,
-                  sessionKey: replyRouteFact.sessionKey,
-                  route: replyRouteFact.route,
-                  payload: {
-                    text: payload.text,
-                    mediaUrl: payload.mediaUrl,
-                    mediaUrls: payload.mediaUrls,
-                    kind: kind || 'final',
-                    replyToId: msgId || undefined,
+        raw: parsed,
+        adapter: {
+          ingest: () => ({
+            id: msgId ?? `${resolution.canonicalTo}:${Date.now()}`,
+            timestamp: Date.now(),
+            rawText: rawBody,
+            textForAgent: ctxPayload.BodyForAgent,
+            textForCommands: ctxPayload.CommandBody,
+            raw: parsed,
+          }),
+          preflight: () =>
+            shouldDispatch
+              ? undefined
+              : {
+                  admission: {
+                    kind: 'observeOnly' as const,
+                    reason: 'bncr-group-mode-no-reply',
                   },
-                });
+                },
+          resolveTurn: () => {
+            const sessionMetaBarrier = createBncrSessionMetaTaskBarrier();
+            return {
+              channel: channelId,
+              accountId: resolution.accountId,
+              routeSessionKey: resolution.resolvedRoute.sessionKey,
+              storePath,
+              ctxPayload,
+              recordInboundSession: wrapBncrInboundRecordSessionLabelCorrection({
+                recordInboundSession: recordBncrInboundSession as (
+                  ...args: unknown[]
+                ) => Promise<unknown> | unknown,
+                expectedPatch: sessionIdentityPatch,
+              }),
+              record: {
+                updateLastRoute,
+                onRecordError: (err: unknown) => {
+                  emitBncrLogLine('warn', `[bncr] inbound record session failed: ${String(err)}`);
+                },
+                trackSessionMetaTask: (task: Promise<unknown>) => {
+                  sessionMetaBarrier.track(task);
+                },
               },
-              onError: (err: unknown) => {
-                emitBncrLogLine('error', `[bncr] outbound reply failed: ${String(err)}`);
+              runDispatch: async () => {
+                await sessionMetaBarrier.wait();
+                await correctBncrInboundSessionLabel({
+                  storePath,
+                  sessionKey: resolution.dispatchSessionKey,
+                  expectedPatch: sessionIdentityPatch,
+                });
+                return Promise.resolve(
+                  dispatchOpenClawReplyWithBufferedBlockDispatcher(api, {
+                    ctx: ctxPayload,
+                    cfg: buildBncrReplyConfig(commandDispatchCfg).replyCfg,
+                    dispatcherOptions: {
+                      deliver: async (
+                        payload: {
+                          text?: string;
+                          mediaUrl?: string;
+                          mediaUrls?: string[];
+                          audioAsVoice?: boolean;
+                        },
+                        info?: { kind?: 'tool' | 'block' | 'final' },
+                      ) => {
+                        const kind = info?.kind;
+                        const shouldForwardTool =
+                          effectiveReply.blockStreaming && effectiveReply.allowTool;
+
+                        if (kind === 'tool' && !shouldForwardTool) {
+                          return;
+                        }
+
+                        await enqueueFromReply({
+                          accountId: replyRouteFact.accountId,
+                          sessionKey: replyRouteFact.sessionKey,
+                          route: replyRouteFact.route,
+                          payload: {
+                            text: payload.text,
+                            mediaUrl: payload.mediaUrl,
+                            mediaUrls: payload.mediaUrls,
+                            kind: kind || 'final',
+                            replyToId: msgId || undefined,
+                          },
+                        });
+                      },
+                      onError: (err: unknown) => {
+                        emitBncrLogLine('error', `[bncr] outbound reply failed: ${String(err)}`);
+                      },
+                    },
+                    replyOptions: {
+                      disableBlockStreaming: !effectiveReply.blockStreaming,
+                      shouldEmitToolResult: effectiveReply.allowTool ? () => true : undefined,
+                    },
+                  }),
+                ).finally(async () => {
+                  await waitForBncrReplySessionQuiescence({
+                    api,
+                    storePath,
+                    sessionKey: resolution.dispatchSessionKey,
+                    msgId,
+                    to: resolution.canonicalTo,
+                    debugEnabled: cfg?.channels?.bncr?.debug?.verbose === true,
+                  });
+                  await correctBncrInboundSessionLabel({
+                    storePath,
+                    sessionKey: resolution.dispatchSessionKey,
+                    expectedPatch: sessionIdentityPatch,
+                  });
+                });
               },
-            },
-            replyOptions: {
-              disableBlockStreaming: !effectiveReply.blockStreaming,
-              shouldEmitToolResult: effectiveReply.allowTool ? () => true : undefined,
-            },
-          }),
+            };
+          },
+          onFinalize: () => {
+            const inboundAt = Date.now();
+            setInboundActivity(resolution.accountId, inboundAt);
+            scheduleSave();
+          },
+        },
       }),
-      onFinalize: () => {
-        const inboundAt = Date.now();
-        setInboundActivity(resolution.accountId, inboundAt);
-        scheduleSave();
-      },
-    },
-  });
+    { msgId, to: resolution.canonicalTo },
+  );
 }