@xmoxmo/bncr 0.0.4 → 0.0.5

package/src/messaging/inbound/commands.ts

@@ -0,0 +1,136 @@
+import { formatDisplayScope, normalizeInboundSessionKey, withTaskSessionKey } from '../../core/targets.js';
+
+type ParsedInbound = ReturnType<typeof import('./parse.js')['parseBncrInboundParams']>;
+
+type NativeCommand = {
+  command: string;
+  raw: string;
+  body: string;
+};
+
+export function parseBncrNativeCommand(text: string): NativeCommand | null {
+  const raw = String(text || '').trim();
+  if (!raw.startsWith('/')) return null;
+  const match = raw.match(/^\/([^\s]+)(?:\s+([\s\S]*))?$/i);
+  if (!match) return null;
+
+  const command = String(match[1] || '').trim().toLowerCase();
+  if (!command) return null;
+
+  const rest = String(match[2] || '').trim();
+  const body = command === 'help'
+    ? ['/commands', rest].filter(Boolean).join(' ')
+    : raw;
+  return { command, raw, body };
+}
+
+export async function handleBncrNativeCommand(params: {
+  api: any;
+  channelId: string;
+  cfg: any;
+  parsed: ParsedInbound;
+  rememberSessionRoute: (sessionKey: string, accountId: string, route: any) => void;
+  enqueueFromReply: (args: {
+    accountId: string;
+    sessionKey: string;
+    route: any;
+    payload: { text?: string; mediaUrl?: string; mediaUrls?: string[] };
+    mediaLocalRoots?: readonly string[];
+  }) => Promise<void>;
+  logger?: { warn?: (msg: string) => void; error?: (msg: string) => void };
+}): Promise<{ handled: false } | { handled: true; command: string; sessionKey: string }> {
+  const { api, channelId, cfg, parsed, rememberSessionRoute, enqueueFromReply, logger } = params;
+  const { accountId, route, peer, sessionKeyfromroute, clientId, extracted, msgId } = parsed;
+  const command = parseBncrNativeCommand(extracted.text);
+  if (!command) return { handled: false };
+
+  const resolvedRoute = api.runtime.channel.routing.resolveAgentRoute({
+    cfg,
+    channel: channelId,
+    accountId,
+    peer,
+  });
+
+  const baseSessionKey = normalizeInboundSessionKey(sessionKeyfromroute, route) || resolvedRoute.sessionKey;
+  const taskSessionKey = withTaskSessionKey(baseSessionKey, extracted.taskKey);
+  const sessionKey = taskSessionKey || baseSessionKey;
+  rememberSessionRoute(baseSessionKey, accountId, route);
+  if (taskSessionKey && taskSessionKey !== baseSessionKey) rememberSessionRoute(taskSessionKey, accountId, route);
+
+  const displayTo = formatDisplayScope(route);
+  const body = command.body;
+  if (!clientId) {
+    logger?.warn?.('bncr: missing clientId for inbound command identity');
+    return { handled: false };
+  }
+  const senderIdForContext = clientId;
+  const senderDisplayName = 'bncr-client';
+  const storePath = api.runtime.channel.session.resolveStorePath(cfg?.session?.store, {
+    agentId: resolvedRoute.agentId,
+  });
+
+  const ctxPayload = api.runtime.channel.reply.finalizeInboundContext({
+    Body: body,
+    BodyForAgent: body,
+    RawBody: body,
+    CommandBody: body,
+    BodyForCommands: body,
+    From: senderIdForContext,
+    To: displayTo,
+    SessionKey: sessionKey,
+    CommandTargetSessionKey: sessionKey,
+    CommandSource: 'native',
+    CommandAuthorized: true,
+    AccountId: accountId,
+    ChatType: peer.kind,
+    ConversationLabel: displayTo,
+    SenderId: senderIdForContext,
+    SenderName: senderDisplayName,
+    SenderUsername: senderDisplayName,
+    Provider: channelId,
+    Surface: channelId,
+    WasMentioned: true,
+    MessageSid: msgId,
+    Timestamp: Date.now(),
+    OriginatingChannel: channelId,
+    OriginatingTo: displayTo,
+  });
+
+  await api.runtime.channel.session.recordInboundSession({
+    storePath,
+    sessionKey,
+    ctx: ctxPayload,
+    onRecordError: (err: unknown) => {
+      logger?.warn?.(`bncr: record native command session failed: ${String(err)}`);
+    },
+  });
+
+  let responded = false;
+  await api.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+    ctx: ctxPayload,
+    cfg,
+    replyOptions: {
+      disableBlockStreaming: true,
+    },
+    dispatcherOptions: {
+      deliver: async (payload: { text?: string; mediaUrl?: string; mediaUrls?: string[] }, info?: { kind?: 'tool' | 'block' | 'final' }) => {
+        if (info?.kind && info.kind !== 'final') return;
+        const hasPayload = Boolean(payload?.text || payload?.mediaUrl || (Array.isArray(payload?.mediaUrls) && payload.mediaUrls.length > 0));
+        if (!hasPayload) return;
+        responded = true;
+        await enqueueFromReply({
+          accountId,
+          sessionKey,
+          route,
+          payload,
+        });
+      },
+    },
+  });
+
+  if (!responded) {
+    return { handled: false };
+  }
+
+  return { handled: true, command: command.command, sessionKey };
+}

package/src/messaging/inbound/dispatch.ts

@@ -0,0 +1,178 @@
+import fs from 'node:fs';
+import { formatDisplayScope, normalizeInboundSessionKey, withTaskSessionKey } from '../../core/targets.js';
+import { handleBncrNativeCommand } from './commands.js';
+
+type ParsedInbound = ReturnType<typeof import('./parse.js')['parseBncrInboundParams']>;
+
+export async function dispatchBncrInbound(params: {
+  api: any;
+  channelId: string;
+  cfg: any;
+  parsed: ParsedInbound;
+  rememberSessionRoute: (sessionKey: string, accountId: string, route: any) => void;
+  enqueueFromReply: (args: {
+    accountId: string;
+    sessionKey: string;
+    route: any;
+    payload: { text?: string; mediaUrl?: string; mediaUrls?: string[] };
+    mediaLocalRoots?: readonly string[];
+  }) => Promise<void>;
+  setInboundActivity: (accountId: string, at: number) => void;
+  scheduleSave: () => void;
+  logger?: { warn?: (msg: string) => void; error?: (msg: string) => void };
+}) {
+  const { api, channelId, cfg, parsed, rememberSessionRoute, enqueueFromReply, setInboundActivity, scheduleSave, logger } = params;
+  const { accountId, route, peer, sessionKeyfromroute, clientId, text, msgType, mediaBase64, mediaPathFromTransfer, mimeType, fileName, msgId, extracted, platform, groupId, userId } = parsed;
+
+  const nativeCommand = await handleBncrNativeCommand({
+    api,
+    channelId,
+    cfg,
+    parsed,
+    rememberSessionRoute,
+    enqueueFromReply,
+    logger,
+  });
+  if (nativeCommand.handled) {
+    const inboundAt = Date.now();
+    setInboundActivity(accountId, inboundAt);
+    scheduleSave();
+    return {
+      accountId,
+      sessionKey: nativeCommand.sessionKey,
+      taskKey: extracted.taskKey ?? null,
+      msgId: msgId ?? null,
+    };
+  }
+
+  const resolvedRoute = api.runtime.channel.routing.resolveAgentRoute({
+    cfg,
+    channel: channelId,
+    accountId,
+    peer,
+  });
+
+  const baseSessionKey = normalizeInboundSessionKey(sessionKeyfromroute, route) || resolvedRoute.sessionKey;
+  const agentText = extracted.text;
+  const taskSessionKey = withTaskSessionKey(baseSessionKey, extracted.taskKey);
+  const sessionKey = taskSessionKey || baseSessionKey;
+
+  rememberSessionRoute(baseSessionKey, accountId, route);
+  if (taskSessionKey && taskSessionKey !== baseSessionKey) {
+    rememberSessionRoute(taskSessionKey, accountId, route);
+  }
+
+  const storePath = api.runtime.channel.session.resolveStorePath(cfg?.session?.store, {
+    agentId: resolvedRoute.agentId,
+  });
+
+  let mediaPath: string | undefined;
+  if (mediaBase64) {
+    const mediaBuf = Buffer.from(mediaBase64, 'base64');
+    const saved = await api.runtime.channel.media.saveMediaBuffer(
+      mediaBuf,
+      mimeType,
+      'inbound',
+      30 * 1024 * 1024,
+      fileName,
+    );
+    mediaPath = saved.path;
+  } else if (mediaPathFromTransfer && fs.existsSync(mediaPathFromTransfer)) {
+    mediaPath = mediaPathFromTransfer;
+  }
+
+  const rawBody = agentText || (msgType === 'text' ? '' : `[${msgType}]`);
+  const body = api.runtime.channel.reply.formatAgentEnvelope({
+    channel: 'Bncr',
+    from: `${platform}:${groupId}:${userId}`,
+    timestamp: Date.now(),
+    previousTimestamp: api.runtime.channel.session.readSessionUpdatedAt({
+      storePath,
+      sessionKey,
+    }),
+    envelope: api.runtime.channel.reply.resolveEnvelopeFormatOptions(cfg),
+    body: rawBody,
+  });
+
+  const displayTo = formatDisplayScope(route);
+  if (!clientId) {
+    logger?.warn?.('bncr: missing clientId for inbound chat identity');
+    return {
+      accountId,
+      sessionKey,
+      taskKey: extracted.taskKey ?? null,
+      msgId: msgId ?? null,
+    };
+  }
+  const senderIdForContext = clientId;
+  const senderDisplayName = 'bncr-client';
+  const ctxPayload = api.runtime.channel.reply.finalizeInboundContext({
+    Body: body,
+    BodyForAgent: rawBody,
+    RawBody: rawBody,
+    CommandBody: rawBody,
+    MediaPath: mediaPath,
+    MediaType: mimeType,
+    From: senderIdForContext,
+    To: displayTo,
+    SessionKey: sessionKey,
+    AccountId: accountId,
+    ChatType: peer.kind,
+    ConversationLabel: displayTo,
+    SenderId: senderIdForContext,
+    SenderName: senderDisplayName,
+    SenderUsername: senderDisplayName,
+    Provider: channelId,
+    Surface: channelId,
+    MessageSid: msgId,
+    Timestamp: Date.now(),
+    OriginatingChannel: channelId,
+    OriginatingTo: displayTo,
+  });
+
+  await api.runtime.channel.session.recordInboundSession({
+    storePath,
+    sessionKey,
+    ctx: ctxPayload,
+    onRecordError: (err: unknown) => {
+      logger?.warn?.(`bncr: record session failed: ${String(err)}`);
+    },
+  });
+
+  const inboundAt = Date.now();
+  setInboundActivity(accountId, inboundAt);
+  scheduleSave();
+
+  await api.runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+    ctx: ctxPayload,
+    cfg,
+    replyOptions: {
+      disableBlockStreaming: true,
+    },
+    dispatcherOptions: {
+      deliver: async (
+        payload: { text?: string; mediaUrl?: string; mediaUrls?: string[] },
+        info?: { kind?: 'tool' | 'block' | 'final' },
+      ) => {
+        if (info?.kind && info.kind !== 'final') return;
+
+        await enqueueFromReply({
+          accountId,
+          sessionKey,
+          route,
+          payload,
+        });
+      },
+      onError: (err: unknown) => {
+        logger?.error?.(`bncr reply failed: ${String(err)}`);
+      },
+    },
+  });
+
+  return {
+    accountId,
+    sessionKey,
+    taskKey: extracted.taskKey ?? null,
+    msgId: msgId ?? null,
+  };
+}

package/src/messaging/inbound/gate.ts

@@ -0,0 +1,66 @@
+import { normalizeAccountId } from '../../core/accounts.js';
+import { resolveBncrChannelPolicy } from '../../core/policy.js';
+import { buildDisplayScopeCandidates } from '../../core/targets.js';
+
+export type BncrGateResult =
+  | { allowed: true }
+  | { allowed: false; reason: string };
+
+function asString(v: unknown, fallback = ''): string {
+  if (typeof v === 'string') return v;
+  if (v == null) return fallback;
+  return String(v);
+}
+
+function matchesAllowList(list: string[], candidates: string[]): boolean {
+  if (!list.length) return false;
+  const normalized = new Set(list.map((x) => asString(x).trim()).filter(Boolean));
+  return candidates.some((x) => normalized.has(asString(x).trim()));
+}
+
+export function checkBncrMessageGate(params: {
+  parsed: any;
+  cfg: any;
+  account: { accountId: string; enabled?: boolean };
+}): BncrGateResult {
+  const { parsed, cfg, account } = params;
+  const accountId = normalizeAccountId(account?.accountId);
+  const channelCfg = cfg?.channels?.bncr || {};
+  const accountCfg = channelCfg?.accounts?.[accountId] || {};
+  const policy = resolveBncrChannelPolicy(channelCfg);
+
+  if (policy.enabled === false || account?.enabled === false || accountCfg?.enabled === false) {
+    return { allowed: false, reason: 'account disabled' };
+  }
+
+  const route = parsed?.route;
+  const isGroup = asString(route?.groupId || '0') !== '0';
+
+  if (!isGroup && policy.dmPolicy === 'disabled') {
+    return { allowed: false, reason: 'dm disabled' };
+  }
+
+  if (isGroup && policy.groupPolicy === 'disabled') {
+    return { allowed: false, reason: 'group disabled' };
+  }
+
+  const candidates = buildDisplayScopeCandidates(route);
+
+  if (!isGroup && policy.dmPolicy === 'allowlist') {
+    if (!matchesAllowList(policy.allowFrom, candidates)) {
+      return { allowed: false, reason: 'dm allowlist blocked' };
+    }
+  }
+
+  if (isGroup && policy.groupPolicy === 'allowlist') {
+    if (!matchesAllowList(policy.groupAllowFrom, candidates)) {
+      return { allowed: false, reason: 'group allowlist blocked' };
+    }
+  }
+
+  // requireMention 默认值为 false。
+  // 设计目标：当它未来真正生效时，含义是“群消息只有在明确提到机器人时才允许进入处理链”。
+  // 但当前 parse 层尚未稳定提取 mentions，上游客户端也未统一透传 mention 信号，
+  // 因此现阶段即使配置为 true，也仍不做实际拦截，避免出现半实现状态。
+  return { allowed: true };
+}

package/src/messaging/inbound/parse.ts

@@ -0,0 +1,97 @@
+import { createHash } from 'node:crypto';
+import { normalizeAccountId } from '../../core/accounts.js';
+import type { BncrRoute } from '../../core/types.js';
+import { extractInlineTaskKey } from '../../core/targets.js';
+
+function asString(v: unknown, fallback = ''): string {
+  if (typeof v === 'string') return v;
+  if (v == null) return fallback;
+  return String(v);
+}
+
+export function inboundDedupKey(params: {
+  accountId: string;
+  platform: string;
+  groupId: string;
+  userId: string;
+  msgId?: string;
+  text?: string;
+  mediaBase64?: string;
+}): string {
+  const accountId = normalizeAccountId(params.accountId);
+  const platform = asString(params.platform).trim().toLowerCase();
+  const groupId = asString(params.groupId).trim();
+  const userId = asString(params.userId).trim();
+  const msgId = asString(params.msgId || '').trim();
+
+  if (msgId) return `${accountId}|${platform}|${groupId}|${userId}|msg:${msgId}`;
+
+  const text = asString(params.text || '').trim();
+  const media = asString(params.mediaBase64 || '');
+  const digest = createHash('sha1').update(`${text}\n${media.slice(0, 256)}`).digest('hex').slice(0, 16);
+  return `${accountId}|${platform}|${groupId}|${userId}|hash:${digest}`;
+}
+
+export function resolveChatType(_route: BncrRoute): 'direct' | 'group' {
+  return 'direct';
+}
+
+export function parseBncrInboundParams(params: any) {
+  const accountId = normalizeAccountId(asString(params?.accountId || ''));
+  const platform = asString(params?.platform || '').trim();
+  const groupId = asString(params?.groupId || '0').trim() || '0';
+  const userId = asString(params?.userId || '').trim();
+  const sessionKeyfromroute = asString(params?.sessionKey || '').trim();
+  const clientId = asString(params?.clientId || '').trim() || undefined;
+
+  const route: BncrRoute = {
+    platform,
+    groupId,
+    userId,
+  };
+
+  const text = asString(params?.msg || '');
+  const msgType = asString(params?.type || 'text') || 'text';
+  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 dedupKey = inboundDedupKey({
+    accountId,
+    platform,
+    groupId,
+    userId,
+    msgId,
+    text,
+    mediaBase64,
+  });
+
+  const peer = {
+    kind: resolveChatType(route),
+    id: route.groupId === '0' ? route.userId : route.groupId,
+  } as const;
+
+  const extracted = extractInlineTaskKey(text);
+
+  return {
+    accountId,
+    platform,
+    groupId,
+    userId,
+    sessionKeyfromroute,
+    clientId,
+    route,
+    text,
+    msgType,
+    mediaBase64,
+    mediaPathFromTransfer,
+    mimeType,
+    fileName,
+    msgId,
+    dedupKey,
+    peer,
+    extracted,
+  };
+}

package/src/messaging/outbound/actions.ts

@@ -0,0 +1,42 @@
+export async function sendBncrReplyAction(params: {
+  accountId: string;
+  to: string;
+  text: string;
+  replyToMessageId?: string;
+  sendText: (params: {
+    accountId: string;
+    to: string;
+    text: string;
+    replyToMessageId?: string;
+  }) => Promise<any>;
+}) {
+  return params.sendText({
+    accountId: params.accountId,
+    to: params.to,
+    text: params.text,
+    replyToMessageId: params.replyToMessageId,
+  });
+}
+
+export async function deleteBncrMessageAction(_params: {
+  accountId: string;
+  targetMessageId: string;
+}) {
+  return { ok: false, unsupported: true, reason: 'delete not implemented yet' };
+}
+
+export async function reactBncrMessageAction(_params: {
+  accountId: string;
+  targetMessageId: string;
+  emoji: string;
+}) {
+  return { ok: false, unsupported: true, reason: 'react not implemented yet' };
+}
+
+export async function editBncrMessageAction(_params: {
+  accountId: string;
+  targetMessageId: string;
+  text: string;
+}) {
+  return { ok: false, unsupported: true, reason: 'edit not implemented yet' };
+}

package/src/messaging/outbound/media.ts

@@ -0,0 +1,53 @@
+function asString(v: unknown, fallback = ''): string {
+  if (typeof v === 'string') return v;
+  if (v == null) return fallback;
+  return String(v);
+}
+
+export function resolveBncrOutboundMessageType(params: { mimeType?: string; fileName?: string; hintedType?: string; hasPayload?: boolean }): 'text' | 'image' | 'video' | 'voice' | 'audio' | 'file' {
+  const hinted = asString(params.hintedType || '').toLowerCase();
+  const hasPayload = !!params.hasPayload;
+  const mt = asString(params.mimeType || '').toLowerCase();
+  const major = mt.split('/')[0] || '';
+  const isStandard = hinted === 'text' || hinted === 'image' || hinted === 'video' || hinted === 'voice' || hinted === 'audio' || hinted === 'file';
+
+  if (hasPayload && major === 'text' && (hinted === 'text' || !isStandard)) return 'file';
+  if (isStandard) return hinted as any;
+  if (major === 'text' || major === 'image' || major === 'video' || major === 'audio') return major as any;
+  return 'file';
+}
+
+export function buildBncrMediaOutboundFrame(params: {
+  messageId: string;
+  sessionKey: string;
+  route: { platform: string; groupId: string; userId: string };
+  media: { mode: 'base64' | 'chunk'; mimeType?: string; fileName?: string; mediaBase64?: string; path?: string };
+  mediaUrl: string;
+  mediaMsg: string;
+  fileName: string;
+  now: number;
+}) {
+  return {
+    type: 'message.outbound',
+    messageId: params.messageId,
+    idempotencyKey: params.messageId,
+    sessionKey: params.sessionKey,
+    message: {
+      platform: params.route.platform,
+      groupId: params.route.groupId,
+      userId: params.route.userId,
+      type: resolveBncrOutboundMessageType({
+        mimeType: params.media.mimeType,
+        fileName: params.media.fileName,
+        hasPayload: !!(params.media.path || params.media.mediaBase64),
+      }),
+      mimeType: params.media.mimeType || '',
+      msg: params.mediaMsg,
+      path: params.media.path || params.mediaUrl,
+      base64: params.media.mediaBase64 || '',
+      fileName: params.fileName,
+      transferMode: params.media.mode,
+    },
+    ts: params.now,
+  };
+}

package/src/messaging/outbound/send.ts

@@ -0,0 +1,67 @@
+export async function sendBncrText(params: {
+  channelId: string;
+  accountId: string;
+  to: string;
+  text: string;
+  mediaLocalRoots?: readonly string[];
+  resolveVerifiedTarget: (to: string, accountId: string) => { sessionKey: string; route: any; displayScope: string };
+  rememberSessionRoute: (sessionKey: string, accountId: string, route: any) => void;
+  enqueueFromReply: (args: {
+    accountId: string;
+    sessionKey: string;
+    route: any;
+    payload: { text?: string; mediaUrl?: string; mediaUrls?: string[] };
+    mediaLocalRoots?: readonly string[];
+  }) => Promise<void>;
+  createMessageId: () => string;
+}) {
+  const verified = params.resolveVerifiedTarget(params.to, params.accountId);
+  params.rememberSessionRoute(verified.sessionKey, params.accountId, verified.route);
+
+  await params.enqueueFromReply({
+    accountId: params.accountId,
+    sessionKey: verified.sessionKey,
+    route: verified.route,
+    payload: {
+      text: params.text,
+    },
+    mediaLocalRoots: params.mediaLocalRoots,
+  });
+
+  return { channel: params.channelId, messageId: params.createMessageId(), chatId: verified.sessionKey };
+}
+
+export async function sendBncrMedia(params: {
+  channelId: string;
+  accountId: string;
+  to: string;
+  text?: string;
+  mediaUrl?: string;
+  mediaLocalRoots?: readonly string[];
+  resolveVerifiedTarget: (to: string, accountId: string) => { sessionKey: string; route: any; displayScope: string };
+  rememberSessionRoute: (sessionKey: string, accountId: string, route: any) => void;
+  enqueueFromReply: (args: {
+    accountId: string;
+    sessionKey: string;
+    route: any;
+    payload: { text?: string; mediaUrl?: string; mediaUrls?: string[] };
+    mediaLocalRoots?: readonly string[];
+  }) => Promise<void>;
+  createMessageId: () => string;
+}) {
+  const verified = params.resolveVerifiedTarget(params.to, params.accountId);
+  params.rememberSessionRoute(verified.sessionKey, params.accountId, verified.route);
+
+  await params.enqueueFromReply({
+    accountId: params.accountId,
+    sessionKey: verified.sessionKey,
+    route: verified.route,
+    payload: {
+      text: params.text || '',
+      mediaUrl: params.mediaUrl || '',
+    },
+    mediaLocalRoots: params.mediaLocalRoots,
+  });
+
+  return { channel: params.channelId, messageId: params.createMessageId(), chatId: verified.sessionKey };
+}