@xmoxmo/bncr 0.3.6 → 0.3.8

package/src/plugin/inbound-handlers.ts

@@ -0,0 +1,248 @@
+import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
+import type { BncrConnection, BncrRoute } from '../core/types.ts';
+import type { parseBncrInboundParams } from '../messaging/inbound/parse.ts';
+import type {
+  buildInboundResponsePayload,
+  resolveInboundSessionContext,
+} from './channel-inbound-helpers.ts';
+import type { BncrChannelConfigRoot } from './channel-runtime-types.ts';
+import { buildBncrGatewayEventContext } from './gateway-event-context.ts';
+
+type InboundLifecycleStage = 'accepted';
+type LeaseEventKind =
+  | 'inbound'
+  | 'activity'
+  | 'ack'
+  | 'file.init'
+  | 'file.chunk'
+  | 'file.complete'
+  | 'file.abort';
+type InboundResponseArgs =
+  | { kind: 'stale-ignored'; accountId: string; msgId?: string | null }
+  | {
+      kind: 'accepted';
+      accountId: string;
+      sessionKey: string;
+      msgId?: string | null;
+      taskKey?: string | null;
+    }
+  | { kind: 'invalid-peer' }
+  | { kind: 'invalid-session'; accountId: string; msgId?: string | null };
+
+type ParsedInboundParams = ReturnType<typeof parseBncrInboundParams>;
+type InboundResponsePayload = ReturnType<typeof buildInboundResponsePayload>;
+type EnsureCanonicalAgentIdPeer = Parameters<typeof resolveInboundSessionContext>[0]['peer'];
+type InboundAcceptanceResult =
+  | {
+      ok: true;
+      accountId?: string;
+      sessionKey: string;
+      inboundText: string;
+      hasMedia: boolean;
+    }
+  | {
+      ok: false;
+      status: boolean;
+      payload: Record<string, unknown>;
+    };
+
+export type BncrInboundHandlersRuntime = {
+  channelId: string;
+  bridgeId: string;
+  asString: (value: unknown, fallback?: string) => string;
+  now: () => number;
+  syncDebugFlag: () => Promise<void>;
+  parseInboundParams: (params: unknown) => ParsedInboundParams;
+  shouldIgnoreStaleEvent: (args: {
+    kind: LeaseEventKind;
+    payload: { leaseId?: string; connectionEpoch?: number };
+    accountId: string;
+    connId: string;
+    clientId?: string;
+  }) => boolean;
+  buildInboundResponsePayload: (args: InboundResponseArgs) => InboundResponsePayload;
+  refreshLiveConnectionState: (args: {
+    accountId: string;
+    connId: string;
+    clientId?: string;
+    outboundReady: boolean;
+    preferredForOutbound: boolean;
+    inboundOnly: boolean;
+    context: GatewayRequestHandlerOptions['context'];
+  }) => void;
+  logInfo: (scope: string, message: string, options?: { debugOnly?: boolean }) => void;
+  logError: (scope: string, message: string, options?: { debugOnly?: boolean }) => void;
+  buildInboundAcceptedLifecycleDebugInfo: (args: {
+    stage: InboundLifecycleStage;
+    bridge: string;
+    accountId: string;
+    connId: string;
+    clientId?: string;
+    outboundReady: boolean;
+    preferredForOutbound: boolean;
+    inboundOnly: boolean;
+    onlineAfterSeen: boolean;
+    recentInboundReachable: boolean;
+    activeConnectionKey: string | null;
+    activeConnections: BncrConnection[];
+  }) => Record<string, unknown>;
+  isOnline: (accountId: string) => boolean;
+  hasRecentInboundReachability: (accountId: string) => boolean;
+  getActiveConnectionKey: (accountId: string) => string | null;
+  buildActiveConnectionDebugList: (accountId: string) => BncrConnection[];
+  markLastInboundAt: (accountId: string) => void;
+  getConfig: () => BncrChannelConfigRoot;
+  ensureCanonicalAgentId: (args: {
+    cfg: BncrChannelConfigRoot;
+    accountId: string;
+    peer: EnsureCanonicalAgentIdPeer;
+    channelId: string;
+  }) => string;
+  prepareInboundAcceptance: (args: {
+    parsed: ParsedInboundParams;
+    canonicalAgentId: string;
+  }) => Promise<InboundAcceptanceResult>;
+  formatDisplayScope: (route: BncrRoute) => string;
+  logInboundSummary: (args: {
+    accountId: string;
+    route: BncrRoute;
+    msgType: string;
+    text: string;
+    hasMedia: boolean;
+  }) => void;
+  respond: GatewayRequestHandlerOptions['respond'];
+  flushOnInboundAccepted: (accountId: string) => void;
+  dispatchInbound: (args: {
+    cfg: BncrChannelConfigRoot;
+    parsed: ParsedInboundParams;
+    canonicalAgentId: string;
+  }) => Promise<unknown>;
+};
+
+export function createBncrInboundHandlers(runtime: Omit<BncrInboundHandlersRuntime, 'respond'>) {
+  return {
+    handleInbound: async ({ params, respond, client, context }: GatewayRequestHandlerOptions) => {
+      await runtime.syncDebugFlag();
+      const parsed = runtime.parseInboundParams(params);
+      const { accountId, platform, route, msgType, msgId, peer, extracted } = parsed;
+      const gatewayContext = buildBncrGatewayEventContext({
+        params,
+        client,
+        context,
+        asString: runtime.asString,
+        normalizeAccountId: (value) => value,
+        now: runtime.now,
+      });
+      const { connId, clientId, outboundReady, preferredForOutbound, inboundOnly } = gatewayContext;
+      if (
+        runtime.shouldIgnoreStaleEvent({
+          kind: 'inbound',
+          payload: params ?? {},
+          accountId,
+          connId,
+          clientId,
+        })
+      ) {
+        respond(
+          true,
+          runtime.buildInboundResponsePayload({
+            kind: 'stale-ignored',
+            accountId,
+            msgId: msgId ?? null,
+          }),
+        );
+        return;
+      }
+      runtime.refreshLiveConnectionState({
+        accountId,
+        connId,
+        clientId,
+        outboundReady,
+        preferredForOutbound,
+        inboundOnly,
+        context: gatewayContext.context,
+      });
+      runtime.logInfo(
+        'inbound',
+        `lifecycle ${JSON.stringify(
+          runtime.buildInboundAcceptedLifecycleDebugInfo({
+            stage: 'accepted',
+            bridge: runtime.bridgeId,
+            accountId,
+            connId,
+            clientId,
+            outboundReady,
+            preferredForOutbound,
+            inboundOnly,
+            onlineAfterSeen: runtime.isOnline(accountId),
+            recentInboundReachable: runtime.hasRecentInboundReachability(accountId),
+            activeConnectionKey: runtime.getActiveConnectionKey(accountId),
+            activeConnections: runtime.buildActiveConnectionDebugList(accountId),
+          }),
+        )}`,
+        { debugOnly: true },
+      );
+      runtime.markLastInboundAt(accountId);
+
+      const cfg = runtime.getConfig();
+      const canonicalAgentId = runtime.ensureCanonicalAgentId({
+        cfg,
+        accountId,
+        peer,
+        channelId: runtime.channelId,
+      });
+      const acceptance = await runtime.prepareInboundAcceptance({ parsed, canonicalAgentId });
+      if (!acceptance.ok) {
+        respond(acceptance.status, acceptance.payload);
+        return;
+      }
+
+      const { sessionKey, inboundText, hasMedia } = acceptance;
+      runtime.logInfo(
+        'inbound',
+        JSON.stringify({
+          accountId,
+          msgId: msgId ?? null,
+          platform,
+          chatType: peer.kind,
+          scope: runtime.formatDisplayScope(route),
+          sessionKey,
+          msgType,
+          textLen: inboundText.length,
+          textPreview: inboundText.slice(0, 120),
+          hasMedia,
+        }),
+        { debugOnly: true },
+      );
+      runtime.logInboundSummary({
+        accountId,
+        route,
+        msgType,
+        text: inboundText,
+        hasMedia,
+      });
+
+      respond(
+        true,
+        runtime.buildInboundResponsePayload({
+          kind: 'accepted',
+          accountId,
+          sessionKey,
+          msgId: msgId ?? null,
+          taskKey: extracted.taskKey ?? null,
+        }),
+      );
+      runtime.flushOnInboundAccepted(accountId);
+
+      void runtime
+        .dispatchInbound({
+          cfg,
+          parsed,
+          canonicalAgentId,
+        })
+        .catch((err) => {
+          runtime.logError('inbound', `process failed: ${String(err)}`, { debugOnly: true });
+        });
+    },
+  };
+}

package/src/plugin/inbound-surface-handlers-group.ts

@@ -0,0 +1,152 @@
+import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
+import type { BncrConnection, BncrRoute } from '../core/types.ts';
+import {
+  createBncrFileInboundHandlersComponent,
+  createBncrInboundHandlersComponent,
+} from './channel-components.ts';
+import type {
+  buildInboundAcceptedLifecycleDebugInfo,
+  buildInboundResponsePayload,
+} from './channel-inbound-helpers.ts';
+import type { createBncrFileInboundHandlers } from './file-inbound-handlers.ts';
+
+export function createBncrInboundSurfaceHandlersGroup(runtime: {
+  getApi: Parameters<typeof createBncrFileInboundHandlersComponent>[0]['getApi'];
+  channelId: string;
+  bridgeId: string;
+  pluginRoot: string;
+  asString: (value: unknown, fallback?: string) => string;
+  now: () => number;
+  normalizeAccountId: (value: string) => string;
+  finiteNonNegativeNumberOrNull: (value: unknown) => number | null;
+  syncDebugFlag: () => Promise<void>;
+  shouldIgnoreStaleEvent: (args: {
+    kind:
+      | 'inbound'
+      | 'activity'
+      | 'ack'
+      | 'file.init'
+      | 'file.chunk'
+      | 'file.complete'
+      | 'file.abort';
+    payload: { leaseId?: string; connectionEpoch?: number };
+    accountId: string;
+    connId: string;
+    clientId?: string;
+  }) => boolean;
+  observeLease: (
+    kind:
+      | 'connect'
+      | 'inbound'
+      | 'activity'
+      | 'ack'
+      | 'file.init'
+      | 'file.chunk'
+      | 'file.complete'
+      | 'file.abort',
+    payload: { leaseId?: string; connectionEpoch?: number },
+  ) => { stale: boolean };
+  matchesTransferOwner: Parameters<typeof createBncrFileInboundHandlers>[0]['matchesTransferOwner'];
+  refreshAcceptedFileTransferLiveState: (args: {
+    accountId: string;
+    connId: string;
+    clientId?: string;
+    context: GatewayRequestHandlerOptions['context'];
+  }) => void;
+  refreshLiveConnectionState: (args: {
+    accountId: string;
+    connId: string;
+    clientId?: string;
+    outboundReady: boolean;
+    preferredForOutbound: boolean;
+    inboundOnly: boolean;
+    context: GatewayRequestHandlerOptions['context'];
+  }) => void;
+  logInfo: (scope: string, message: string, options?: { debugOnly?: boolean }) => void;
+  logWarn: Parameters<typeof createBncrFileInboundHandlers>[0]['logWarn'];
+  logError: (scope: string, message: string, options?: { debugOnly?: boolean }) => void;
+  buildInboundResponsePayload: typeof buildInboundResponsePayload;
+  buildInboundAcceptedLifecycleDebugInfo: typeof buildInboundAcceptedLifecycleDebugInfo;
+  isOnline: (accountId: string) => boolean;
+  hasRecentInboundReachability: (accountId: string) => boolean;
+  getActiveConnectionKey: (accountId: string) => string | null;
+  buildActiveConnectionDebugList: (accountId: string) => BncrConnection[];
+  markLastInboundAt: (accountId: string) => void;
+  ensureCanonicalAgentId: Parameters<
+    typeof createBncrInboundHandlersComponent
+  >[0]['ensureCanonicalAgentId'];
+  prepareInboundAcceptance: Parameters<
+    typeof createBncrInboundHandlersComponent
+  >[0]['prepareInboundAcceptance'];
+  logInboundSummary: (args: {
+    accountId: string;
+    route: BncrRoute;
+    msgType: string;
+    text: string;
+    hasMedia: boolean;
+  }) => void;
+  flushPushQueueBestEffort: (args?: {
+    accountId?: string;
+    trigger?: string;
+    reason?: string;
+  }) => void;
+  rememberSessionRoute: (sessionKey: string, accountId: string, route: BncrRoute) => void;
+  enqueueFromReply: Parameters<typeof createBncrInboundHandlersComponent>[0]['enqueueFromReply'];
+  setInboundActivity: (accountId: string, at: number) => void;
+  scheduleSave: () => void;
+  fileRecvTransfers: Parameters<
+    typeof createBncrFileInboundHandlersComponent
+  >[0]['fileRecvTransfers'];
+  inboundFileTransferMaxBytes: number;
+  inboundFileTransferMaxChunks: number;
+}) {
+  const fileInboundHandlers = createBncrFileInboundHandlersComponent({
+    getApi: runtime.getApi,
+    asString: runtime.asString,
+    now: runtime.now,
+    normalizeAccountId: runtime.normalizeAccountId,
+    finiteNonNegativeNumberOrNull: runtime.finiteNonNegativeNumberOrNull,
+    shouldIgnoreStaleEvent: runtime.shouldIgnoreStaleEvent,
+    observeLease: runtime.observeLease,
+    matchesTransferOwner: runtime.matchesTransferOwner,
+    refreshAcceptedFileTransferLiveState: runtime.refreshAcceptedFileTransferLiveState,
+    logWarn: runtime.logWarn,
+    fileRecvTransfers: runtime.fileRecvTransfers,
+    inboundFileTransferMaxBytes: runtime.inboundFileTransferMaxBytes,
+    inboundFileTransferMaxChunks: runtime.inboundFileTransferMaxChunks,
+  });
+
+  const inboundHandlers = createBncrInboundHandlersComponent({
+    getApi: runtime.getApi,
+    channelId: runtime.channelId,
+    bridgeId: runtime.bridgeId,
+    pluginRoot: runtime.pluginRoot,
+    asString: runtime.asString,
+    now: runtime.now,
+    syncDebugFlag: runtime.syncDebugFlag,
+    shouldIgnoreStaleEvent: runtime.shouldIgnoreStaleEvent,
+    buildInboundResponsePayload: runtime.buildInboundResponsePayload,
+    refreshLiveConnectionState: runtime.refreshLiveConnectionState,
+    logInfo: runtime.logInfo,
+    logError: runtime.logError,
+    buildInboundAcceptedLifecycleDebugInfo: runtime.buildInboundAcceptedLifecycleDebugInfo,
+    isOnline: runtime.isOnline,
+    hasRecentInboundReachability: runtime.hasRecentInboundReachability,
+    getActiveConnectionKey: runtime.getActiveConnectionKey,
+    buildActiveConnectionDebugList: runtime.buildActiveConnectionDebugList,
+    markLastInboundAt: runtime.markLastInboundAt,
+    ensureCanonicalAgentId: runtime.ensureCanonicalAgentId,
+    prepareInboundAcceptance: runtime.prepareInboundAcceptance,
+    logInboundSummary: runtime.logInboundSummary,
+    flushPushQueueBestEffort: runtime.flushPushQueueBestEffort,
+    rememberSessionRoute: runtime.rememberSessionRoute,
+    enqueueFromReply: runtime.enqueueFromReply,
+    setInboundActivity: runtime.setInboundActivity,
+    scheduleSave: runtime.scheduleSave,
+  });
+
+  return {
+    fileInboundHandlers,
+    inboundHandlers,
+  };
+}

package/src/plugin/media-dedupe-runtime.ts

@@ -0,0 +1,90 @@
+import {
+  buildMediaTextFallback,
+  type MediaDedupeCacheEntry,
+  normalizeMessageText,
+  normalizeReplyToId,
+} from '../messaging/outbound/media-dedupe.ts';
+
+function asString(v: unknown, fallback = ''): string {
+  if (typeof v === 'string') return v;
+  if (v == null) return fallback;
+  return String(v);
+}
+
+export function createBncrMediaDedupeRuntime(runtime: {
+  now: () => number;
+  recentMediaDedupeBySession: Map<string, Map<string, MediaDedupeCacheEntry>>;
+}) {
+  function pruneMediaDedupeCache(sessionKey: string, currentTime = runtime.now()) {
+    const sessionCache = runtime.recentMediaDedupeBySession.get(sessionKey);
+    if (!sessionCache) return;
+
+    for (const [mediaUrl, entry] of sessionCache.entries()) {
+      if (currentTime - entry.createdAt > 10_000) {
+        sessionCache.delete(mediaUrl);
+      }
+    }
+
+    if (sessionCache.size === 0) {
+      runtime.recentMediaDedupeBySession.delete(sessionKey);
+    }
+  }
+
+  function rememberRecentMediaSend(params: {
+    sessionKey: string;
+    mediaUrl: string;
+    text: string;
+    replyToId: string;
+    createdAt?: number;
+  }) {
+    const sessionKey = asString(params.sessionKey || '').trim();
+    const mediaUrl = asString(params.mediaUrl || '').trim();
+    if (!sessionKey || !mediaUrl) return;
+
+    const createdAt = typeof params.createdAt === 'number' ? params.createdAt : runtime.now();
+    pruneMediaDedupeCache(sessionKey, createdAt);
+    let sessionCache = runtime.recentMediaDedupeBySession.get(sessionKey);
+    if (!sessionCache) {
+      sessionCache = new Map<string, MediaDedupeCacheEntry>();
+      runtime.recentMediaDedupeBySession.set(sessionKey, sessionCache);
+    }
+    sessionCache.set(mediaUrl, {
+      mediaUrl,
+      text: normalizeMessageText(params.text),
+      replyToId: normalizeReplyToId(params.replyToId),
+      createdAt,
+    });
+  }
+
+  function tryBuildMediaDedupeFallback(params: {
+    sessionKey: string;
+    mediaUrl: string;
+    text: string;
+    replyToId: string;
+    currentTime?: number;
+  }): { text: string; reason: 'same-text-sent-checkmark' | 'text-changed-downgrade' } | null {
+    const sessionKey = asString(params.sessionKey || '').trim();
+    const mediaUrl = asString(params.mediaUrl || '').trim();
+    if (!sessionKey || !mediaUrl) return null;
+
+    const currentTime = typeof params.currentTime === 'number' ? params.currentTime : runtime.now();
+    pruneMediaDedupeCache(sessionKey, currentTime);
+    const sessionCache = runtime.recentMediaDedupeBySession.get(sessionKey);
+    const previous = sessionCache?.get(mediaUrl);
+    if (!previous) return null;
+    if (currentTime - previous.createdAt > 10_000) return null;
+
+    return buildMediaTextFallback({
+      currentText: normalizeMessageText(params.text),
+      previousText: previous.text,
+      currentReplyToId: normalizeReplyToId(params.replyToId),
+      previousReplyToId: previous.replyToId,
+    });
+  }
+
+  return {
+    pruneMediaDedupeCache,
+    rememberRecentMediaSend,
+    tryBuildMediaDedupeFallback,
+  };
+}