@xmoxmo/bncr 0.5.5 → 0.5.7

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

@@ -1,6 +1,7 @@
 import { buildFileTransferInitPayload } from '../core/file-transfer-payloads.ts';
 import type { BncrRoute, FileSendTransferState } from '../core/types.ts';
 import { asSanitizedString, clampFiniteNumber } from '../core/value-sanitize.ts';
+import { resolveOutboundFileName } from './channel-utils.ts';
 import type { createBncrFileAckRuntime } from './file-ack-runtime.ts';
 import {
   abortChunkTransfer,
@@ -36,13 +37,13 @@ function getCompletedTransferPath(state?: FileSendTransferState): string | null
 function buildBase64TransferResult(prepared: {
   mimeType?: string;
   fileName?: string;
-  mediaBase64?: string;
+  base64?: string;
 }) {
   return {
     mode: 'base64' as const,
     mimeType: prepared.mimeType,
     fileName: prepared.fileName,
-    mediaBase64: prepared.mediaBase64,
+    base64: prepared.base64,
   };
 }
 
@@ -190,8 +191,96 @@ export function createBncrFileTransferOrchestrator(runtime: BncrFileTransferOrch
 
     return buildChunkTransferResult({ mimeType, fileName, path: done.path });
   };
+  const HTTP_URL_RE = /^https?:\/\//i;
+
+  /** Try HEAD for Content-Type; fall back to Range+sniff for magic bytes when unclear. */
+  async function resolveRemoteMediaType(url: string): Promise<{ mimeType?: string }> {
+    // 1) HEAD -> Content-Type
+    let headerType = '';
+    try {
+      const head = await fetch(url, { method: 'HEAD', signal: AbortSignal.timeout(10_000) });
+      if (head.ok) {
+        const raw = (head.headers.get('content-type') || '').trim().toLowerCase();
+        const parsed = raw.split(';')[0]?.trim() || '';
+        // Accept explicit types; reject octet-stream and generic application/*
+        if (parsed && parsed !== 'application/octet-stream') {
+          headerType = parsed;
+        }
+      }
+    } catch {
+      /* HEAD failed, fall through to Range sniff */
+    }
+
+    if (headerType) return { mimeType: headerType };
+
+    // 2) Range GET -> first 512 bytes -> magic byte sniff
+    try {
+      const range = await fetch(url, {
+        method: 'GET',
+        headers: { Range: 'bytes=0-511' },
+        signal: AbortSignal.timeout(10_000),
+      });
+      // Only accept 206 Partial Content; 200 (no Range support) or other statuses -> fall through
+      if (range.status !== 206) return {};
+      const buf = Buffer.from(await range.arrayBuffer());
+      if (buf.length < 4) return {};
+
+      const sniffed = sniffMimeFromMagic(buf);
+      if (!sniffed) return {};
+      return { mimeType: sniffed };
+    } catch {
+      return {};
+    }
+  }
+
+  /** Minimal magic-byte MIME sniffer for the first ~512 bytes. */
+  function sniffMimeFromMagic(buf: Buffer): string | undefined {
+    const eq = (off: number, ...bytes: number[]) =>
+      bytes.every((b, idx) => off + idx < buf.length && buf[off + idx] === b);
+
+    // JPEG: FF D8 FF
+    if (buf.length >= 3 && buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff)
+      return 'image/jpeg';
+    // PNG: 89 50 4E 47
+    if (eq(0, 0x89, 0x50, 0x4e, 0x47)) return 'image/png';
+    // GIF: 47 49 46 38
+    if (eq(0, 0x47, 0x49, 0x46, 0x38)) return 'image/gif';
+    // WEBP: RIFF .... WEBP
+    if (eq(0, 0x52, 0x49, 0x46, 0x46) && buf.length >= 12 && eq(8, 0x57, 0x45, 0x42, 0x50))
+      return 'image/webp';
+    // BMP: 42 4D
+    if (eq(0, 0x42, 0x4d)) return 'image/bmp';
+    // MP4 / MOV / M4A: ftyp box
+    if (eq(4, 0x66, 0x74, 0x79, 0x70) && buf.length >= 12) {
+      const brand = String.fromCharCode(buf[8], buf[9], buf[10], buf[11]);
+      if (brand === 'M4A ' || brand === 'mp42') return 'audio/mp4';
+      return 'video/mp4';
+    }
+    // MP3: ID3 tag
+    if (eq(0, 0x49, 0x44, 0x33)) return 'audio/mpeg';
+    // MPEG audio sync word
+    if (buf[0] === 0xff && (buf[1] & 0xe0) === 0xe0) return 'audio/mpeg';
+    // OGG: 4F 67 67 53
+    if (eq(0, 0x4f, 0x67, 0x67, 0x53)) return 'audio/ogg';
+    // WAV: RIFF .... WAVE
+    if (eq(0, 0x52, 0x49, 0x46, 0x46) && buf.length >= 12 && eq(8, 0x57, 0x41, 0x56, 0x45))
+      return 'audio/wav';
+    // FLAC: 66 4C 61 43
+    if (eq(0, 0x66, 0x4c, 0x61, 0x43)) return 'audio/flac';
+    // PDF: 25 50 44 46
+    if (eq(0, 0x25, 0x50, 0x44, 0x46)) return 'application/pdf';
+    // WebM/Matroska: 1A 45 DF A3
+    if (eq(0, 0x1a, 0x45, 0xdf, 0xa3)) {
+      for (let i = 0; i < Math.min(buf.length, 200); i++) {
+        if (buf[i] === 0xae) return 'video/webm';
+      }
+      return 'audio/webm';
+    }
+    return undefined;
+  }
 
   const transferMediaToBncrClient = async (params: {
+    downloadMedia?: boolean;
     accountId: string;
     sessionKey: string;
     route: BncrRoute;
@@ -201,9 +290,22 @@ export function createBncrFileTransferOrchestrator(runtime: BncrFileTransferOrch
     mode: 'base64' | 'chunk';
     mimeType?: string;
     fileName?: string;
-    mediaBase64?: string;
+    base64?: string;
     path?: string;
   }> => {
+    // HTTP URL: skip download/chunk, pass URL through to client
+    if (HTTP_URL_RE.test(params.mediaUrl) && !params.downloadMedia) {
+      const { mimeType } = await resolveRemoteMediaType(params.mediaUrl);
+      const fileName = resolveOutboundFileName({
+        mediaUrl: params.mediaUrl,
+        mimeType,
+      });
+      return {
+        mode: 'base64' as const,
+        mimeType,
+        fileName,
+      };
+    }
     const prepared = await runtime.prepareOutboundTransfer({
       accountId: params.accountId,
       sessionKey: params.sessionKey,

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

@@ -116,7 +116,7 @@ export function createBncrFileTransferSetup(runtime: BncrFileTransferSetupRuntim
         mode: 'base64' as const,
         mimeType,
         fileName,
-        mediaBase64: loaded.buffer.toString('base64'),
+        base64: loaded.buffer.toString('base64'),
       };
     }
 

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

@@ -1,3 +1,4 @@
+import { asString } from '../core/value-sanitize.ts';
 import {
   buildMediaTextFallback,
   type MediaDedupeCacheEntry,
@@ -5,12 +6,6 @@ import {
   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>>;

package/src/plugin/media-orchestrators-runtime-group.ts

@@ -53,6 +53,7 @@ function buildReplyMediaEntryHelpers(runtime: {
     kind?: 'tool' | 'block' | 'final';
     replyToId?: string;
     replyTargetPolicy?: OutboundReplyTargetPolicy;
+    downloadMedia?: boolean;
   }) => OutboxEntry;
   rememberRecentMediaSend: (args: {
     sessionKey: string;
@@ -208,6 +209,7 @@ export function createBncrMediaOrchestratorsRuntimeGroup(runtime: {
     kind?: 'tool' | 'block' | 'final';
     replyToId?: string;
     replyTargetPolicy?: OutboundReplyTargetPolicy;
+    downloadMedia?: boolean;
   }) => OutboxEntry;
   rememberRecentMediaSend: (args: {
     sessionKey: string;

package/src/plugin/message-send.ts

@@ -1,23 +1,22 @@
 import type { ChannelMessageSendResult } from 'openclaw/plugin-sdk/channel-message';
-
-type MessageSendContext = Record<string, unknown>;
+import type { BncrChannelSendContext } from './channel-runtime-types.ts';
 
 export type BncrMessageSendBridge = {
   channelMessageSendText: (
-    ctx: MessageSendContext,
+    ctx: BncrChannelSendContext,
   ) => ChannelMessageSendResult | Promise<ChannelMessageSendResult>;
   channelMessageSendMedia: (
-    ctx: MessageSendContext,
+    ctx: BncrChannelSendContext,
   ) => ChannelMessageSendResult | Promise<ChannelMessageSendResult>;
   channelMessageSendPayload: (
-    ctx: MessageSendContext,
+    ctx: BncrChannelSendContext,
   ) => ChannelMessageSendResult | Promise<ChannelMessageSendResult>;
 };
 
 export function createBncrMessageSend(getBridge: () => BncrMessageSendBridge) {
   return {
-    text: async (ctx: MessageSendContext) => getBridge().channelMessageSendText(ctx),
-    media: async (ctx: MessageSendContext) => getBridge().channelMessageSendMedia(ctx),
-    payload: async (ctx: MessageSendContext) => getBridge().channelMessageSendPayload(ctx),
+    text: async (ctx: BncrChannelSendContext) => getBridge().channelMessageSendText(ctx),
+    media: async (ctx: BncrChannelSendContext) => getBridge().channelMessageSendMedia(ctx),
+    payload: async (ctx: BncrChannelSendContext) => getBridge().channelMessageSendPayload(ctx),
   };
 }

package/src/plugin/outbound.ts

@@ -1,31 +1,15 @@
 import { normalizeAccountId } from '../core/accounts.ts';
+import { asString } from '../core/value-sanitize.ts';
 import {
   deleteBncrMessageAction,
   editBncrMessageAction,
   reactBncrMessageAction,
   sendBncrReplyAction,
 } from '../messaging/outbound/actions.ts';
-
-function asString(v: unknown, fallback = ''): string {
-  return typeof v === 'string' ? v : v == null ? fallback : String(v);
-}
+import type { BncrChannelSendContext } from './channel-runtime-types.ts';
 
 type BncrOutboundDeliveryResult = { channel: string; messageId: string; chatId: string };
 
-type BncrOutboundSendContext = {
-  accountId?: string | null;
-  to?: string;
-  text?: string;
-  mediaUrl?: string;
-  type?: string;
-  kind?: string;
-  replyToId?: string | null;
-  replyToMessageId?: string | null;
-  asVoice?: boolean;
-  audioAsVoice?: boolean;
-  mediaLocalRoots?: readonly string[];
-};
-
 type BncrOutboundReplyActionContext = {
   accountId?: string | null;
   to?: string;
@@ -50,18 +34,18 @@ type BncrOutboundEditActionContext = BncrOutboundTargetActionContext & {
 
 export type BncrOutboundBridge = {
   channelSendText: (
-    ctx: BncrOutboundSendContext,
+    ctx: BncrChannelSendContext,
   ) => BncrOutboundDeliveryResult | Promise<BncrOutboundDeliveryResult>;
   channelSendMedia: (
-    ctx: BncrOutboundSendContext,
+    ctx: BncrChannelSendContext,
   ) => BncrOutboundDeliveryResult | Promise<BncrOutboundDeliveryResult>;
 };
 
 export function createBncrOutboundRuntime(getBridge: () => BncrOutboundBridge) {
   return {
     deliveryMode: 'gateway' as const,
-    sendText: async (ctx: BncrOutboundSendContext) => getBridge().channelSendText(ctx),
-    sendMedia: async (ctx: BncrOutboundSendContext) => getBridge().channelSendMedia(ctx),
+    sendText: async (ctx: BncrChannelSendContext) => getBridge().channelSendText(ctx),
+    sendMedia: async (ctx: BncrChannelSendContext) => getBridge().channelSendMedia(ctx),
     replyAction: async (ctx: BncrOutboundReplyActionContext) =>
       sendBncrReplyAction({
         accountId: normalizeAccountId(ctx?.accountId),

package/src/plugin/outbox-drain-loop.ts

@@ -295,8 +295,8 @@ export function createBncrOutboxDrainLoop(
     try {
       pushed = await runtime.tryPushEntry(entry);
     } catch (error) {
-      const meta = runtime.isPlainObject(entry.payload?._meta) ? entry.payload._meta : null;
-      if (meta?.kind === 'file-transfer') {
+      const msg = runtime.isPlainObject(entry.payload?.message) ? entry.payload.message : null;
+      if (msg?.transferMode === 'media') {
         runtime.handleFileTransferPushFailure({ entry, error });
       } else {
         runtime.handleTextPushFailure({ entry, error });

package/src/plugin/outbox-file-push-flow.ts

@@ -1,11 +1,11 @@
 import { resolveFileTransferGuard } from '../core/outbox-file-transfer-guards.ts';
-import { prepareFileTransferRouteSelection } from '../core/outbox-file-transfer-prep.ts';
+import { prepareRouteSelection } from '../core/outbox-file-transfer-prep.ts';
 import type { BncrConnection, OutboxEntry } from '../core/types.ts';
 import { selectOutboxFileTransferRouteCandidates } from '../messaging/outbound/queue-selectors.ts';
 
 export async function runBncrFileTransferOutboxPush(args: {
   entry: OutboxEntry;
-  meta: Record<string, unknown>;
+  msg: Record<string, unknown>;
   gatewayContext: unknown;
   owner: BncrConnection | null;
   resolvePushConnIds: (accountId: string) => Set<string>;
@@ -18,7 +18,7 @@ export async function runBncrFileTransferOutboxPush(args: {
   }) => void;
   pushFileTransferSuccessPath: (args: {
     entry: OutboxEntry;
-    meta: Record<string, unknown>;
+    msg: Record<string, unknown>;
     owner: BncrConnection | null;
     connIds: Iterable<string>;
     recentInboundReachable: boolean;
@@ -27,21 +27,21 @@ export async function runBncrFileTransferOutboxPush(args: {
   }) => Promise<void>;
   handleFileTransferPushFailure: (args: { entry: OutboxEntry; error: unknown }) => void;
 }) {
-  const selection = prepareFileTransferRouteSelection({
+  const selection = prepareRouteSelection({
     entry: args.entry,
     owner: args.owner,
     resolvePushConnIds: args.resolvePushConnIds,
     resolveRecentInboundConnIds: args.resolveRecentInboundConnIds,
     hasRecentInboundReachability: args.hasRecentInboundReachability,
     isRevalidatedAttemptedConn: args.isRevalidatedAttemptedConn,
-    selectOutboxFileTransferRouteCandidates,
+    selectRouteCandidates: selectOutboxFileTransferRouteCandidates,
   });
   const guard = resolveFileTransferGuard({
     gatewayContext: args.gatewayContext,
     entry: args.entry,
     owner: args.owner,
     routeSelection: selection,
-    mediaUrl: String(args.meta.mediaUrl || '').trim(),
+    mediaUrl: String(args.msg.mediaUrl || '').trim(),
   });
   if (!guard.ok) {
     args.handleFileTransferPushGuardFailure({
@@ -54,7 +54,7 @@ export async function runBncrFileTransferOutboxPush(args: {
   try {
     await args.pushFileTransferSuccessPath({
       entry: args.entry,
-      meta: args.meta,
+      msg: args.msg,
       owner: args.owner,
       connIds: guard.connIds,
       recentInboundReachable: guard.recentInboundReachable,

package/src/plugin/outbox-text-push-flow.ts

@@ -43,7 +43,7 @@ export async function runBncrTextOutboxPush(args: {
     resolveRecentInboundConnIds: args.resolveRecentInboundConnIds,
     hasRecentInboundReachability: args.hasRecentInboundReachability,
     isRevalidatedAttemptedConn: args.isRevalidatedAttemptedConn,
-    selectOutboxRouteCandidates,
+    selectRouteCandidates: selectOutboxRouteCandidates,
   });
   const guard = resolveTextPushGuard({
     gatewayContext: args.gatewayContext,

package/src/plugin/target-runtime.ts

@@ -6,15 +6,10 @@ import {
   routeKey,
 } from '../core/targets.ts';
 import type { BncrRoute } from '../core/types.ts';
+import { asString } from '../core/value-sanitize.ts';
 import { getOpenClawRuntimeConfigOrDefault } from '../openclaw/config-runtime.ts';
 import type { BncrChannelConfigRoot } from './channel-runtime-types.ts';
 
-function asString(v: unknown, fallback = ''): string {
-  if (typeof v === 'string') return v;
-  if (v == null) return fallback;
-  return String(v);
-}
-
 export function createBncrTargetRuntime(runtime: {
   api: Parameters<typeof getOpenClawRuntimeConfigOrDefault>[0];
   channelId: string;

package/src/runtime/outbound-ack-timeout.ts

@@ -1,4 +1,5 @@
 import type { BncrAckObservability, BncrAckStrategy } from '../core/types.ts';
+import { asString, finiteNumberOr } from '../core/value-sanitize.ts';
 
 type ComputeBncrRecommendedAckTimeoutArgs = {
   lateAckOkCount: number;
@@ -76,14 +77,6 @@ export function resolveBncrRuntimeAckTimeoutDecision(args: ComputeBncrRecommende
   return { timeoutMs, reason };
 }
 
-function finiteNumberOr(value: unknown, fallback: number) {
-  return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
-}
-
-function asString(value: unknown, fallback = '') {
-  return typeof value === 'string' ? value : fallback;
-}
-
 export function buildBncrRuntimeAckStrategy(args: {
   ackObservability: BncrAckObservability;
   defaultAckTimeoutMs: number;

package/src/runtime/outbox-transitions.ts

@@ -1,4 +1,5 @@
 import type { OutboxEntry } from '../core/types.ts';
+import { finiteNumberOr } from '../core/value-sanitize.ts';
 import type {
   PushFailureDecision,
   RetryRerouteDecision,
@@ -83,10 +84,6 @@ export function buildBncrOutboxPushSuccessEntryPatch(args: {
   };
 }
 
-function finiteNumberOr(value: unknown, fallback: number): number {
-  return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
-}
-
 export function buildBncrAckOkTelemetryPatch(args: {
   entry: OutboxEntry;
   ackAt: number;

package/src/runtime/status-worker.ts

@@ -1,5 +1,6 @@
 import { normalizeAccountId } from '../core/accounts.ts';
 import type { BncrDiagnosticsSummary } from '../core/types.ts';
+import { finiteNumberOr, nonNegativeFiniteNumberOr } from '../core/value-sanitize.ts';
 
 type StatusRuntimeMeta = {
   pending?: number;
@@ -60,15 +61,6 @@ export function createHealthStatusLogState(): HealthStatusLogState {
   return { emittedSig: null, pendingSig: null, pendingSince: 0 };
 }
 
-function finiteNumberOr(value: unknown, fallback: number): number {
-  const n = Number(value);
-  return Number.isFinite(n) ? n : fallback;
-}
-
-function nonNegativeFiniteNumberOr(value: unknown, fallback: number): number {
-  return Math.max(0, finiteNumberOr(value, fallback));
-}
-
 export function updateHealthStatusLogState(args: {
   state: HealthStatusLogState;
   sig: string;

package/src/messaging/outbound/build-send-action.ts

@@ -1,130 +0,0 @@
-import { randomUUID } from 'node:crypto';
-
-type MinimalBncrSendInput = {
-  channel?: string;
-  action?: string;
-  idempotencyKey?: string;
-  accountId?: string;
-  to?: string;
-  message?: string;
-  caption?: string;
-  path?: string;
-  media?: string;
-  filePath?: string;
-  mediaUrl?: string;
-  mediaUrls?: string[];
-  asVoice?: boolean;
-  audioAsVoice?: boolean;
-  params?: Record<string, unknown>;
-};
-
-type BuiltBncrMessageAction = {
-  channel: string;
-  action: string;
-  idempotencyKey: string;
-  accountId?: string;
-  params: Record<string, unknown>;
-};
-
-function asString(v: unknown, fallback = ''): string {
-  if (typeof v === 'string') return v;
-  if (v == null) return fallback;
-  return String(v);
-}
-
-function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-
-function pickFirstString(...values: unknown[]): string | undefined {
-  for (const value of values) {
-    if (typeof value !== 'string') continue;
-    if (value.length === 0) return '';
-    return value;
-  }
-  return undefined;
-}
-
-function pickFirstBoolean(...values: unknown[]): boolean | undefined {
-  for (const value of values) {
-    if (typeof value === 'boolean') return value;
-  }
-  return undefined;
-}
-
-export function buildBncrMessageAction(input: MinimalBncrSendInput): BuiltBncrMessageAction {
-  const paramsObj = isPlainObject(input.params) ? input.params : {};
-
-  const channel = asString(input.channel || 'bncr').trim() || 'bncr';
-  const action = asString(input.action || 'send').trim() || 'send';
-  const idempotencyKey = asString(input.idempotencyKey || '').trim() || `bncr-${randomUUID()}`;
-  const accountId =
-    asString(pickFirstString(paramsObj.accountId, input.accountId) || '').trim() || undefined;
-
-  const to = asString(pickFirstString(paramsObj.to, input.to) || '').trim();
-  if (!to) throw new Error('bncr send requires to');
-
-  const mediaPath = pickFirstString(
-    paramsObj.media,
-    paramsObj.path,
-    paramsObj.filePath,
-    paramsObj.mediaUrl,
-    input.media,
-    input.path,
-    input.filePath,
-    input.mediaUrl,
-  );
-  const rawMediaUrls = Array.isArray(paramsObj.mediaUrls)
-    ? paramsObj.mediaUrls
-    : Array.isArray(input.mediaUrls)
-      ? input.mediaUrls
-      : undefined;
-  const mediaUrls = rawMediaUrls?.map((value) => asString(value || '').trim()).filter(Boolean);
-
-  const message = pickFirstString(paramsObj.message, input.message) ?? '';
-  const explicitCaption = pickFirstString(paramsObj.caption, input.caption) ?? '';
-  const asVoice = pickFirstBoolean(paramsObj.asVoice, input.asVoice);
-  const audioAsVoice = pickFirstBoolean(paramsObj.audioAsVoice, input.audioAsVoice);
-
-  if ((asVoice === true || audioAsVoice === true) && !mediaPath && !mediaUrls?.length) {
-    throw new Error('bncr voice send requires media path');
-  }
-
-  const normalizedParams: Record<string, unknown> = {
-    ...paramsObj,
-    to,
-  };
-
-  if (mediaPath) {
-    normalizedParams.path = mediaPath;
-    const finalCaption = explicitCaption || message;
-    if (finalCaption) normalizedParams.caption = finalCaption;
-    delete normalizedParams.message;
-    if (mediaUrls?.length) normalizedParams.mediaUrls = mediaUrls;
-  } else {
-    if (mediaUrls?.length) {
-      normalizedParams.mediaUrls = mediaUrls;
-      const finalCaption = explicitCaption || message;
-      if (finalCaption) normalizedParams.caption = finalCaption;
-      delete normalizedParams.message;
-      delete normalizedParams.path;
-    } else {
-      const finalMessage = message || explicitCaption;
-      if (!finalMessage.trim()) throw new Error('bncr send requires message or media');
-      normalizedParams.message = finalMessage;
-      delete normalizedParams.caption;
-    }
-  }
-
-  if (asVoice === true) normalizedParams.asVoice = true;
-  if (audioAsVoice === true) normalizedParams.audioAsVoice = true;
-  if (accountId) normalizedParams.accountId = accountId;
-
-  return {
-    channel,
-    action,
-    idempotencyKey,
-    ...(accountId ? { accountId } : {}),
-    params: normalizedParams,
-  };
-}