@xmoxmo/bncr 0.4.5 → 0.4.7

package/src/messaging/inbound/commands.ts

@@ -20,7 +20,12 @@ import type {
 } from './contracts.ts';
 import type { ParsedInbound } from './dispatch-prep.ts';
 import { buildBncrInboundRecordUpdateLastRoute } from './last-route.ts';
-import { parseBncrNativeCommand, resolveBncrNativeVerboseCommand } from './native-command.ts';
+import {
+  parseBncrNativeCommand,
+  resolveBncrNativeHelpCommand,
+  resolveBncrNativeVerboseCommand,
+  resolveBncrNativeWhoamiCommand,
+} from './native-command.ts';
 import {
   buildBncrNativeCommandSessionState,
   buildBncrNativeCommandSummary,
@@ -34,11 +39,13 @@ import {
 } from './native-command-runtime.ts';
 import { buildBncrReplyConfig } from './reply-config.ts';
 import { resolveBncrChannelInboundRuntime } from './runtime-compat.ts';
+import { executeSceneAdminCommand, parseSceneAdminCommand } from './scene-admin.ts';
 import {
   buildBncrInboundSessionIdentityPatch,
   recordAndPatchBncrInboundSessionEntry,
   wrapBncrInboundRecordSessionLabelCorrection,
 } from './session-label.ts';
+import { createBncrSessionMetaTaskBarrier } from './session-meta-task.ts';
 
 function assertResolvedAgentRoute(resolvedRoute: OpenClawResolvedAgentRoute): {
   sessionKey: string;
@@ -65,8 +72,9 @@ function buildBncrNativeCommandResolvedRoute(args: {
   channelId: string;
   accountId: string;
   peer: ParsedInbound['peer'];
+  resolvedAgentId?: string;
 }) {
-  return assertResolvedAgentRoute(
+  const resolvedRoute = assertResolvedAgentRoute(
     resolveOpenClawAgentRoute(args.api, {
       cfg: args.cfg,
       channel: args.channelId,
@@ -74,6 +82,14 @@ function buildBncrNativeCommandResolvedRoute(args: {
       peer: args.peer,
     }),
   );
+
+  const agentId = (args.resolvedAgentId || '').trim() || resolvedRoute.agentId;
+  if (!agentId || agentId === resolvedRoute.agentId) return resolvedRoute;
+
+  return {
+    ...resolvedRoute,
+    agentId,
+  };
 }
 
 export { parseBncrNativeCommand } from './native-command.ts';
@@ -84,6 +100,11 @@ export async function handleBncrNativeCommand(params: {
   cfg: BncrInboundConfig;
   parsed: ParsedInbound;
   canonicalAgentId: string;
+  resolvedAgentId?: string;
+  sceneRegistry: Map<string, import('../../plugin/channel-runtime-types.ts').BncrSceneRecord>;
+  defaultAdminAgentId: string;
+  defaultPublicAgentId: string;
+  now: () => number;
   rememberSessionRoute: BncrRememberSessionRoute;
   enqueueFromReply: BncrEnqueueFromReply;
   logger?: BncrInboundLogger;
@@ -91,10 +112,24 @@ export async function handleBncrNativeCommand(params: {
   | { handled: false }
   | { handled: true; command: string; sessionKey: string; fallbackToAgent?: boolean }
 > {
-  const { api, channelId, cfg, parsed, canonicalAgentId, rememberSessionRoute, enqueueFromReply } =
-    params;
+  const {
+    api,
+    channelId,
+    cfg,
+    parsed,
+    canonicalAgentId,
+    resolvedAgentId,
+    sceneRegistry,
+    defaultAdminAgentId,
+    defaultPublicAgentId,
+    now,
+    rememberSessionRoute,
+    enqueueFromReply,
+  } = params;
   const { accountId, route, peer, clientId, extracted, msgId } = parsed;
-  const command = parseBncrNativeCommand(extracted.text);
+  const command = parseBncrNativeCommand(extracted.text, {
+    allowBareWhoami: parsed.isAdmin !== true,
+  });
   if (!command) return { handled: false };
   const nativeCommandDebugEnabled = resolveNativeCommandDebugEnabled({ cfg, channelId });
 
@@ -115,12 +150,13 @@ export async function handleBncrNativeCommand(params: {
     channelId,
     accountId,
     peer,
+    resolvedAgentId,
   });
 
   const { baseSessionKey, taskSessionKey, sessionKey, displayTo, originatingTo } =
     buildBncrNativeCommandSessionState({
       parsed,
-      canonicalAgentId,
+      sessionAgentId: resolvedRoute.agentId || canonicalAgentId,
       resolvedRoute,
     });
   rememberSessionRoute(baseSessionKey, accountId, route);
@@ -133,8 +169,8 @@ export async function handleBncrNativeCommand(params: {
       '[bncr] inbound missing clientId for native command identity; using route identity fallback',
     );
   }
-  const senderIdForContext = clientId || displayTo;
-  const senderDisplayName = clientId ? 'bncr-client' : displayTo;
+  const senderIdForContext = parsed.userId || clientId || displayTo;
+  const senderDisplayName = parsed.userName || displayTo;
   const storePath = resolveBncrInboundSessionStorePath({
     storeConfig: cfg?.session?.store,
     agentId: resolvedRoute.agentId,
@@ -166,7 +202,108 @@ export async function handleBncrNativeCommand(params: {
   });
 
   const nativeVerbose = resolveBncrNativeVerboseCommand(command);
+  const nativeHelp = resolveBncrNativeHelpCommand(command);
+  const nativeWhoami = resolveBncrNativeWhoamiCommand({
+    command,
+    platform: parsed.platform,
+    groupId: parsed.groupId,
+    groupName: parsed.groupName,
+    userId: parsed.userId,
+    userName: parsed.userName,
+    isGroup: parsed.isGroup,
+    isAdmin: parsed.isAdmin,
+  });
+  if (nativeHelp) {
+    logBncrNativeCommandSummary(
+      buildBncrNativeCommandSummary({
+        kind: 'help',
+        command: command.command,
+        accountId,
+        to: displayTo,
+        msgId: msgId || null,
+        result: 'handled',
+      }),
+    );
+    await recordAndPatchBncrInboundSessionEntry({
+      storePath,
+      sessionKey,
+      ctx: ctxPayload,
+      patch: sessionIdentityPatch,
+    });
+    rememberSessionRoute(baseSessionKey, accountId, route);
+    await enqueueFromReply({
+      accountId,
+      sessionKey,
+      route,
+      payload: {
+        text: nativeHelp.text,
+        replyToId: msgId || undefined,
+      },
+    });
+    return { handled: true, command: command.command, sessionKey };
+  }
+
+  if (nativeWhoami) {
+    logBncrNativeCommandSummary(
+      buildBncrNativeCommandSummary({
+        kind: 'whoami',
+        command: command.command,
+        accountId,
+        to: displayTo,
+        msgId: msgId || null,
+        result: 'handled',
+      }),
+    );
+    await recordAndPatchBncrInboundSessionEntry({
+      storePath,
+      sessionKey,
+      ctx: ctxPayload,
+      patch: sessionIdentityPatch,
+    });
+    rememberSessionRoute(baseSessionKey, accountId, route);
+    await enqueueFromReply({
+      accountId,
+      sessionKey,
+      route,
+      payload: {
+        text: nativeWhoami.text,
+        replyToId: msgId || undefined,
+      },
+    });
+    return { handled: true, command: command.command, sessionKey };
+  }
+
   if (nativeVerbose) {
+    if (!parsed.isAdmin) {
+      logBncrNativeCommandSummary(
+        buildBncrNativeCommandSummary({
+          kind: 'verbose',
+          command: command.command,
+          accountId,
+          to: displayTo,
+          msgId: msgId || null,
+          result: 'rejected',
+        }),
+      );
+      await recordAndPatchBncrInboundSessionEntry({
+        storePath,
+        sessionKey,
+        ctx: ctxPayload,
+        patch: sessionIdentityPatch,
+      });
+      rememberSessionRoute(baseSessionKey, accountId, route);
+      await enqueueFromReply({
+        accountId,
+        sessionKey,
+        route,
+        payload: {
+          text: 'Admin permission required.',
+          replyToId: msgId || undefined,
+        },
+      });
+      return { handled: true, command: command.command, sessionKey };
+    }
+
     logBncrNativeCommandSummary(
       buildBncrNativeCommandSummary({
         kind: 'verbose',
@@ -211,6 +348,73 @@ export async function handleBncrNativeCommand(params: {
     return { handled: true, command: command.command, sessionKey };
   }
 
+  const sceneAdmin = parseSceneAdminCommand(command);
+  if (sceneAdmin.matched) {
+    if (!sceneAdmin.valid) {
+      logBncrNativeCommandSummary(
+        buildBncrNativeCommandSummary({
+          kind: 'scene-admin',
+          command: command.command,
+          accountId,
+          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 };
+    }
+
+    const outcome = executeSceneAdminCommand({
+      parsed,
+      command: sceneAdmin.command,
+      sceneRegistry,
+      defaultAdminAgentId,
+      defaultPublicAgentId,
+      now,
+    });
+    logBncrNativeCommandSummary(
+      buildBncrNativeCommandSummary({
+        kind: 'scene-admin',
+        command: command.command,
+        accountId,
+        to: displayTo,
+        msgId: msgId ?? null,
+        result: outcome.ok ? 'handled' : 'rejected',
+      }),
+    );
+    await recordAndPatchBncrInboundSessionEntry({
+      storePath,
+      sessionKey,
+      ctx: ctxPayload,
+      patch: sessionIdentityPatch,
+    });
+    await enqueueFromReply({
+      accountId,
+      sessionKey,
+      route,
+      payload: {
+        text: outcome.text,
+        replyToId: msgId || undefined,
+      },
+    });
+    return { handled: true, command: command.command, sessionKey };
+  }
+
   await recordAndPatchBncrInboundSessionEntry({
     storePath,
     sessionKey,
@@ -264,51 +468,59 @@ export async function handleBncrNativeCommand(params: {
         textForCommands: ctxPayload.CommandBody,
         raw: parsed,
       }),
-      resolveTurn: () => ({
-        channel: channelId,
-        accountId,
-        routeSessionKey: resolvedRoute.sessionKey,
-        storePath,
-        ctxPayload,
-        recordInboundSession: wrapBncrInboundRecordSessionLabelCorrection({
-          recordInboundSession: recordBncrInboundSession as (
-            ...args: unknown[]
-          ) => Promise<unknown> | unknown,
-          expectedLabel: displayTo,
-        }),
-        record: {
-          updateLastRoute,
-          onRecordError: (err: unknown) => {
-            buildNativeCommandRecordErrorLogger(err);
-          },
-        },
-        runDispatch: () =>
-          dispatchOpenClawReplyWithBufferedBlockDispatcher(api, {
-            ctx: ctxPayload,
-            cfg: effectiveReply.replyCfg,
-            dispatcherOptions: {
-              deliver: createNativeCommandReplyDeliverer({
-                command: command.command,
-                accountId,
-                sessionKey,
-                to: displayTo,
-                msgId: msgId || undefined,
-                effectiveReply,
-                route,
-                enqueueFromReply,
-                nativeCommandDebugEnabled,
-                onResponded: () => responded,
-                markResponded: () => {
-                  responded = true;
-                },
-              }),
+      resolveTurn: () => {
+        const sessionMetaBarrier = createBncrSessionMetaTaskBarrier();
+        return {
+          channel: channelId,
+          accountId,
+          routeSessionKey: resolvedRoute.sessionKey,
+          storePath,
+          ctxPayload,
+          recordInboundSession: wrapBncrInboundRecordSessionLabelCorrection({
+            recordInboundSession: recordBncrInboundSession as (
+              ...args: unknown[]
+            ) => Promise<unknown> | unknown,
+            expectedPatch: sessionIdentityPatch,
+          }),
+          record: {
+            updateLastRoute,
+            onRecordError: (err: unknown) => {
+              buildNativeCommandRecordErrorLogger(err);
             },
-            replyOptions: {
-              disableBlockStreaming: !effectiveReply.blockStreaming,
-              shouldEmitToolResult: effectiveReply.allowTool ? () => true : undefined,
+            trackSessionMetaTask: (task: Promise<unknown>) => {
+              sessionMetaBarrier.track(task);
             },
-          }),
-      }),
+          },
+          runDispatch: async () => {
+            await sessionMetaBarrier.wait();
+            return dispatchOpenClawReplyWithBufferedBlockDispatcher(api, {
+              ctx: ctxPayload,
+              cfg: effectiveReply.replyCfg,
+              dispatcherOptions: {
+                deliver: createNativeCommandReplyDeliverer({
+                  command: command.command,
+                  accountId,
+                  sessionKey,
+                  to: displayTo,
+                  msgId: msgId || undefined,
+                  effectiveReply,
+                  route,
+                  enqueueFromReply,
+                  nativeCommandDebugEnabled,
+                  onResponded: () => responded,
+                  markResponded: () => {
+                    responded = true;
+                  },
+                }),
+              },
+              replyOptions: {
+                disableBlockStreaming: !effectiveReply.blockStreaming,
+                shouldEmitToolResult: effectiveReply.allowTool ? () => true : undefined,
+              },
+            });
+          },
+        };
+      },
     },
   });
 

package/src/messaging/inbound/context-facts.ts

@@ -19,6 +19,27 @@ export type BncrStructuredContextFactsInput = {
   sender: {
     id: string;
     displayName?: string;
+    userId?: string;
+    userName?: string;
+    bridgeId?: string;
+    bridgeName?: string;
+    isAdmin?: boolean;
+    isOwner?: boolean;
+    isAuthorizedSender?: boolean;
+    role?: 'owner' | 'admin' | 'user';
+  };
+  platform?: string;
+  group?: {
+    id?: string;
+    name?: string;
+    isGroup?: boolean;
+  };
+  trigger?: {
+    shouldRespond?: boolean;
+    triggerKind?: string;
+    botName?: string;
+    isBotMentioned?: boolean;
+    isReplyToBot?: boolean;
   };
   message: {
     id?: string | null;
@@ -60,6 +81,27 @@ export function buildBncrStructuredContextFacts(input: BncrStructuredContextFact
     sender: {
       id: input.sender.id,
       displayName: input.sender.displayName || input.sender.id,
+      userId: input.sender.userId,
+      userName: input.sender.userName,
+      bridgeId: input.sender.bridgeId,
+      bridgeName: input.sender.bridgeName,
+      isAdmin: input.sender.isAdmin,
+      ...(input.sender.isOwner === true ? { isOwner: true } : {}),
+      ...(input.sender.isAuthorizedSender === true ? { isAuthorizedSender: true } : {}),
+      ...(input.sender.role !== undefined ? { role: input.sender.role } : {}),
+    },
+    platform: input.platform,
+    group: {
+      id: input.group?.id,
+      name: input.group?.name,
+      isGroup: input.group?.isGroup,
+    },
+    trigger: {
+      shouldRespond: input.trigger?.shouldRespond,
+      triggerKind: input.trigger?.triggerKind,
+      botName: input.trigger?.botName,
+      isBotMentioned: input.trigger?.isBotMentioned,
+      isReplyToBot: input.trigger?.isReplyToBot,
     },
     message: {
       id: input.message.id || undefined,
@@ -85,6 +127,15 @@ export function buildBncrPromptVisibleContextFacts(
   facts: ReturnType<typeof buildBncrStructuredContextFacts>,
 ) {
   const result: {
+    trigger?: {
+      botName?: string;
+    };
+    sender?: {
+      isAdmin?: boolean;
+      isOwner?: boolean;
+      isAuthorizedSender?: boolean;
+      role?: 'owner' | 'admin' | 'user';
+    };
     reply?: {
       to: string;
       originatingTo: string;
@@ -96,6 +147,30 @@ export function buildBncrPromptVisibleContextFacts(
     }>;
   } = {};
 
+  if (
+    facts.sender.isAdmin === true ||
+    facts.sender.isOwner === true ||
+    facts.sender.isAuthorizedSender === true ||
+    facts.sender.role === 'owner' ||
+    facts.sender.role === 'admin'
+  ) {
+    const sender = {
+      ...(facts.sender.isAdmin === true ? { isAdmin: true } : {}),
+      ...(facts.sender.isOwner === true ? { isOwner: true } : {}),
+      ...(facts.sender.isAuthorizedSender === true ? { isAuthorizedSender: true } : {}),
+      ...(facts.sender.role === 'owner' || facts.sender.role === 'admin'
+        ? { role: facts.sender.role }
+        : {}),
+    };
+    if (Object.keys(sender).length > 0) result.sender = sender;
+  }
+
+  if (facts.trigger.botName) {
+    result.trigger = {
+      botName: facts.trigger.botName,
+    };
+  }
+
   if (facts.reply.originatingTo !== facts.reply.to) {
     result.reply = {
       to: facts.reply.to,
@@ -125,11 +200,25 @@ export type BncrStructuredContextFactsFromInboundPartsInput = {
   channelId: string;
   parsed: {
     accountId: string;
+    platform?: string;
     peer: {
       kind: string;
       id: string;
     };
     clientId?: string;
+    bridgeId?: string;
+    bridgeName?: string;
+    groupId?: string;
+    groupName?: string;
+    userId?: string;
+    userName?: string;
+    isGroup?: boolean;
+    isAdmin?: boolean;
+    shouldRespond?: boolean;
+    triggerKind?: string;
+    botName?: string;
+    isBotMentioned?: boolean;
+    isReplyToBot?: boolean;
     msgId?: string;
     mimeType?: string;
   };
@@ -147,18 +236,24 @@ export type BncrStructuredContextFactsFromInboundPartsInput = {
   prepared: {
     rawBody: string;
     body?: string;
-    mediaPath?: string | null;
-    mediaContentType?: string;
+    mediaItems?: Array<{
+      path: string;
+      contentType?: string;
+      kind?: string;
+    }>;
   };
   senderIdForContext: string;
   senderDisplayName?: string;
+  bridgeSenderId?: string;
+  bridgeSenderName?: string;
+  senderIsOwner?: boolean;
+  senderIsAuthorized?: boolean;
 };
 
 export function buildBncrStructuredContextFactsFromInboundParts(
   input: BncrStructuredContextFactsFromInboundPartsInput,
 ) {
-  const mediaPath = input.prepared.mediaPath || undefined;
-  const mediaContentType = input.prepared.mediaContentType || input.parsed.mimeType;
+  const mediaItems = Array.isArray(input.prepared.mediaItems) ? input.prepared.mediaItems : [];
   return buildBncrStructuredContextFacts({
     channelId: input.channelId,
     accountId: input.parsed.accountId,
@@ -180,6 +275,27 @@ export function buildBncrStructuredContextFactsFromInboundParts(
     sender: {
       id: input.senderIdForContext,
       displayName: input.senderDisplayName,
+      userId: input.parsed.userId,
+      userName: input.parsed.userName,
+      bridgeId: input.bridgeSenderId || input.parsed.bridgeId || input.parsed.clientId,
+      bridgeName: input.bridgeSenderName || input.parsed.bridgeName,
+      isAdmin: input.parsed.isAdmin,
+      isOwner: input.senderIsOwner === true ? true : undefined,
+      isAuthorizedSender: input.senderIsAuthorized === true ? true : undefined,
+      role: input.senderIsOwner ? 'owner' : input.parsed.isAdmin ? 'admin' : undefined,
+    },
+    platform: input.parsed.platform,
+    group: {
+      id: input.parsed.groupId,
+      name: input.parsed.groupName,
+      isGroup: input.parsed.isGroup,
+    },
+    trigger: {
+      shouldRespond: input.parsed.shouldRespond,
+      triggerKind: input.parsed.triggerKind,
+      botName: input.parsed.botName,
+      isBotMentioned: input.parsed.isBotMentioned,
+      isReplyToBot: input.parsed.isReplyToBot,
     },
     message: {
       id: input.parsed.msgId,
@@ -188,15 +304,11 @@ export function buildBncrStructuredContextFactsFromInboundParts(
       commandBody: input.prepared.rawBody,
       envelopeBody: input.prepared.body,
     },
-    media: mediaPath
-      ? [
-          {
-            path: mediaPath,
-            contentType: mediaContentType,
-            kind: inferBncrStructuredMediaKind(mediaContentType),
-            messageId: input.parsed.msgId,
-          },
-        ]
-      : [],
+    media: mediaItems.map((item) => ({
+      path: item.path,
+      contentType: item.contentType,
+      kind: item.kind || inferBncrStructuredMediaKind(item.contentType),
+      messageId: input.parsed.msgId,
+    })),
   });
 }

package/src/messaging/inbound/contracts.ts

@@ -15,21 +15,45 @@ export type BncrInboundParsedPeer = OpenClawChannelPeer;
 
 export type BncrInboundParamsInput = {
   accountId?: unknown;
+  protocolVersion?: unknown;
+  capabilities?: unknown;
   platform?: unknown;
   groupId?: unknown;
+  groupName?: unknown;
   userId?: unknown;
+  userName?: unknown;
   sessionKey?: unknown;
   originatingTo?: unknown;
   providedOriginatingTo?: unknown;
   to?: unknown;
   clientId?: unknown;
+  bridgeId?: unknown;
+  bridgeName?: unknown;
+  isGroup?: unknown;
+  isAdmin?: unknown;
   msg?: unknown;
   type?: unknown;
   base64?: unknown;
   path?: unknown;
+  paths?: unknown;
+  mediaList?: unknown;
   mimeType?: unknown;
   fileName?: unknown;
   msgId?: unknown;
+  shouldRespond?: unknown;
+  triggerKind?: unknown;
+  botName?: unknown;
+  isBotMentioned?: unknown;
+  isReplyToBot?: unknown;
+};
+
+export type BncrInboundMediaItem = {
+  path?: string;
+  base64?: string;
+  mimeType?: string;
+  fileName?: string;
+  type?: string;
+  transferId?: string;
 };
 
 export type BncrRememberSessionRoute = (