@xmoxmo/bncr 0.4.6 → 0.4.8

package/src/messaging/inbound/native-command.ts

@@ -2,6 +2,13 @@ export type NativeCommand = {
   command: string;
   raw: string;
   body: string;
+  argsText: string;
+};
+
+export type ParseBncrNativeCommandOptions = {
+  allowBareWhoami?: boolean;
+  allowBareStatus?: boolean;
+  allowBareSessionReset?: boolean;
 };
 
 export type NativeVerboseCommand = {
@@ -10,27 +17,204 @@ export type NativeVerboseCommand = {
   text: string;
 };
 
-export function parseBncrNativeCommand(text: string): NativeCommand | null {
+export type NativeHelpCommand = {
+  handled: true;
+  text: string;
+};
+
+export type NativeWhoamiCommand = {
+  handled: true;
+  text: string;
+};
+
+export type NativeStatusCommand = {
+  handled: true;
+  text: string;
+};
+
+export type NativeSessionResetCommand = {
+  handled: true;
+  reason: 'new' | 'reset';
+  text: string;
+};
+
+const BNCR_HELP_TEXT = [
+  '🦞 Bncr command usage',
+  '',
+  '📌 Bncr builtins',
+  '  • /bncr whoami',
+  '  • /bncr verbose on|off|full',
+  '',
+  '🛡 Scene approval',
+  '  • /bncr allow [<SceneId>]',
+  '  • /bncr deny [<SceneId>]',
+  '  • /bncr bind <agentId> [<SceneId>]',
+  '  • /bncr mode',
+  '  • /bncr mode help',
+  '  • /bncr mode <admin|mention|hybrid|all> [<SceneId>]',
+  '  • /bncr revoke [<SceneId>]',
+  '  • /bncr list pending',
+  '  • /bncr list scenes',
+].join('\n');
+
+const BNCR_NATIVE_COMMANDS = new Set([
+  'help',
+  'new',
+  'reset',
+  'status',
+  'whoami',
+  'verbose',
+  'allow',
+  'deny',
+  'bind',
+  'mode',
+  'revoke',
+  'list',
+]);
+
+export const BNCR_DIRECT_ALLOWED_BARE_COMMANDS = new Set(['whoami', 'status', 'new', 'reset']);
+
+export const BNCR_DIRECT_ALLOWED_SUBCOMMANDS = new Set([
+  'help',
+  'whoami',
+  'status',
+  'new',
+  'reset',
+]);
+
+export function parseBncrNativeCommand(
+  text: string,
+  options?: ParseBncrNativeCommandOptions,
+): NativeCommand | null {
   const raw = String(text || '').trim();
-  if (!raw.startsWith('/')) return null;
-  const match = raw.match(/^\/([^\s]+)(?:\s+([\s\S]*))?$/i);
+  const allowBareWhoami = options?.allowBareWhoami !== false;
+  const allowBareStatus = options?.allowBareStatus === true;
+  const allowBareSessionReset = options?.allowBareSessionReset === true;
+  if (allowBareSessionReset && raw.toLowerCase() === '/new') {
+    return { command: 'new', raw, body: '/new', argsText: '' };
+  }
+  if (allowBareSessionReset && raw.toLowerCase() === '/reset') {
+    return { command: 'reset', raw, body: '/reset', argsText: '' };
+  }
+  if (allowBareStatus && raw.toLowerCase() === '/status') {
+    return { command: 'status', raw, body: '/status', argsText: '' };
+  }
+  if (allowBareWhoami && raw.toLowerCase() === '/whoami') {
+    return { command: 'whoami', raw, body: '/whoami', argsText: '' };
+  }
+  if (!raw.startsWith('/bncr')) return null;
+  const match = raw.match(/^\/bncr(?:@[A-Za-z0-9_]+)?(?:\s+([^\s]+)(?:\s+([\s\S]*))?)?$/i);
   if (!match) return null;
 
-  const command = String(match[1] || '')
+  const command = String(match[1] || 'help')
     .trim()
     .toLowerCase();
   if (!command) return null;
+  if (!BNCR_NATIVE_COMMANDS.has(command)) return null;
+
+  const argsText = String(match[2] || '').trim();
+  const body =
+    command === 'help' ? '/commands' : [`/${command}`, argsText].filter(Boolean).join(' ');
+  return { command, raw, body, argsText };
+}
+
+export function parseBncrUnsupportedDirectCommand(text: string): {
+  command: string;
+  raw: string;
+} | null {
+  const raw = String(text || '').trim();
+  if (!raw.startsWith('/')) return null;
+
+  const bareMatch = raw.match(/^\/([A-Za-z0-9_]+)(?:@[A-Za-z0-9_]+)?(?:\s+.*)?$/);
+  if (!bareMatch) return null;
+  const bareCommand = String(bareMatch[1] || '')
+    .trim()
+    .toLowerCase();
+  if (!bareCommand) return null;
+
+  if (bareCommand === 'bncr') {
+    const subMatch = raw.match(/^\/bncr(?:@[A-Za-z0-9_]+)?(?:\s+([A-Za-z0-9_-]+))?/i);
+    const subCommand =
+      String(subMatch?.[1] || '')
+        .trim()
+        .toLowerCase() || 'help';
+    if (BNCR_DIRECT_ALLOWED_SUBCOMMANDS.has(subCommand)) return null;
+    return { command: `bncr ${subCommand}`, raw };
+  }
 
-  const rest = String(match[2] || '').trim();
-  const body = command === 'help' ? ['/commands', rest].filter(Boolean).join(' ') : raw;
-  return { command, raw, body };
+  if (BNCR_DIRECT_ALLOWED_BARE_COMMANDS.has(bareCommand)) return null;
+  return { command: bareCommand, raw };
+}
+
+export function resolveBncrNativeHelpCommand(command: NativeCommand): NativeHelpCommand | null {
+  if (command.command !== 'help') return null;
+  return { handled: true, text: BNCR_HELP_TEXT };
+}
+
+export function resolveBncrNativeWhoamiCommand(args: {
+  command: NativeCommand;
+  platform: string;
+  groupId: string;
+  groupName?: string;
+  userId: string;
+  userName?: string;
+  isGroup: boolean;
+  isAdmin: boolean;
+}): NativeWhoamiCommand | null {
+  if (args.command.command !== 'whoami') return null;
+  const lines = ['🧭 Bncr Identity', ''];
+  lines.push(`Platform: ${args.platform || '(unknown)'}`);
+  lines.push(`User: ${args.userName || '(unknown)'} (${args.userId || '0'})`);
+  if (args.isGroup) {
+    lines.push(`Group: ${args.groupName || '(unknown)'} (${args.groupId || '0'})`);
+    lines.push(`Scene: ${args.platform || '(unknown)'}:${args.groupId || '0'}`);
+  } else {
+    lines.push(`Scene: ${args.platform || '(unknown)'}:${args.userId || '0'}`);
+  }
+  lines.push(`Admin: ${args.isAdmin ? 'true' : 'false'}`);
+  return { handled: true, text: lines.join('\n') };
+}
+
+export function resolveBncrNativeStatusCommand(args: {
+  command: NativeCommand;
+  accountId: string;
+  platform: string;
+  userId: string;
+  userName?: string;
+  resolvedAgentId: string;
+  sessionKey: string;
+}): NativeStatusCommand | null {
+  if (args.command.command !== 'status') return null;
+  const lines = ['🦞 Bncr Status', ''];
+  lines.push(`Channel: bncr`);
+  lines.push(`Account: ${args.accountId || 'Primary'}`);
+  lines.push(`User: ${args.userName || '(unknown)'} (${args.userId || '0'})`);
+  lines.push(`Scene: ${args.platform || '(unknown)'}:${args.userId || '0'}`);
+  lines.push(`Agent: ${args.resolvedAgentId || '(unknown)'}`);
+  lines.push(`SessionKey: ${args.sessionKey || '(unknown)'}`);
+  return { handled: true, text: lines.join('\n') };
+}
+
+export function resolveBncrNativeSessionResetCommand(args: {
+  command: NativeCommand;
+}): NativeSessionResetCommand | null {
+  if (args.command.command !== 'new' && args.command.command !== 'reset') return null;
+  const reason = args.command.command === 'new' ? 'new' : 'reset';
+  return {
+    handled: true,
+    reason,
+    text:
+      reason === 'new'
+        ? 'Started a new session for this private chat.'
+        : 'Reset the current session for this private chat.',
+  };
 }
 
 export function resolveBncrNativeVerboseCommand(
   command: NativeCommand,
 ): NativeVerboseCommand | null {
   if (command.command !== 'verbose') return null;
-  const rawLevel = String(command.raw.slice('/verbose'.length) || '')
+  const rawLevel = String(command.argsText || '')
     .trim()
     .toLowerCase();
   if (!rawLevel || rawLevel === 'status') {

package/src/messaging/inbound/parse.ts

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import { normalizeAccountId } from '../../core/accounts.ts';
 import { extractInlineTaskKey } from '../../core/targets.ts';
 import type { BncrRoute } from '../../core/types.ts';
-import type { BncrInboundParamsInput } from './contracts.ts';
+import type { BncrInboundMediaItem, BncrInboundParamsInput } from './contracts.ts';
 
 function asString(v: unknown, fallback = ''): string {
   if (typeof v === 'string') return v;
@@ -10,6 +10,84 @@ function asString(v: unknown, fallback = ''): string {
   return String(v);
 }
 
+function asBoolean(v: unknown, fallback = false): boolean {
+  if (typeof v === 'boolean') return v;
+  if (typeof v === 'number') return v !== 0;
+  if (typeof v === 'string') {
+    const raw = v.trim().toLowerCase();
+    if (!raw) return fallback;
+    if (['true', '1', 'yes', 'y', 'on'].includes(raw)) return true;
+    if (['false', '0', 'no', 'n', 'off'].includes(raw)) return false;
+  }
+  return fallback;
+}
+
+function asStringArray(v: unknown): string[] {
+  if (Array.isArray(v)) {
+    return v.map((item) => asString(item).trim()).filter(Boolean);
+  }
+  if (typeof v === 'string') {
+    return v
+      .split(',')
+      .map((item) => item.trim())
+      .filter(Boolean);
+  }
+  return [];
+}
+
+function asInboundMediaItems(params: BncrInboundParamsInput): BncrInboundMediaItem[] {
+  const normalized: BncrInboundMediaItem[] = [];
+  const rawList = Array.isArray(params?.mediaList) ? params.mediaList : [];
+  for (const item of rawList) {
+    if (!item || typeof item !== 'object') continue;
+    const path = asString((item as { path?: unknown }).path || '').trim();
+    const base64 = asString((item as { base64?: unknown }).base64 || '').trim();
+    const mimeType = asString((item as { mimeType?: unknown }).mimeType || '').trim();
+    const fileName = asString((item as { fileName?: unknown }).fileName || '').trim();
+    const type = asString((item as { type?: unknown }).type || '').trim();
+    const transferId = asString((item as { transferId?: unknown }).transferId || '').trim();
+    if (!path && !base64) continue;
+    normalized.push({
+      ...(path ? { path } : {}),
+      ...(base64 ? { base64 } : {}),
+      ...(mimeType ? { mimeType } : {}),
+      ...(fileName ? { fileName } : {}),
+      ...(type ? { type } : {}),
+      ...(transferId ? { transferId } : {}),
+    });
+  }
+
+  if (normalized.length > 0) return normalized;
+
+  const legacyPath = asString(params?.path || '').trim();
+  const legacyBase64 = asString(params?.base64 || '').trim();
+  const legacyMimeType = asString(params?.mimeType || '').trim();
+  const legacyFileName = asString(params?.fileName || '').trim();
+  const legacyType = asString(params?.type || '').trim();
+  const legacyTransferId = asString((params as { transferId?: unknown })?.transferId || '').trim();
+  if (legacyPath || legacyBase64) {
+    return [
+      {
+        ...(legacyPath ? { path: legacyPath } : {}),
+        ...(legacyBase64 ? { base64: legacyBase64 } : {}),
+        ...(legacyMimeType ? { mimeType: legacyMimeType } : {}),
+        ...(legacyFileName ? { fileName: legacyFileName } : {}),
+        ...(legacyType ? { type: legacyType } : {}),
+        ...(legacyTransferId ? { transferId: legacyTransferId } : {}),
+      },
+    ];
+  }
+
+  const legacyPaths = asStringArray(params?.paths);
+  return legacyPaths.map((item) => ({
+    path: item,
+    ...(legacyMimeType ? { mimeType: legacyMimeType } : {}),
+    ...(legacyFileName ? { fileName: legacyFileName } : {}),
+    ...(legacyType ? { type: legacyType } : {}),
+    ...(legacyTransferId ? { transferId: legacyTransferId } : {}),
+  }));
+}
+
 export function inboundDedupKey(params: {
   accountId: string;
   platform: string;
@@ -36,24 +114,30 @@ export function inboundDedupKey(params: {
   return `${accountId}|${platform}|${groupId}|${userId}|hash:${digest}`;
 }
 
-export function resolveChatType(_route: BncrRoute): 'direct' | 'group' {
-  // Compatibility boundary: bncr currently records and dispatches all conversations as direct
-  // sessions even when the display scope contains a group id. Do not change this to true
-  // group semantics without updating session routing, reply target policy, and requireMention
-  // behavior together.
+export function resolveChatType(route: BncrRoute, isGroup: boolean): 'direct' | 'group' {
+  if (isGroup) return 'group';
+  if (route.groupId !== '0') return 'group';
   return 'direct';
 }
 
 export function parseBncrInboundParams(params: BncrInboundParamsInput) {
   const accountId = normalizeAccountId(asString(params?.accountId || ''));
+  const protocolVersion = asString(params?.protocolVersion || '').trim() || undefined;
+  const capabilities = asStringArray(params?.capabilities);
   const platform = asString(params?.platform || '').trim();
   const groupId = asString(params?.groupId || '0').trim() || '0';
+  const groupName = asString(params?.groupName || '').trim();
   const userId = asString(params?.userId || '').trim();
+  const userName = asString(params?.userName || '').trim();
   const sessionKeyfromroute = asString(params?.sessionKey || '').trim();
   const providedOriginatingTo =
     asString(params?.originatingTo || params?.providedOriginatingTo || params?.to || '').trim() ||
     undefined;
   const clientId = asString(params?.clientId || '').trim() || undefined;
+  const bridgeId = asString(params?.bridgeId || params?.clientId || '').trim() || undefined;
+  const bridgeName = asString(params?.bridgeName || 'Bncr').trim() || 'Bncr';
+  const isGroup = asBoolean(params?.isGroup, groupId !== '0');
+  const isAdmin = asBoolean(params?.isAdmin, false);
 
   const route: BncrRoute = {
     platform,
@@ -63,11 +147,17 @@ export function parseBncrInboundParams(params: BncrInboundParamsInput) {
 
   const text = asString(params?.msg || '');
   const msgType = asString(params?.type || 'text') || 'text';
+  const mediaItems = asInboundMediaItems(params);
   const mediaBase64 = asString(params?.base64 || '');
   const mediaPathFromTransfer = asString(params?.path || '').trim();
   const mimeType = asString(params?.mimeType || '').trim() || undefined;
   const fileName = asString(params?.fileName || '').trim() || undefined;
   const msgId = asString(params?.msgId || '').trim() || undefined;
+  const shouldRespond = asBoolean(params?.shouldRespond, false);
+  const triggerKind = asString(params?.triggerKind || 'none').trim() || 'none';
+  const botName = asString(params?.botName || '').trim();
+  const isBotMentioned = asBoolean(params?.isBotMentioned, false);
+  const isReplyToBot = asBoolean(params?.isReplyToBot, false);
 
   const dedupKey = inboundDedupKey({
     accountId,
@@ -79,29 +169,44 @@ export function parseBncrInboundParams(params: BncrInboundParamsInput) {
     mediaBase64,
   });
 
+  const peerKind = resolveChatType(route, isGroup);
   const peer = {
-    kind: resolveChatType(route),
-    id: route.groupId === '0' ? route.userId : route.groupId,
+    kind: peerKind,
+    id: peerKind === 'group' ? route.groupId : route.userId,
   } as const;
 
   const extracted = extractInlineTaskKey(text);
 
   return {
     accountId,
+    protocolVersion,
+    capabilities,
     platform,
     groupId,
+    groupName,
     userId,
+    userName,
     sessionKeyfromroute,
     providedOriginatingTo,
     clientId,
+    bridgeId,
+    bridgeName,
+    isGroup,
+    isAdmin,
     route,
     text,
     msgType,
+    mediaItems,
     mediaBase64,
     mediaPathFromTransfer,
     mimeType,
     fileName,
     msgId,
+    shouldRespond,
+    triggerKind,
+    botName,
+    isBotMentioned,
+    isReplyToBot,
     dedupKey,
     peer,
     extracted,

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();
+}