@xmoxmo/bncr 0.4.6 → 0.4.7

package/src/messaging/inbound/scene-admin.ts

@@ -0,0 +1,269 @@
+import type {
+  BncrGroupReplyMode,
+  BncrSceneRecord,
+  BncrSceneStatus,
+} from '../../plugin/channel-runtime-types.ts';
+import type { ParsedInbound } from './dispatch-prep.ts';
+import type { NativeCommand } from './native-command.ts';
+
+export type BncrSceneAdminCommand =
+  | { kind: 'allow'; sceneKey?: string }
+  | { kind: 'deny'; sceneKey?: string }
+  | { kind: 'revoke'; sceneKey?: string }
+  | { kind: 'bind'; sceneKey?: string; agentId: string }
+  | { kind: 'mode-help' }
+  | { kind: 'mode-get'; sceneKey?: string }
+  | { kind: 'mode'; sceneKey: string; mode: BncrGroupReplyMode }
+  | { kind: 'list'; scope: 'pending' | 'scenes' };
+
+const GROUP_REPLY_MODES = new Set<BncrGroupReplyMode>(['admin', 'mention', 'hybrid', 'all']);
+
+const MODE_HELP_TEXT = [
+  '💬 Group reply modes',
+  '  • default: admin',
+  '  • admin: 仅管理员|消息上送并逐条回复',
+  '  • mention: 全员|消息上送 仅指定消息触发回复',
+  '  • hybrid: 全员|消息上送 管理员逐条回复 其他人仅指定消息触发回复',
+  '  • all: 全员|消息上送并逐条回复',
+  '',
+  'Specified messages include:',
+  '  • @bot',
+  '  • reply to bot',
+  '  • platform-marked should-respond messages',
+  '',
+  'Usage:',
+  '  • /bncr mode',
+  '  • /bncr mode help',
+  '  • /bncr mode <admin|mention|hybrid|all> [<platform>:<groupId>]',
+].join('\n');
+
+export type ParsedSceneAdminCommand =
+  | { matched: false }
+  | { matched: true; valid: false; text: string }
+  | { matched: true; valid: true; command: BncrSceneAdminCommand };
+
+function normalizeToken(value: string): string {
+  return String(value || '').trim();
+}
+
+function splitArgs(raw: string): string[] {
+  return normalizeToken(raw)
+    .split(/\s+/)
+    .map((part) => part.trim())
+    .filter(Boolean);
+}
+
+function resolveCurrentGroupSceneKey(parsed: ParsedInbound): string | null {
+  if (parsed.peer.kind !== 'group') return null;
+  const platform = normalizeToken(parsed.platform);
+  const groupId = normalizeToken(parsed.groupId);
+  if (!platform || !groupId || groupId === '0') return null;
+  return `${platform}:${groupId}`;
+}
+
+export function parseSceneAdminCommand(command: NativeCommand): ParsedSceneAdminCommand {
+  const args = splitArgs(command.argsText);
+  switch (command.command) {
+    case 'allow':
+      return args.length <= 1
+        ? { matched: true, valid: true, command: { kind: 'allow', sceneKey: args[0] } }
+        : { matched: true, valid: false, text: 'Usage: /bncr allow [<sceneKey>]' };
+    case 'deny':
+      return args.length <= 1
+        ? { matched: true, valid: true, command: { kind: 'deny', sceneKey: args[0] } }
+        : { matched: true, valid: false, text: 'Usage: /bncr deny [<sceneKey>]' };
+    case 'revoke':
+      return args.length <= 1
+        ? { matched: true, valid: true, command: { kind: 'revoke', sceneKey: args[0] } }
+        : { matched: true, valid: false, text: 'Usage: /bncr revoke [<sceneKey>]' };
+    case 'bind':
+      if (args.length === 1) {
+        return {
+          matched: true,
+          valid: true,
+          command: { kind: 'bind', agentId: args[0] },
+        };
+      }
+      if (args.length === 2) {
+        return {
+          matched: true,
+          valid: true,
+          command: { kind: 'bind', agentId: args[0], sceneKey: args[1] },
+        };
+      }
+      return {
+        matched: true,
+        valid: false,
+        text: 'Usage: /bncr bind <agentId> [<sceneKey>]',
+      };
+    case 'mode':
+      if (args.length === 0) {
+        return { matched: true, valid: true, command: { kind: 'mode-get' } };
+      }
+      if (args.length === 1) {
+        if (args[0] === 'help') {
+          return {
+            matched: true,
+            valid: true,
+            command: { kind: 'mode-help' },
+          };
+        }
+        if (GROUP_REPLY_MODES.has(args[0] as BncrGroupReplyMode)) {
+          return {
+            matched: true,
+            valid: true,
+            command: { kind: 'mode', sceneKey: '', mode: args[0] as BncrGroupReplyMode },
+          };
+        }
+        return {
+          matched: true,
+          valid: true,
+          command: { kind: 'mode-get', sceneKey: args[0] },
+        };
+      }
+      if (GROUP_REPLY_MODES.has(args[0] as BncrGroupReplyMode) && args[1]) {
+        return {
+          matched: true,
+          valid: true,
+          command: { kind: 'mode', sceneKey: args[1], mode: args[0] as BncrGroupReplyMode },
+        };
+      }
+      return {
+        matched: true,
+        valid: false,
+        text: 'Usage: /bncr mode | /bncr mode <admin|mention|hybrid|all> [<sceneKey>]',
+      };
+    case 'list':
+      if (args[0] === 'pending') {
+        return { matched: true, valid: true, command: { kind: 'list', scope: 'pending' } };
+      }
+      if (args[0] === 'scenes') {
+        return { matched: true, valid: true, command: { kind: 'list', scope: 'scenes' } };
+      }
+      return { matched: true, valid: false, text: 'Usage: /bncr list <pending|scenes>' };
+    default:
+      return { matched: false };
+  }
+}
+
+function formatSceneLine(scene: BncrSceneRecord): string {
+  const idPart =
+    scene.kind === 'group' ? scene.groupId || scene.sceneKey : scene.userId || scene.sceneKey;
+  const namePart = scene.kind === 'group' ? scene.groupName || '' : scene.userName || '';
+  const agentPart = scene.agentId ? ` agent=${scene.agentId}` : '';
+  const modePart =
+    scene.kind === 'group' && scene.groupReplyMode ? ` mode=${scene.groupReplyMode}` : '';
+  const labelPart = namePart ? ` name=${namePart}` : '';
+  return `${scene.sceneKey} status=${scene.status} kind=${scene.kind} id=${idPart}${labelPart}${agentPart}${modePart}`;
+}
+
+function applySceneStatus(scene: BncrSceneRecord, status: BncrSceneStatus): BncrSceneRecord {
+  return {
+    ...scene,
+    status,
+  };
+}
+
+export function executeSceneAdminCommand(args: {
+  parsed: ParsedInbound;
+  command: BncrSceneAdminCommand;
+  sceneRegistry: Map<string, BncrSceneRecord>;
+  defaultAdminAgentId: string;
+  defaultPublicAgentId: string;
+  now: () => number;
+}): { ok: true; text: string } | { ok: false; text: string } {
+  const { parsed, command, sceneRegistry, defaultAdminAgentId, defaultPublicAgentId, now } = args;
+
+  if (!parsed.isAdmin) {
+    return { ok: false, text: 'Admin permission required.' };
+  }
+
+  if (command.kind === 'list') {
+    const scenes = Array.from(sceneRegistry.values())
+      .filter((scene) => (command.scope === 'pending' ? scene.status === 'pending' : true))
+      .sort((a, b) => a.lastSeenAt - b.lastSeenAt);
+    if (scenes.length === 0) {
+      return {
+        ok: true,
+        text: command.scope === 'pending' ? 'No pending scenes.' : 'No scenes recorded.',
+      };
+    }
+    return { ok: true, text: scenes.map(formatSceneLine).join('\n') };
+  }
+
+  if (command.kind === 'mode-help') {
+    return { ok: true, text: MODE_HELP_TEXT };
+  }
+
+  if (command.kind === 'mode-get') {
+    const sceneKey = command.sceneKey || resolveCurrentGroupSceneKey(parsed);
+    if (!sceneKey) {
+      return { ok: false, text: 'Current group mode query only works inside a group chat.' };
+    }
+    const existingScene = sceneRegistry.get(sceneKey);
+    if (!existingScene) {
+      return { ok: false, text: `Scene not found: ${sceneKey}` };
+    }
+    if (existingScene.kind !== 'group') {
+      return { ok: false, text: `Scene ${sceneKey} is not a group scene.` };
+    }
+    return {
+      ok: true,
+      text: `Current ${sceneKey} reply mode is ${existingScene.groupReplyMode || 'admin'}.`,
+    };
+  }
+
+  const sceneKey = command.sceneKey || resolveCurrentGroupSceneKey(parsed);
+  if (!sceneKey) {
+    return { ok: false, text: 'Current group shortcut only works inside a group chat.' };
+  }
+
+  const existing = sceneRegistry.get(sceneKey);
+  if (!existing) {
+    return { ok: false, text: `Scene not found: ${sceneKey}` };
+  }
+
+  if (command.kind === 'revoke') {
+    sceneRegistry.delete(sceneKey);
+    return { ok: true, text: `Revoked scene ${sceneKey}.` };
+  }
+
+  if (command.kind === 'bind') {
+    sceneRegistry.set(sceneKey, {
+      ...existing,
+      agentId: command.agentId,
+      lastSeenAt: now(),
+    });
+    return { ok: true, text: `Bound ${sceneKey} to agent ${command.agentId}.` };
+  }
+
+  if (command.kind === 'mode') {
+    if (existing.kind !== 'group') {
+      return { ok: false, text: `Scene ${sceneKey} is not a group scene.` };
+    }
+    sceneRegistry.set(sceneKey, {
+      ...existing,
+      groupReplyMode: command.mode,
+      lastSeenAt: now(),
+    });
+    return { ok: true, text: `Set ${sceneKey} reply mode to ${command.mode}.` };
+  }
+
+  const fallbackAgentId =
+    existing.kind === 'group'
+      ? defaultPublicAgentId
+      : parsed.isAdmin
+        ? defaultAdminAgentId
+        : defaultPublicAgentId;
+  const next = applySceneStatus(existing, command.kind === 'allow' ? 'allowed' : 'denied');
+  sceneRegistry.set(sceneKey, {
+    ...next,
+    ...(command.kind === 'allow' ? { agentId: existing.agentId || fallbackAgentId } : {}),
+    lastSeenAt: now(),
+  });
+
+  return {
+    ok: true,
+    text: command.kind === 'allow' ? `Allowed scene ${sceneKey}.` : `Denied scene ${sceneKey}.`,
+  };
+}

package/src/messaging/inbound/session-label.ts

@@ -5,6 +5,37 @@ import {
   updateBncrSessionStoreEntry,
 } from '../../openclaw/inbound-session-runtime.ts';
 
+function formatBncrSessionLabel(displayTo: string): string {
+  const raw = String(displayTo || '').trim();
+  const parts = raw.split(':');
+  if (parts.length === 4 && parts[0] === 'Bncr') {
+    const [, platform, groupId, userId] = parts;
+    if (platform && groupId && groupId !== '0') return `Bncr:${platform}:Group:${groupId}`;
+    if (platform && userId && userId !== '0') return `Bncr:${platform}:User:${userId}`;
+  }
+  return raw;
+}
+
+function formatBncrSessionRouteTarget(displayTo: string): string {
+  const raw = String(displayTo || '').trim();
+  const parts = raw.split(':');
+  if (parts.length === 4 && parts[0] === 'Bncr') {
+    const [, platform, groupId, userId] = parts;
+    if (platform && groupId && groupId !== '0') return `Bncr:${platform}:${groupId}:0`;
+    if (platform && userId && userId !== '0') return `Bncr:${platform}:0:${userId}`;
+  }
+  return raw;
+}
+
+function formatBncrSessionGroupKey(displayTo: string): string | null {
+  const raw = String(displayTo || '').trim();
+  const parts = raw.split(':');
+  if (parts.length !== 4 || parts[0] !== 'Bncr') return null;
+  const [, platform, groupId] = parts;
+  if (!platform || !groupId || groupId === '0') return null;
+  return `${platform.toLowerCase()}:${groupId}`;
+}
+
 type RecordInboundSessionFn = (args: {
   storePath?: string;
   sessionKey?: string;
@@ -21,30 +52,35 @@ export function buildBncrInboundSessionIdentityPatch(args: {
   senderId: string;
 }) {
   const { channelId, accountId, chatType, displayTo, senderId } = args;
+  const displayLabel = formatBncrSessionLabel(displayTo);
+  const routeTarget = formatBncrSessionRouteTarget(displayTo);
+  const groupKey = chatType === 'group' ? formatBncrSessionGroupKey(displayTo) : null;
   return {
-    label: displayTo,
+    label: displayLabel,
+    displayName: displayLabel,
     channel: channelId,
     chatType,
+    ...(groupKey ? { groupId: groupKey } : {}),
     origin: {
-      label: displayTo,
+      label: displayLabel,
       provider: channelId,
       surface: channelId,
       chatType,
       from: senderId,
-      to: displayTo,
+      to: routeTarget,
       accountId,
     },
     deliveryContext: {
       channel: channelId,
-      to: displayTo,
+      to: routeTarget,
       accountId,
     },
     route: {
       channel: channelId,
       accountId,
-      target: { to: displayTo },
+      target: { to: routeTarget },
     },
-    lastTo: displayTo,
+    lastTo: routeTarget,
   };
 }
 
@@ -56,20 +92,93 @@ function normalizeNonEmptyString(value: unknown): string | null {
 export async function correctBncrInboundSessionLabel(args: {
   storePath: string;
   sessionKey: string;
-  expectedLabel: string;
+  expectedPatch: Record<string, unknown>;
 }) {
   const storePath = normalizeNonEmptyString(args.storePath);
   const sessionKey = normalizeNonEmptyString(args.sessionKey);
-  const expectedLabel = normalizeNonEmptyString(args.expectedLabel);
-  if (!storePath || !sessionKey || !expectedLabel) return;
+  if (!storePath || !sessionKey) return;
+
+  const expectedPatch = args.expectedPatch;
+  const expectedLabel = normalizeNonEmptyString(expectedPatch.label);
+  const expectedDisplayName = normalizeNonEmptyString(expectedPatch.displayName);
+  const expectedGroupId = normalizeNonEmptyString(expectedPatch.groupId);
+  const expectedOriginTo = normalizeNonEmptyString(
+    (expectedPatch.origin as { to?: unknown } | undefined)?.to,
+  );
+  const expectedDeliveryTo = normalizeNonEmptyString(
+    (expectedPatch.deliveryContext as { to?: unknown } | undefined)?.to,
+  );
+  const expectedRouteTo = normalizeNonEmptyString(
+    (
+      (expectedPatch.route as { target?: { to?: unknown } } | undefined)?.target as
+        | { to?: unknown }
+        | undefined
+    )?.to,
+  );
+  const expectedLastTo = normalizeNonEmptyString(expectedPatch.lastTo);
+  if (
+    !expectedLabel ||
+    !expectedDisplayName ||
+    !expectedOriginTo ||
+    !expectedDeliveryTo ||
+    !expectedRouteTo ||
+    !expectedLastTo
+  )
+    return;
 
   try {
     await updateBncrSessionStoreEntry({
       storePath,
       sessionKey,
       update: (entry: SessionStoreEntryLike) => {
-        if (entry?.label === expectedLabel) return null;
-        return { label: expectedLabel };
+        const origin =
+          entry?.origin && typeof entry.origin === 'object'
+            ? (entry.origin as Record<string, unknown>)
+            : {};
+        const deliveryContext =
+          entry?.deliveryContext && typeof entry.deliveryContext === 'object'
+            ? (entry.deliveryContext as Record<string, unknown>)
+            : {};
+        const route =
+          entry?.route && typeof entry.route === 'object'
+            ? (entry.route as Record<string, unknown>)
+            : {};
+        const routeTarget =
+          route.target && typeof route.target === 'object'
+            ? (route.target as Record<string, unknown>)
+            : {};
+
+        const unchanged =
+          entry?.label === expectedLabel &&
+          entry?.displayName === expectedDisplayName &&
+          normalizeNonEmptyString(entry?.groupId) === expectedGroupId &&
+          normalizeNonEmptyString(origin.to) === expectedOriginTo &&
+          normalizeNonEmptyString(deliveryContext.to) === expectedDeliveryTo &&
+          normalizeNonEmptyString(routeTarget.to) === expectedRouteTo &&
+          normalizeNonEmptyString(entry?.lastTo) === expectedLastTo;
+        if (unchanged) return null;
+
+        return {
+          ...(expectedGroupId ? { groupId: expectedGroupId } : {}),
+          label: expectedLabel,
+          displayName: expectedDisplayName,
+          origin: {
+            ...origin,
+            ...(expectedPatch.origin as Record<string, unknown>),
+          },
+          deliveryContext: {
+            ...deliveryContext,
+            ...(expectedPatch.deliveryContext as Record<string, unknown>),
+          },
+          route: {
+            ...route,
+            ...(expectedPatch.route as Record<string, unknown>),
+            target: {
+              to: expectedRouteTo,
+            },
+          },
+          lastTo: expectedLastTo,
+        };
       },
     });
   } catch (err) {
@@ -108,7 +217,7 @@ export async function recordAndPatchBncrInboundSessionEntry(args: {
 
 export function wrapBncrInboundRecordSessionLabelCorrection(args: {
   recordInboundSession: RecordInboundSessionFn;
-  expectedLabel: string;
+  expectedPatch: Record<string, unknown>;
 }): RecordInboundSessionFn {
   return async (recordArgs) => {
     const result = await args.recordInboundSession(recordArgs);
@@ -116,7 +225,7 @@ export function wrapBncrInboundRecordSessionLabelCorrection(args: {
     await correctBncrInboundSessionLabel({
       storePath: recordArgs.storePath,
       sessionKey: recordArgs.sessionKey,
-      expectedLabel: args.expectedLabel,
+      expectedPatch: args.expectedPatch,
     });
     return result;
   };

package/src/messaging/inbound/session-meta-task.ts

@@ -0,0 +1,17 @@
+export function createBncrSessionMetaTaskBarrier() {
+  const pending = new Set<Promise<unknown>>();
+
+  return {
+    track(task: Promise<unknown>) {
+      if (!task || typeof task.then !== 'function') return;
+      pending.add(task);
+      void task.finally(() => {
+        pending.delete(task);
+      });
+    },
+    async wait() {
+      if (pending.size === 0) return;
+      await Promise.allSettled([...pending]);
+    },
+  };
+}