@xmoxmo/bncr 0.4.6 → 0.4.8

package/src/plugin/scene-registry.ts

@@ -0,0 +1,171 @@
+import type {
+  BncrGroupReplyMode,
+  BncrSceneKind,
+  BncrSceneRecord,
+  BncrSceneStatus,
+} from './channel-runtime-types.ts';
+
+type ParsedInbound = ReturnType<
+  typeof import('../messaging/inbound/parse.ts')['parseBncrInboundParams']
+>;
+
+export type BncrSceneRegistryDecision =
+  | {
+      allowed: true;
+      scene: BncrSceneRecord;
+      agentId: string;
+    }
+  | {
+      allowed: false;
+      scene: BncrSceneRecord;
+      reason: string;
+      replyPolicy: 'silent' | 'pending';
+    };
+
+function asSceneKind(parsed: ParsedInbound): BncrSceneKind {
+  return parsed.peer.kind === 'group' ? 'group' : 'direct';
+}
+
+function defaultGroupReplyMode(kind: BncrSceneKind): BncrGroupReplyMode | undefined {
+  return kind === 'group' ? 'admin' : undefined;
+}
+
+export function buildSceneKey(parsed: ParsedInbound): string {
+  return parsed.peer.kind === 'group'
+    ? `${parsed.platform}:${parsed.groupId}`
+    : `${parsed.platform}:${parsed.userId}`;
+}
+
+export function buildSceneRecord(args: {
+  parsed: ParsedInbound;
+  sceneKey: string;
+  kind: BncrSceneKind;
+  status: BncrSceneStatus;
+  agentId?: string;
+  lastSeenAt: number;
+}): BncrSceneRecord {
+  const { parsed, sceneKey, kind, status, agentId, lastSeenAt } = args;
+  return {
+    sceneKey,
+    kind,
+    status,
+    platform: parsed.platform,
+    ...(parsed.userId ? { userId: parsed.userId } : {}),
+    ...(parsed.userName ? { userName: parsed.userName } : {}),
+    ...(kind === 'group' && parsed.groupId ? { groupId: parsed.groupId } : {}),
+    ...(kind === 'group' && parsed.groupName ? { groupName: parsed.groupName } : {}),
+    ...(agentId ? { agentId } : {}),
+    ...(kind === 'group' ? { groupReplyMode: defaultGroupReplyMode(kind) } : {}),
+    lastSeenAt,
+  };
+}
+
+export function decideSceneAdmission(args: {
+  parsed: ParsedInbound;
+  now: number;
+  sceneRegistry: Map<string, BncrSceneRecord>;
+  defaultAdminAgentId: string;
+  defaultPublicAgentId: string;
+}): BncrSceneRegistryDecision {
+  const { parsed, now, sceneRegistry, defaultAdminAgentId, defaultPublicAgentId } = args;
+  const sceneKey = buildSceneKey(parsed);
+  const kind = asSceneKind(parsed);
+  const existing = sceneRegistry.get(sceneKey);
+  const shouldForceDirectNonAdminPublic = (agentId?: string) =>
+    kind === 'direct' && parsed.isAdmin !== true && (!agentId || agentId === defaultAdminAgentId);
+
+  if (existing) {
+    const forcedAgentId = shouldForceDirectNonAdminPublic(existing.agentId)
+      ? defaultPublicAgentId
+      : existing.agentId;
+    const nextScene = {
+      ...existing,
+      ...(parsed.userId ? { userId: parsed.userId } : {}),
+      ...(parsed.userName ? { userName: parsed.userName } : {}),
+      ...(kind === 'group' && parsed.groupId ? { groupId: parsed.groupId } : {}),
+      ...(kind === 'group' && parsed.groupName ? { groupName: parsed.groupName } : {}),
+      ...(forcedAgentId ? { agentId: forcedAgentId } : {}),
+      ...(kind === 'group' && !existing.groupReplyMode
+        ? { groupReplyMode: defaultGroupReplyMode(kind) }
+        : {}),
+      lastSeenAt: now,
+    } satisfies BncrSceneRecord;
+
+    if (kind === 'group' && nextScene.status === 'denied' && parsed.isAdmin) {
+      const allowedScene = {
+        ...nextScene,
+        status: 'allowed',
+      } satisfies BncrSceneRecord;
+      sceneRegistry.set(sceneKey, allowedScene);
+      return {
+        allowed: true,
+        scene: allowedScene,
+        agentId: allowedScene.agentId || defaultPublicAgentId,
+      };
+    }
+
+    sceneRegistry.set(sceneKey, nextScene);
+
+    if (nextScene.status === 'allowed') {
+      const fallbackAgentId =
+        kind === 'group'
+          ? defaultPublicAgentId
+          : parsed.isAdmin
+            ? defaultAdminAgentId
+            : defaultPublicAgentId;
+      return {
+        allowed: true,
+        scene: nextScene,
+        agentId: nextScene.agentId || fallbackAgentId,
+      };
+    }
+
+    return {
+      allowed: false,
+      scene: nextScene,
+      reason: nextScene.status === 'pending' ? 'scene pending approval' : 'scene denied',
+      replyPolicy:
+        kind === 'group' ? 'silent' : nextScene.status === 'pending' ? 'pending' : 'silent',
+    };
+  }
+
+  if (parsed.isAdmin) {
+    const agentId = kind === 'group' ? defaultPublicAgentId : defaultAdminAgentId;
+    const scene = buildSceneRecord({
+      parsed,
+      sceneKey,
+      kind,
+      status: 'allowed',
+      agentId,
+      lastSeenAt: now,
+    });
+    sceneRegistry.set(sceneKey, scene);
+    return { allowed: true, scene, agentId };
+  }
+
+  const directNonAdminAllowed = kind === 'direct';
+  const scene = buildSceneRecord({
+    parsed,
+    sceneKey,
+    kind,
+    status: directNonAdminAllowed ? 'allowed' : 'denied',
+    agentId: directNonAdminAllowed ? defaultPublicAgentId : undefined,
+    lastSeenAt: now,
+  });
+  sceneRegistry.set(sceneKey, scene);
+
+  if (directNonAdminAllowed) {
+    return {
+      allowed: true,
+      scene,
+      agentId: scene.agentId || defaultPublicAgentId,
+    };
+  }
+
+  return {
+    allowed: false,
+    scene,
+    reason: 'scene denied',
+    replyPolicy: 'silent',
+  };
+}

package/src/plugin/state-store.ts

@@ -8,16 +8,25 @@ import {
   writeOpenClawJsonFileAtomically,
 } from '../openclaw/sdk-helpers.ts';
 import type {
+  BncrGroupReplyMode,
   BncrPersistedAccountTimestamp,
+  BncrPersistedGroupHistoryBucket,
+  BncrPersistedGroupHistoryEntry,
+  BncrPersistedGroupHistoryMediaEntry,
   BncrPersistedLastSession,
   BncrPersistedSessionRoute,
   PersistedState as BncrPersistedState,
+  BncrSceneRecord,
 } from './channel-runtime-types.ts';
 
+const GROUP_REPLY_MODES = new Set<BncrGroupReplyMode>(['admin', 'mention', 'hybrid', 'all']);
+
 type BncrPersistedStateStoreInput = {
   outbox?: unknown;
   deadLetter?: unknown;
   sessionRoutes?: unknown;
+  sceneRegistry?: unknown;
+  groupHistories?: unknown;
   lastSessionByAccount?: unknown;
   lastActivityByAccount?: unknown;
   lastInboundByAccount?: unknown;
@@ -28,6 +37,9 @@ type BncrPersistedStateStoreInput = {
 type PersistedAccountTimestampInput = Partial<BncrPersistedAccountTimestamp>;
 type PersistedLastSessionInput = Partial<BncrPersistedLastSession>;
 type PersistedSessionRouteInput = Partial<BncrPersistedSessionRoute>;
+type PersistedSceneRecordInput = Partial<BncrSceneRecord>;
+type PersistedGroupHistoryBucketInput = Partial<BncrPersistedGroupHistoryBucket>;
+type PersistedGroupHistoryEntryInput = Partial<BncrPersistedGroupHistoryEntry>;
 
 export function createBncrStateStore(runtime: {
   getStatePath: () => string | null;
@@ -50,6 +62,8 @@ export function createBncrStateStore(runtime: {
   maxDeadLetterEntries: number;
   maxSessionRouteEntries: number;
   maxAccountActivityEntries: number;
+  sceneRegistry: Map<string, BncrSceneRecord>;
+  groupHistories: Map<string, BncrPersistedGroupHistoryEntry[]>;
   outbox: Map<string, OutboxEntry>;
   getDeadLetter: () => OutboxEntry[];
   setDeadLetter: (entries: OutboxEntry[]) => void;
@@ -62,6 +76,117 @@ export function createBncrStateStore(runtime: {
   getLastDriftSnapshot: () => BncrPersistedState['lastDriftSnapshot'];
   setLastDriftSnapshot: (value: BncrPersistedState['lastDriftSnapshot']) => void;
 }) {
+  function loadPersistedSceneRegistry(persisted: unknown): void {
+    runtime.sceneRegistry.clear();
+    const items = Array.isArray(persisted) ? (persisted as PersistedSceneRecordInput[]) : [];
+    for (const item of items) {
+      if (!item || typeof item !== 'object') continue;
+      const sceneKey = runtime.asString(item.sceneKey || '').trim();
+      const kind = runtime.asString(item.kind || '').trim();
+      const status = runtime.asString(item.status || '').trim();
+      const platform = runtime.asString(item.platform || '').trim();
+      const lastSeenAt = runtime.finiteNumberOr(item.lastSeenAt, 0);
+      if (!sceneKey || !platform || lastSeenAt <= 0) continue;
+      if (kind !== 'direct' && kind !== 'group') continue;
+      if (status !== 'pending' && status !== 'allowed' && status !== 'denied') continue;
+
+      runtime.sceneRegistry.set(sceneKey, {
+        sceneKey,
+        kind,
+        status,
+        platform,
+        ...(runtime.asString(item.userId || '').trim()
+          ? { userId: runtime.asString(item.userId || '').trim() }
+          : {}),
+        ...(runtime.asString(item.userName || '').trim()
+          ? { userName: runtime.asString(item.userName || '').trim() }
+          : {}),
+        ...(runtime.asString(item.groupId || '').trim()
+          ? { groupId: runtime.asString(item.groupId || '').trim() }
+          : {}),
+        ...(runtime.asString(item.groupName || '').trim()
+          ? { groupName: runtime.asString(item.groupName || '').trim() }
+          : {}),
+        ...(runtime.asString(item.agentId || '').trim()
+          ? { agentId: runtime.asString(item.agentId || '').trim() }
+          : {}),
+        ...(kind === 'group' &&
+        GROUP_REPLY_MODES.has(
+          runtime.asString(item.groupReplyMode || '').trim() as BncrGroupReplyMode,
+        )
+          ? {
+              groupReplyMode: runtime
+                .asString(item.groupReplyMode || '')
+                .trim() as BncrGroupReplyMode,
+            }
+          : {}),
+        lastSeenAt,
+      });
+    }
+  }
+
+  function dumpPersistedSceneRegistry() {
+    return Array.from(runtime.sceneRegistry.values()).sort((a, b) => a.lastSeenAt - b.lastSeenAt);
+  }
+
+  function loadPersistedGroupHistories(persisted: unknown): void {
+    runtime.groupHistories.clear();
+    const buckets = Array.isArray(persisted)
+      ? (persisted as PersistedGroupHistoryBucketInput[])
+      : [];
+    for (const bucket of buckets) {
+      const key = runtime.asString(bucket?.key || '').trim();
+      if (!key) continue;
+      const entries: BncrPersistedGroupHistoryEntry[] = [];
+      const rawEntries = Array.isArray(bucket?.entries)
+        ? (bucket.entries as PersistedGroupHistoryEntryInput[])
+        : [];
+      for (const entry of rawEntries) {
+        const sender = runtime.asString(entry?.sender || '').trim();
+        const body = runtime.asString(entry?.body || '').trim();
+        if (!sender || !body) continue;
+        const timestamp = runtime.finiteNumberOr(entry?.timestamp, 0);
+        const messageId = runtime.asString(entry?.messageId || '').trim();
+
+        const media: BncrPersistedGroupHistoryMediaEntry[] = [];
+        const rawMedia = Array.isArray(entry?.media)
+          ? (entry.media as Partial<BncrPersistedGroupHistoryMediaEntry>[])
+          : [];
+        for (const item of rawMedia) {
+          const path = runtime.asString(item?.path || '').trim();
+          if (!path) continue;
+          const contentType = runtime.asString(item?.contentType || '').trim();
+          const kind = runtime.asString(item?.kind || '').trim();
+          const mediaMessageId = runtime.asString(item?.messageId || '').trim();
+          const normalizedMedia: BncrPersistedGroupHistoryMediaEntry = {
+            path,
+            ...(contentType ? { contentType } : {}),
+            ...(kind ? { kind: kind as BncrPersistedGroupHistoryMediaEntry['kind'] } : {}),
+            ...(mediaMessageId ? { messageId: mediaMessageId } : {}),
+          };
+          media.push(normalizedMedia);
+        }
+
+        const normalizedEntry: BncrPersistedGroupHistoryEntry = {
+          sender,
+          body,
+          ...(timestamp > 0 ? { timestamp } : {}),
+          ...(messageId ? { messageId } : {}),
+          ...(media.length > 0 ? { media } : {}),
+        };
+        entries.push(normalizedEntry);
+      }
+      if (entries.length > 0) runtime.groupHistories.set(key, entries.slice(-50));
+    }
+  }
+
+  function dumpPersistedGroupHistories() {
+    return Array.from(runtime.groupHistories.entries()).map(([key, entries]) => ({
+      key,
+      entries: entries.slice(-50),
+    }));
+  }
+
   function loadPersistedAccountTimestampMap(target: Map<string, number>, persisted: unknown): void {
     target.clear();
     const items = Array.isArray(persisted)
@@ -208,6 +333,8 @@ export function createBncrStateStore(runtime: {
     runtime.setDeadLetter(deadLetter);
 
     loadPersistedSessionRoutes(data.sessionRoutes);
+    loadPersistedSceneRegistry(data.sceneRegistry);
+    loadPersistedGroupHistories(data.groupHistories);
     loadPersistedLastSessionMap(data.lastSessionByAccount);
     loadPersistedAccountTimestampMap(runtime.lastActivityByAccount, data.lastActivityByAccount);
     loadPersistedAccountTimestampMap(runtime.lastInboundByAccount, data.lastInboundByAccount);
@@ -225,6 +352,8 @@ export function createBncrStateStore(runtime: {
       outbox: Array.from(runtime.outbox.values()),
       deadLetter: runtime.getDeadLetter().slice(-runtime.maxDeadLetterEntries),
       sessionRoutes: dumpPersistedSessionRoutes(),
+      sceneRegistry: dumpPersistedSceneRegistry(),
+      groupHistories: dumpPersistedGroupHistories(),
       lastSessionByAccount: dumpPersistedLastSessionMap(),
       lastActivityByAccount: dumpPersistedAccountTimestampMap(runtime.lastActivityByAccount),
       lastInboundByAccount: dumpPersistedAccountTimestampMap(runtime.lastInboundByAccount),
@@ -242,6 +371,10 @@ export function createBncrStateStore(runtime: {
     dumpPersistedLastSessionMap,
     loadPersistedSessionRoutes,
     dumpPersistedSessionRoutes,
+    loadPersistedSceneRegistry,
+    dumpPersistedSceneRegistry,
+    loadPersistedGroupHistories,
+    dumpPersistedGroupHistories,
     backfillAccountActivityFromSessionRoutes,
     loadState,
     flushState,

package/src/plugin/state-transient-runtime-group.ts

@@ -6,6 +6,7 @@ import type {
   FileSendTransferState,
   OutboxEntry,
 } from '../core/types.ts';
+import type { BncrPersistedGroupHistoryEntry, BncrSceneRecord } from './channel-runtime-types.ts';
 import { createBncrStateStore } from './state-store.ts';
 import { createBncrTransientStateRuntime } from './transient-state-runtime.ts';
 
@@ -31,6 +32,8 @@ export function createBncrStateTransientRuntimeGroup(runtime: {
   maxDeadLetterEntries: number;
   maxSessionRouteEntries: number;
   maxAccountActivityEntries: number;
+  sceneRegistry: Map<string, BncrSceneRecord>;
+  groupHistories: Map<string, BncrPersistedGroupHistoryEntry[]>;
   outbox: Map<string, OutboxEntry>;
   getDeadLetter: () => OutboxEntry[];
   setDeadLetter: (entries: OutboxEntry[]) => void;
@@ -69,6 +72,8 @@ export function createBncrStateTransientRuntimeGroup(runtime: {
     maxDeadLetterEntries: runtime.maxDeadLetterEntries,
     maxSessionRouteEntries: runtime.maxSessionRouteEntries,
     maxAccountActivityEntries: runtime.maxAccountActivityEntries,
+    sceneRegistry: runtime.sceneRegistry,
+    groupHistories: runtime.groupHistories,
     outbox: runtime.outbox,
     getDeadLetter: runtime.getDeadLetter,
     setDeadLetter: runtime.setDeadLetter,

package/src/plugin/target-runtime.ts

@@ -95,11 +95,11 @@ export function createBncrTargetRuntime(runtime: {
     if (!route) {
       runtime.logWarn(
         'target',
-        `invalid raw=${raw} accountId=${acc} reason=unparseable-or-unknown standardTo=Bncr:<platform>:<groupId>:<userId>|Bncr:<platform>:<userId> standardSessionKey=agent:<agentId>:bncr:direct:<hex(scope)>`,
+        `invalid raw=${raw} accountId=${acc} reason=unparseable-or-unknown canonicalTo=Bncr:<platform>:0:<userId>|Bncr:<platform>:<groupId>:0 acceptedAliases=Bncr:<platform>:user:<userId>|Bncr:<platform>:group:<groupId> standardSessionKey=agent:<agentId>:bncr:<direct|group>:<hex(scope)>`,
         { debugOnly: true },
       );
       throw new Error(
-        `bncr invalid target(standard: Bncr:<platform>:<groupId>:<userId> | Bncr:<platform>:<userId>): ${raw}`,
+        `bncr invalid target(canonical: Bncr:<platform>:0:<userId> | Bncr:<platform>:<groupId>:0; aliases: Bncr:<platform>:user:<userId> | Bncr:<platform>:group:<groupId>): ${raw}`,
       );
     }