@xmoxmo/bncr 0.3.6 → 0.3.7

package/src/plugin/file-transfer-runtime-group.ts

@@ -0,0 +1,102 @@
+import {
+  createBncrFileAckRuntime,
+  type FileAckPayloadState,
+  type FileAckWaiter,
+} from './file-ack-runtime.ts';
+import { createBncrFileTransferLogs } from './file-transfer-logs.ts';
+import { createBncrFileTransferSend } from './file-transfer-send.ts';
+import {
+  type BncrFileTransferRouteDiagnostics,
+  createBncrFileTransferSetup,
+} from './file-transfer-setup.ts';
+
+export function createBncrFileTransferRuntimeGroup(runtime: {
+  bridgeId: string;
+  now: () => number;
+  asString: (value: unknown, fallback?: string) => string;
+  clampFiniteNumber: (value: unknown, fallback: number, min?: number, max?: number) => number;
+  fileAckTimeoutMs: number;
+  maxEarlyFileAcks: number;
+  fileAckWaiters: Map<string, FileAckWaiter>;
+  earlyFileAcks: Map<string, FileAckPayloadState>;
+  getFileAckOwnerInfo: (transferId: string) => Record<string, unknown>;
+  fileForceChunk: boolean;
+  fileInlineThreshold: number;
+  normalizeAccountId: (accountId: string) => string;
+  loadOutboundTransferMedia: (args: {
+    mediaUrl: string;
+    mediaLocalRoots?: readonly string[];
+  }) => Promise<{ loaded: { buffer: Buffer }; size: number; mimeType?: string; fileName: string }>;
+  resolveOutboxPushOwner: (accountId: string) => { connId?: string; clientId?: string } | null;
+  hasRecentInboundReachability: (accountId: string) => boolean;
+  buildTransferRouteDiagnostics: (args: {
+    accountId: string;
+    recentInboundReachable: boolean;
+  }) => BncrFileTransferRouteDiagnostics;
+  selectTransferConnIds: (args: {
+    directConnIds: Set<string>;
+    recentConnIds: Set<string>;
+    recentInboundReachable: boolean;
+  }) => Set<string>;
+  broadcastToConnIds: (event: string, payload: unknown, connIds: ReadonlySet<string>) => void;
+  chunkEvent: string;
+  completeEvent: string;
+  logInfo: (scope: string | undefined, message: string, options?: { debugOnly?: boolean }) => void;
+  logWarn: (scope: string | undefined, message: string, options?: { debugOnly?: boolean }) => void;
+}) {
+  const fileAckRuntime = createBncrFileAckRuntime({
+    bridgeId: runtime.bridgeId,
+    now: runtime.now,
+    asString: runtime.asString,
+    clampFiniteNumber: (value, fallback, min, max) =>
+      runtime.clampFiniteNumber(value, fallback, min ?? fallback, max ?? fallback),
+    fileAckTimeoutMs: runtime.fileAckTimeoutMs,
+    maxEarlyFileAcks: runtime.maxEarlyFileAcks,
+    fileAckWaiters: runtime.fileAckWaiters,
+    earlyFileAcks: runtime.earlyFileAcks,
+    getFileAckOwnerInfo: runtime.getFileAckOwnerInfo,
+    logInfo: runtime.logInfo,
+    logWarn: runtime.logWarn,
+  });
+
+  const fileTransferLogs = createBncrFileTransferLogs({
+    bridgeId: runtime.bridgeId,
+    now: runtime.now,
+    logInfo: (scope, message, options) => runtime.logInfo(scope, message, options),
+    logWarn: (scope, message, options) => runtime.logWarn(scope, message, options),
+  });
+
+  const fileTransferSetup = createBncrFileTransferSetup({
+    fileForceChunk: runtime.fileForceChunk,
+    fileInlineThreshold: runtime.fileInlineThreshold,
+    normalizeAccountId: runtime.normalizeAccountId,
+    loadOutboundTransferMedia: runtime.loadOutboundTransferMedia,
+    resolveOutboxPushOwner: runtime.resolveOutboxPushOwner,
+    hasRecentInboundReachability: runtime.hasRecentInboundReachability,
+    buildTransferRouteDiagnostics: runtime.buildTransferRouteDiagnostics,
+    selectTransferConnIds: runtime.selectTransferConnIds,
+    logFileChunkDiag: fileTransferLogs.logFileChunkDiag,
+    logFileTransferStart: fileTransferLogs.logFileTransferStart,
+    buildInitialFileSendTransferState: (args) =>
+      fileTransferLogs.buildInitialFileSendTransferState({
+        ...args,
+        normalizeAccountId: runtime.normalizeAccountId,
+      }),
+  });
+
+  const fileTransferSend = createBncrFileTransferSend({
+    now: runtime.now,
+    broadcastToConnIds: runtime.broadcastToConnIds,
+    chunkEvent: runtime.chunkEvent,
+    completeEvent: runtime.completeEvent,
+    logFileTransferChunkSend: fileTransferLogs.logFileTransferChunkSend,
+    logFileTransferCompleteSend: fileTransferLogs.logFileTransferCompleteSend,
+  });
+
+  return {
+    fileAckRuntime,
+    fileTransferLogs,
+    fileTransferSetup,
+    fileTransferSend,
+  };
+}

package/src/plugin/file-transfer-send.ts

@@ -0,0 +1,89 @@
+import {
+  buildFileTransferChunkPayload,
+  buildFileTransferCompletePayload,
+} from '../core/file-transfer-payloads.ts';
+
+export type BncrFileTransferSendRuntime = {
+  now: () => number;
+  broadcastToConnIds: (event: string, payload: unknown, connIds: ReadonlySet<string>) => void;
+  chunkEvent: string;
+  completeEvent: string;
+  logFileTransferChunkSend: (args: {
+    transferId: string;
+    accountId: string;
+    chunkIndex: number;
+    attempt: number;
+    offset: number;
+    size: number;
+    connIds: ReadonlySet<string>;
+  }) => void;
+  logFileTransferCompleteSend: (args: {
+    transferId: string;
+    accountId: string;
+    connIds: ReadonlySet<string>;
+  }) => void;
+};
+
+export function createBncrFileTransferSend(runtime: BncrFileTransferSendRuntime) {
+  const sendChunk = (args: {
+    transferId: string;
+    accountId: string;
+    chunkIndex: number;
+    attempt: number;
+    offset: number;
+    size: number;
+    chunkSha256: string;
+    base64: string;
+    connIds: ReadonlySet<string>;
+  }) => {
+    runtime.broadcastToConnIds(
+      runtime.chunkEvent,
+      buildFileTransferChunkPayload({
+        transferId: args.transferId,
+        chunkIndex: args.chunkIndex,
+        offset: args.offset,
+        size: args.size,
+        chunkSha256: args.chunkSha256,
+        base64: args.base64,
+        ts: runtime.now(),
+      }),
+      args.connIds,
+    );
+
+    runtime.logFileTransferChunkSend({
+      transferId: args.transferId,
+      accountId: args.accountId,
+      chunkIndex: args.chunkIndex,
+      attempt: args.attempt,
+      offset: args.offset,
+      size: args.size,
+      connIds: args.connIds,
+    });
+  };
+
+  const sendComplete = (args: {
+    transferId: string;
+    accountId: string;
+    connIds: ReadonlySet<string>;
+  }) => {
+    runtime.broadcastToConnIds(
+      runtime.completeEvent,
+      buildFileTransferCompletePayload({
+        transferId: args.transferId,
+        ts: runtime.now(),
+      }),
+      args.connIds,
+    );
+
+    runtime.logFileTransferCompleteSend({
+      transferId: args.transferId,
+      accountId: args.accountId,
+      connIds: args.connIds,
+    });
+  };
+
+  return {
+    sendChunk,
+    sendComplete,
+  };
+}

package/src/plugin/file-transfer-setup.ts

@@ -0,0 +1,206 @@
+import { createHash, randomUUID } from 'node:crypto';
+import type { BncrRoute } from '../core/types.ts';
+
+export type BncrFileTransferRouteDiagnostics = {
+  activeConnectionKey: string | null;
+  directConnIds: Set<string>;
+  recentConnIds: Set<string>;
+  accountConnections: Array<{
+    connId: string;
+    clientId?: string;
+    connectedAt: number;
+    lastSeenAt: number;
+  }>;
+};
+
+export type BncrFileTransferSetupRuntime = {
+  fileForceChunk: boolean;
+  fileInlineThreshold: number;
+  normalizeAccountId: (accountId: string) => string;
+  loadOutboundTransferMedia: (args: {
+    mediaUrl: string;
+    mediaLocalRoots?: readonly string[];
+  }) => Promise<{ loaded: { buffer: Buffer }; size: number; mimeType?: string; fileName: string }>;
+  resolveOutboxPushOwner: (accountId: string) => { connId?: string; clientId?: string } | null;
+  hasRecentInboundReachability: (accountId: string) => boolean;
+  buildTransferRouteDiagnostics: (args: {
+    accountId: string;
+    recentInboundReachable: boolean;
+  }) => BncrFileTransferRouteDiagnostics;
+  selectTransferConnIds: (args: {
+    directConnIds: Set<string>;
+    recentConnIds: Set<string>;
+    recentInboundReachable: boolean;
+  }) => Set<string>;
+  logFileChunkDiag: (args: {
+    accountId: string;
+    sessionKey: string;
+    mediaUrl: string;
+    hasGatewayContext: boolean;
+    activeConnectionKey: string | null;
+    ownerConnId?: string;
+    ownerClientId?: string;
+    directConnIds: Iterable<string>;
+    recentInboundReachable: boolean;
+    recentConnIds: Iterable<string>;
+    accountConnections: Array<{
+      connId: string;
+      clientId?: string;
+      connectedAt: number;
+      lastSeenAt: number;
+    }>;
+  }) => void;
+  logFileTransferStart: (args: {
+    transferId: string;
+    accountId: string;
+    sessionKey: string;
+    mediaUrl: string;
+    fileName: string;
+    mimeType?: string;
+    fileSize: number;
+    chunkSize: number;
+    totalChunks: number;
+    connIds: ReadonlySet<string>;
+    ownerConnId?: string;
+    ownerClientId?: string;
+  }) => void;
+  buildInitialFileSendTransferState: (args: {
+    transferId: string;
+    accountId: string;
+    sessionKey: string;
+    route: BncrRoute;
+    fileName: string;
+    mimeType?: string;
+    fileSize: number;
+    chunkSize: number;
+    totalChunks: number;
+    fileSha256: string;
+    ownerConnId?: string;
+    ownerClientId?: string;
+  }) => {
+    transferId: string;
+    accountId: string;
+    sessionKey: string;
+    route: BncrRoute;
+    fileName: string;
+    mimeType: string;
+    fileSize: number;
+    chunkSize: number;
+    totalChunks: number;
+    fileSha256: string;
+    startedAt: number;
+    status: string;
+    ownerConnId?: string;
+    ownerClientId?: string;
+    ackedChunks: Set<number>;
+    failedChunks: Map<number, string>;
+  };
+};
+
+export function createBncrFileTransferSetup(runtime: BncrFileTransferSetupRuntime) {
+  const prepareOutboundTransfer = async (args: {
+    accountId: string;
+    sessionKey: string;
+    route: BncrRoute;
+    mediaUrl: string;
+    mediaLocalRoots?: readonly string[];
+    hasGatewayContext: boolean;
+  }) => {
+    const { loaded, size, mimeType, fileName } = await runtime.loadOutboundTransferMedia({
+      mediaUrl: args.mediaUrl,
+      mediaLocalRoots: args.mediaLocalRoots,
+    });
+
+    if (!runtime.fileForceChunk && size <= runtime.fileInlineThreshold) {
+      return {
+        mode: 'base64' as const,
+        mimeType,
+        fileName,
+        mediaBase64: loaded.buffer.toString('base64'),
+      };
+    }
+
+    const owner = runtime.resolveOutboxPushOwner(args.accountId);
+    const recentInboundReachable = runtime.hasRecentInboundReachability(args.accountId);
+    const normalizedAccountId = runtime.normalizeAccountId(args.accountId);
+    const routeDiagnostics = runtime.buildTransferRouteDiagnostics({
+      accountId: normalizedAccountId,
+      recentInboundReachable,
+    });
+    runtime.logFileChunkDiag({
+      accountId: normalizedAccountId,
+      sessionKey: args.sessionKey,
+      mediaUrl: args.mediaUrl,
+      hasGatewayContext: args.hasGatewayContext,
+      activeConnectionKey: routeDiagnostics.activeConnectionKey,
+      ownerConnId: owner?.connId,
+      ownerClientId: owner?.clientId,
+      directConnIds: routeDiagnostics.directConnIds,
+      recentInboundReachable,
+      recentConnIds: routeDiagnostics.recentConnIds,
+      accountConnections: routeDiagnostics.accountConnections,
+    });
+
+    const connIds = runtime.selectTransferConnIds({
+      directConnIds: routeDiagnostics.directConnIds,
+      recentConnIds: routeDiagnostics.recentConnIds,
+      recentInboundReachable,
+    });
+    const transferId = randomUUID();
+    const chunkSize = 256 * 1024;
+    const totalChunks = Math.ceil(size / chunkSize);
+    const fileSha256 = createHash('sha256').update(loaded.buffer).digest('hex');
+
+    runtime.logFileTransferStart({
+      transferId,
+      accountId: normalizedAccountId,
+      sessionKey: args.sessionKey,
+      mediaUrl: args.mediaUrl,
+      fileName,
+      mimeType,
+      fileSize: size,
+      chunkSize,
+      totalChunks,
+      connIds,
+      ownerConnId: owner?.connId,
+      ownerClientId: owner?.clientId,
+    });
+
+    const state = runtime.buildInitialFileSendTransferState({
+      transferId,
+      accountId: args.accountId,
+      sessionKey: args.sessionKey,
+      route: args.route,
+      fileName,
+      mimeType,
+      fileSize: size,
+      chunkSize,
+      totalChunks,
+      fileSha256,
+      ownerConnId: owner?.connId,
+      ownerClientId: owner?.clientId,
+    });
+
+    return {
+      mode: 'chunk' as const,
+      loaded,
+      size,
+      mimeType,
+      fileName,
+      owner,
+      recentInboundReachable,
+      accountId: normalizedAccountId,
+      routeDiagnostics,
+      connIds,
+      transferId,
+      chunkSize,
+      totalChunks,
+      fileSha256,
+      state,
+    };
+  };
+
+  return {
+    prepareOutboundTransfer,
+  };
+}

package/src/plugin/gateway-event-context.ts

@@ -0,0 +1,41 @@
+import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
+import type { BncrGatewayCapabilityFlags } from '../core/types.ts';
+
+export type BncrGatewayEventContextParams = {
+  accountId?: unknown;
+  clientId?: unknown;
+  outboundReady?: unknown;
+  preferredForOutbound?: unknown;
+  inboundOnly?: unknown;
+};
+
+export type BncrGatewayEventContext = {
+  accountId: string;
+  connId: string;
+  clientId?: string;
+  context: GatewayRequestHandlerOptions['context'];
+} & BncrGatewayCapabilityFlags;
+
+export function buildBncrGatewayEventContext(args: {
+  params: BncrGatewayEventContextParams | null | undefined;
+  client: GatewayRequestHandlerOptions['client'];
+  context: GatewayRequestHandlerOptions['context'];
+  asString: (value: unknown, fallback?: string) => string;
+  normalizeAccountId: (value: string) => string;
+  now?: () => number;
+}): BncrGatewayEventContext {
+  const accountId = args.normalizeAccountId(args.asString(args.params?.accountId || ''));
+  const connId =
+    args.asString(args.client?.connId || '').trim() || `no-conn-${(args.now || Date.now)()}`;
+  const clientId = args.asString(args.params?.clientId || '').trim() || undefined;
+
+  return {
+    accountId,
+    connId,
+    clientId,
+    context: args.context,
+    outboundReady: args.params?.outboundReady === true,
+    preferredForOutbound: args.params?.preferredForOutbound === true,
+    inboundOnly: args.params?.inboundOnly === true,
+  };
+}

package/src/plugin/gateway-runtime.ts

@@ -1,11 +1,21 @@
+import type { ChannelAccountSnapshot, ChannelGatewayContext } from 'openclaw/plugin-sdk';
+
+type GatewayAccountContext = Pick<
+  ChannelGatewayContext,
+  'accountId' | 'abortSignal' | 'getStatus' | 'setStatus'
+> & {
+  getStatus?: () => ChannelAccountSnapshot;
+  setStatus?: (status: ChannelAccountSnapshot) => void;
+};
+
 export type BncrGatewayAccountBridge = {
-  channelStartAccount: (ctx: any) => unknown | Promise<unknown>;
-  channelStopAccount: (ctx: any) => unknown | Promise<unknown>;
+  channelStartAccount: (ctx: GatewayAccountContext) => void | Promise<void>;
+  channelStopAccount: (ctx: GatewayAccountContext) => void | Promise<void>;
 };
 
 export function createBncrGatewayRuntime(getBridge: () => BncrGatewayAccountBridge) {
   return {
-    startAccount: async (ctx: any) => getBridge().channelStartAccount(ctx),
-    stopAccount: async (ctx: any) => getBridge().channelStopAccount(ctx),
+    startAccount: async (ctx: GatewayAccountContext) => getBridge().channelStartAccount(ctx),
+    stopAccount: async (ctx: GatewayAccountContext) => getBridge().channelStopAccount(ctx),
   };
 }

package/src/plugin/inbound-acceptance.ts

@@ -0,0 +1,107 @@
+import { resolveAccount } from '../core/accounts.ts';
+import { checkBncrMessageGate } from '../messaging/inbound/gate.ts';
+import type { parseBncrInboundParams } from '../messaging/inbound/parse.ts';
+import type { OpenClawResolvedAgentRoute } from '../openclaw/routing-runtime.ts';
+import type { buildInboundResponsePayload } from './channel-inbound-helpers.ts';
+import { resolveInboundSessionContext } from './channel-inbound-helpers.ts';
+import type { BncrChannelConfigRoot } from './channel-runtime-types.ts';
+
+type InboundAcceptanceResponsePayload = ReturnType<typeof buildInboundResponsePayload>;
+
+export async function prepareBncrInboundAcceptance(args: {
+  api: unknown;
+  parsed: ReturnType<typeof parseBncrInboundParams>;
+  canonicalAgentId: string;
+  asString: (value: unknown, fallback?: string) => string;
+  getRuntimeConfig: (api: unknown) => BncrChannelConfigRoot;
+  resolveAgentRoute: (params: {
+    cfg: BncrChannelConfigRoot;
+    channel: string;
+    accountId: string;
+    peer: unknown;
+  }) => OpenClawResolvedAgentRoute;
+  buildInboundResponsePayload: (
+    args:
+      | { kind: 'invalid-peer' }
+      | { kind: 'duplicated'; accountId: string; msgId?: string | null }
+      | { kind: 'gate-denied'; accountId: string; msgId?: string | null; reason: string },
+  ) => InboundAcceptanceResponsePayload;
+  markInboundDedupSeen: (key: string) => boolean;
+}) {
+  const { parsed, canonicalAgentId } = args;
+  const {
+    accountId,
+    platform,
+    groupId,
+    userId,
+    sessionKeyfromroute,
+    route,
+    text,
+    mediaBase64,
+    mediaPathFromTransfer,
+    msgId,
+    peer,
+    extracted,
+    dedupKey,
+  } = parsed;
+
+  if (!platform || (!userId && !groupId)) {
+    return {
+      ok: false as const,
+      status: false,
+      payload: args.buildInboundResponsePayload({ kind: 'invalid-peer' }),
+    };
+  }
+  if (args.markInboundDedupSeen(dedupKey)) {
+    return {
+      ok: false as const,
+      status: true,
+      payload: args.buildInboundResponsePayload({
+        kind: 'duplicated',
+        accountId,
+        msgId: msgId ?? null,
+      }),
+    };
+  }
+
+  const cfg = args.getRuntimeConfig(args.api);
+  const gate = await checkBncrMessageGate({
+    parsed,
+    cfg,
+    account: resolveAccount(cfg, accountId),
+  });
+  if (!gate.allowed) {
+    return {
+      ok: false as const,
+      status: true,
+      payload: args.buildInboundResponsePayload({
+        kind: 'gate-denied',
+        accountId,
+        msgId: msgId ?? null,
+        reason: gate.reason,
+      }),
+    };
+  }
+
+  const { sessionKey, inboundText } = resolveInboundSessionContext({
+    cfg,
+    accountId,
+    peer,
+    route,
+    sessionKeyFromRoute: sessionKeyfromroute,
+    canonicalAgentId,
+    taskKey: extracted.taskKey ?? undefined,
+    text,
+    extractedText: extracted.text,
+    asString: args.asString,
+    resolveAgentRoute: args.resolveAgentRoute,
+  });
+
+  return {
+    ok: true as const,
+    accountId,
+    sessionKey,
+    inboundText,
+    hasMedia: Boolean(mediaBase64 || mediaPathFromTransfer),
+  };
+}