@xmoxmo/bncr 0.5.7 → 0.5.8

package/src/messaging/outbound/marker-parser.ts

@@ -12,8 +12,13 @@
  * - Incomplete marker (no closing ]) → left in text, does NOT block later
  *   complete markers.
  * - Multiple valid markers → all stripped, params merge (later same-key wins).
+ * - When path/paths/mediaUrl/mediaUrls are present, probe for reachability.
+ *   Unreachable single paths keep the marker visible in the output text.
+ *   Unreachable entries in path arrays are dropped with warnings logged.
  */
 
+import fs from 'node:fs';
+
 const PREFIX = '[BncrParam:';
 
 /**
@@ -186,3 +191,213 @@ export function extractConsumptionFields(extra: Record<string, unknown> | undefi
     remaining,
   };
 }
+
+// ---------------------------------------------------------------------------
+// Media path probing
+// ---------------------------------------------------------------------------
+
+const PROBE_TIMEOUT_MS = 5_000;
+const MEDIA_PATH_KEYS = new Set(['path', 'paths', 'mediaUrl', 'mediaUrls']);
+
+function hasMediaPathParams(params: Record<string, unknown>): boolean {
+  for (const key of MEDIA_PATH_KEYS) {
+    if (key in params) return true;
+  }
+  return false;
+}
+
+/**
+ * Check whether a single media path (HTTP URL or local file) is reachable.
+ *
+ * - HTTP/HTTPS URLs → HEAD request with short timeout (5 s), follows redirects.
+ * - Local files → fs.existsSync.
+ *
+ * Returns `{ ok, reason }` where `reason` describes the failure when `ok` is false.
+ */
+async function probeMediaPath(raw: string): Promise<{
+  ok: boolean;
+  reason?: string;
+}> {
+  const path = String(raw || '').trim();
+  if (!path) return { ok: false, reason: 'empty path' };
+
+  // HTTP(S) URL — HEAD probe
+  if (path.startsWith('http://') || path.startsWith('https://')) {
+    try {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+      const response = await fetch(path, {
+        method: 'HEAD',
+        signal: controller.signal,
+        redirect: 'follow',
+      });
+      clearTimeout(timer);
+      if (response.ok || response.status === 206) return { ok: true };
+      return { ok: false, reason: `HTTP ${response.status} ${response.statusText}` };
+    } catch (err: unknown) {
+      const reason = err instanceof Error ? err.message : String(err);
+      return { ok: false, reason };
+    }
+  }
+
+  // Local file
+  try {
+    if (fs.existsSync(path)) return { ok: true };
+    return { ok: false, reason: 'file not found' };
+  } catch {
+    return { ok: false, reason: 'unreadable path' };
+  }
+}
+
+/**
+ * After JSON marker parsing, probe any media paths found in the params.
+ *
+ * - Single path (`path` / `mediaUrl`): if unreachable, keeps the marker in text
+ *   (returns allValid=false, warnings populated).
+ * - Path arrays (`paths` / `mediaUrls`): unreachable entries are removed; if at
+ *   least one entry is valid the marker is still stripped.  If ALL entries are
+ *   invalid the marker is kept.
+ *
+ * Returns `{ params, warnings, allValid }`:
+ * - `params` — (potentially filtered) params with invalid array entries removed.
+ * - `warnings` — human-readable warning strings for each unreachable path.
+ * - `allValid` — false when a single path or all array entries are unreachable.
+ */
+async function probeAndResolveMarkerPaths(params: Record<string, unknown>): Promise<{
+  params: Record<string, unknown>;
+  warnings: string[];
+  allValid: boolean;
+}> {
+  const warnings: string[] = [];
+  if (!hasMediaPathParams(params)) return { params, warnings, allValid: true };
+
+  // Single path / mediaUrl
+  const singlePath = String(params.path ?? params.mediaUrl ?? '').trim();
+  if (singlePath) {
+    const result = await probeMediaPath(singlePath);
+    if (!result.ok) {
+      warnings.push(`path ${singlePath} unreachable: ${result.reason}`);
+      return { params, warnings, allValid: false };
+    }
+    // Path confirmed reachable — signal downstream that media is validated
+    // Only set ismedia:true when user hasn't explicitly opted out.
+    if (!('ismedia' in params && params.ismedia === false)) {
+      params = { ...params, ismedia: true };
+    }
+    return { params, warnings, allValid: true };
+  }
+
+  // Path arrays — paths / mediaUrls
+  const arraySource = (params.paths ?? params.mediaUrls) as unknown;
+  if (Array.isArray(arraySource) && arraySource.length > 0) {
+    const entries = arraySource.filter(
+      (v): v is string => typeof v === 'string' && v.trim().length > 0,
+    );
+    if (entries.length === 0) return { params, warnings, allValid: true };
+
+    const results = await Promise.all(entries.map((p) => probeMediaPath(p)));
+    const valid: string[] = [];
+    for (let i = 0; i < entries.length; i++) {
+      if (results[i].ok) {
+        valid.push(entries[i]);
+      } else {
+        warnings.push(`path ${entries[i]} unreachable: ${results[i].reason}`);
+      }
+    }
+
+    if (valid.length === 0) {
+      // All invalid → keep marker
+      return { params, warnings, allValid: false };
+    }
+    // At least one valid → strip marker, replace with filtered entries.
+    // Only set ismedia=true when user hasn't explicitly opted out.
+    const setMedia = !('ismedia' in params && params.ismedia === false);
+    params = { ...params, ...(setMedia ? { ismedia: true } : {}), paths: valid, mediaUrls: valid };
+  }
+
+  return { params, warnings, allValid: true };
+}
+
+/**
+ * Parse text markers AND probe media paths in one async step.
+ *
+/**
+ * Unified marker strip decision: the single place that decides whether to strip
+ * a [BncrParam:...] marker from the text or leave it in place.
+ *
+ * - Markers that JSON parse successfully AND whose media paths (if any) are
+ *   reachable → stripped from text, params extracted and merged.
+ * - Markers whose paths are unreachable (single path OR all array entries) →
+ *   kept in text, NOT stripped, NOT extracted.
+ * - Markers without path fields → stripped as normal (existing behavior).
+ * - Markers that fail JSON parse → kept in text (existing behavior).
+ * - Multiple markers → each evaluated independently, later markers' params
+ *   overwrite earlier ones when the same key appears.
+ *
+ * This function IS the single decision point.  Downstream consumers of the
+ * returned text never re-parse markers — they trust the decision made here.
+ */
+export async function resolveMarkerStripDecision(text: string): Promise<{
+  cleanText: string;
+  params: Record<string, unknown>;
+  warnings: string[];
+}> {
+  const params: Record<string, unknown> = {};
+  const warnings: string[] = [];
+  let result = text;
+  let searchFrom = 0;
+  const hadMarkers = text.includes(PREFIX);
+
+  if (!hadMarkers) return { cleanText: text, params, warnings };
+
+  while (true) {
+    const idx = result.indexOf(PREFIX, searchFrom);
+    if (idx === -1) break;
+
+    const end = findMarkerEnd(result, idx);
+    if (end === -1) {
+      searchFrom = idx + PREFIX.length;
+      continue;
+    }
+
+    const rawJson = result.slice(idx + PREFIX.length, end);
+    let parsed: Record<string, unknown> | null = null;
+    try {
+      const obj = JSON.parse(rawJson);
+      if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
+        parsed = obj as Record<string, unknown>;
+      }
+    } catch {
+      // JSON parse failed → keep marker in text, continue scanning after it
+      searchFrom = end + 1;
+      continue;
+    }
+
+    // JSON parsed but is not a plain object → keep marker in text
+    if (!parsed) {
+      searchFrom = end + 1;
+      continue;
+    }
+
+    // Marker has path fields → probe before deciding to strip
+    if (hasMediaPathParams(parsed)) {
+      const probeResult = await probeAndResolveMarkerPaths(parsed);
+      if (probeResult.warnings.length > 0) warnings.push(...probeResult.warnings);
+      if (!probeResult.allValid) {
+        // Path(s) unreachable → keep marker in text, do NOT extract any params
+        searchFrom = end + 1;
+        continue;
+      }
+      // Paths valid → strip, merge params (probeResult.params includes ismedia:true + filtered arrays)
+      Object.assign(params, probeResult.params);
+    } else {
+      // No path fields → strip marker and merge params unconditionally
+      Object.assign(params, parsed);
+    }
+    result = result.slice(0, idx) + result.slice(end + 1);
+    searchFrom = idx;
+  }
+
+  const cleanText = result !== text ? result.replace(/ {2,}/g, ' ').trim() : result;
+  return { cleanText, params, warnings };
+}

package/src/messaging/outbound/media-dedupe.ts

@@ -15,10 +15,7 @@ export function normalizeMessageText(value: unknown): string {
   return asString(value || '').trim();
 }
 
-export function shouldTreatReplyToAsSame(
-  currentReplyToId: string,
-  previousReplyToId: string,
-): boolean {
+function shouldTreatReplyToAsSame(currentReplyToId: string, previousReplyToId: string): boolean {
   if (!currentReplyToId || !previousReplyToId) return true;
   return currentReplyToId === previousReplyToId;
 }

package/src/messaging/outbound/normalize-outbound-send.ts

@@ -12,7 +12,7 @@
  */
 
 import { asString, isPlainObject } from '../../core/value-sanitize.ts';
-import { extractConsumptionFields, parseBncrMarker } from './marker-parser.ts';
+import { extractConsumptionFields, resolveMarkerStripDecision } from './marker-parser.ts';
 
 const MEDIA_SOURCE_EXTRA_KEYS = ['path', 'paths', 'mediaUrl', 'mediaUrls'] as const;
 
@@ -104,13 +104,13 @@ function buildBranchExtra(args: {
  * Parse markers from one or more text fields and merge extras.
  * Marker params always override host/params extra and host control flags.
  */
-export function mergeMarkerAndHostFields(args: {
+export async function mergeMarkerAndHostFields(args: {
   texts: string[];
   hostExtra?: Record<string, unknown>;
   forceDocument?: boolean;
   gifPlayback?: boolean;
   silent?: boolean;
-}): {
+}): Promise<{
   cleanTexts: string[];
   markerParams: Record<string, unknown>;
   consumed: Partial<{
@@ -124,12 +124,12 @@ export function mergeMarkerAndHostFields(args: {
   }>;
   remaining: Record<string, unknown>;
   markerHasMsg: boolean;
-} {
+}> {
   const markerParams: Record<string, unknown> = {};
   const cleanTexts: string[] = [];
 
   for (const raw of args.texts) {
-    const { cleanText, params } = parseBncrMarker(raw);
+    const { cleanText, params } = await resolveMarkerStripDecision(raw);
     cleanTexts.push(cleanText);
     Object.assign(markerParams, params);
   }
@@ -222,13 +222,15 @@ function resolveDispatchMediaSources(args: {
  * Normalize any outbound send input into a single dispatch shape.
  * Callers only need to branch on `hasMedia` after this.
  */
-export function normalizeOutboundSend(input: UnifiedOutboundSendInput): NormalizedOutboundSend {
+export async function normalizeOutboundSend(
+  input: UnifiedOutboundSendInput,
+): Promise<NormalizedOutboundSend> {
   const rawText = asString(input.text ?? input.message ?? '', '');
   const rawCaption = asString(input.caption ?? '', '');
   // Prefer text/message; also parse caption so marker in either field works.
   const textsToParse = rawCaption && rawCaption !== rawText ? [rawText, rawCaption] : [rawText];
 
-  const { cleanTexts, consumed, remaining, markerHasMsg } = mergeMarkerAndHostFields({
+  const { cleanTexts, consumed, remaining, markerHasMsg } = await mergeMarkerAndHostFields({
     texts: textsToParse,
     hostExtra: isPlainObject(input.extra) ? input.extra : undefined,
     forceDocument: input.forceDocument,

package/src/messaging/outbound/reply-enqueue-media.ts

@@ -1,187 +1,4 @@
-import { buildBncrDebugJsonMessage } from '../../core/logging.ts';
-import type { BncrRoute, OutboxEntry } from '../../core/types.ts';
-import { buildReplyMediaFallbackDebugInfo } from './diagnostics.ts';
-import type {
-  EnqueueSingleReplyMediaEntryParams,
-  NormalizedReplyPayload,
-  ReplyMediaEntriesParams,
-  ReplyMediaFallbackTextEntryParams,
-  ReplyMediaFileTransferParams,
-} from './reply-enqueue.ts';
-import type { OutboundReplyTargetPolicy } from './reply-target-policy.ts';
-
-export function enqueueReplyMediaFallbackTextEntry(
-  params: ReplyMediaFallbackTextEntryParams,
-  helpers: {
-    logInfo: (
-      scope: string | undefined,
-      message: string,
-      options?: { debugOnly?: boolean },
-    ) => void;
-    enqueueOutbound: (entry: OutboxEntry) => void;
-    buildTextOutboxEntry: (args: {
-      accountId: string;
-      sessionKey: string;
-      route: BncrRoute;
-      text: string;
-      extra?: Record<string, unknown>;
-      kind?: 'tool' | 'block' | 'final';
-      replyToId?: string;
-      replyTargetPolicy?: OutboundReplyTargetPolicy;
-    }) => OutboxEntry;
-  },
-): void {
-  helpers.logInfo(
-    'outbound',
-    buildBncrDebugJsonMessage('media-dedupe-hit', buildReplyMediaFallbackDebugInfo(params)),
-    { debugOnly: true },
-  );
-  helpers.enqueueOutbound(
-    helpers.buildTextOutboxEntry({
-      accountId: params.accountId,
-      sessionKey: params.sessionKey,
-      route: params.route,
-      text: params.fallback.text,
-      kind: params.kind,
-      replyToId: params.replyToId || undefined,
-      replyTargetPolicy: params.replyTargetPolicy,
-    }),
-  );
-}
-
-export function enqueueReplyMediaFileTransferEntry(
-  params: ReplyMediaFileTransferParams,
-  helpers: {
-    enqueueOutbound: (entry: OutboxEntry) => void;
-    buildFileTransferOutboxEntry: (args: {
-      accountId: string;
-      sessionKey: string;
-      route: BncrRoute;
-      mediaUrl: string;
-      mediaLocalRoots?: readonly string[];
-      text: string;
-      asVoice: boolean;
-      audioAsVoice: boolean;
-      downloadMedia?: boolean;
-      type?: string;
-      extra?: Record<string, unknown>;
-      kind?: 'tool' | 'block' | 'final';
-      replyToId?: string;
-      replyTargetPolicy?: OutboundReplyTargetPolicy;
-    }) => OutboxEntry;
-    rememberRecentMediaSend: (args: {
-      sessionKey: string;
-      mediaUrl: string;
-      text: string;
-      replyToId: string;
-      createdAt: number;
-    }) => void;
-  },
-): void {
-  helpers.enqueueOutbound(
-    helpers.buildFileTransferOutboxEntry({
-      accountId: params.accountId,
-      sessionKey: params.sessionKey,
-      route: params.route,
-      mediaUrl: params.mediaUrl,
-      mediaLocalRoots: params.mediaLocalRoots,
-      text: params.text,
-      asVoice: params.asVoice,
-      audioAsVoice: params.audioAsVoice,
-      downloadMedia: params.downloadMedia,
-      type: params.type,
-      extra: params.extra,
-      kind: params.kind,
-      replyToId: params.replyToId || undefined,
-      replyTargetPolicy: params.replyTargetPolicy,
-    }),
-  );
-  helpers.rememberRecentMediaSend({
-    sessionKey: params.sessionKey,
-    mediaUrl: params.mediaUrl,
-    text: params.normalizedText,
-    replyToId: params.replyToId,
-    createdAt: params.createdAt,
-  });
-}
-
-export function enqueueSingleReplyMediaEntry(
-  params: EnqueueSingleReplyMediaEntryParams,
-  helpers: {
-    enqueueReplyMediaFallbackTextEntry: (params: ReplyMediaFallbackTextEntryParams) => void;
-    enqueueReplyMediaFileTransferEntry: (params: ReplyMediaFileTransferParams) => void;
-  },
-): void {
-  if (params.fallback !== null) {
-    helpers.enqueueReplyMediaFallbackTextEntry({
-      accountId: params.params.accountId,
-      sessionKey: params.params.sessionKey,
-      route: params.params.route,
-      mediaUrl: params.mediaUrl,
-      kind: params.params.payload.kind,
-      replyToId: params.params.payload.replyToId,
-      replyTargetPolicy: params.params.payload.replyTargetPolicy,
-      fallback: params.fallback,
-    });
-    return;
-  }
-
-  helpers.enqueueReplyMediaFileTransferEntry({
-    accountId: params.params.accountId,
-    sessionKey: params.params.sessionKey,
-    route: params.params.route,
-    mediaUrl: params.mediaUrl,
-    mediaLocalRoots: params.params.mediaLocalRoots,
-    text: params.text,
-    normalizedText: params.normalizedText,
-    asVoice: params.params.payload.asVoice,
-    audioAsVoice: params.params.payload.audioAsVoice,
-    downloadMedia: params.params.payload.downloadMedia,
-    type: params.params.payload.type,
-    extra: params.params.payload.extra,
-    kind: params.params.payload.kind,
-    replyToId: params.params.payload.replyToId,
-    replyTargetPolicy: params.params.payload.replyTargetPolicy,
-    createdAt: params.currentTime,
-  });
-}
-
-export function enqueueReplyMediaEntries(
-  params: ReplyMediaEntriesParams,
-  helpers: {
-    now: () => number;
-    normalizeMessageText: (text: string) => string;
-    tryBuildMediaDedupeFallback: (args: {
-      sessionKey: string;
-      mediaUrl: string;
-      text: string;
-      replyToId: string;
-      currentTime: number;
-    }) => { text: string; reason: string } | null;
-    enqueueSingleReplyMediaEntry: (params: EnqueueSingleReplyMediaEntryParams) => void;
-  },
-): void {
-  const currentTime = helpers.now();
-  const normalizedText = helpers.normalizeMessageText(params.payload.text);
-
-  for (const mediaUrl of params.payload.mediaList) {
-    const fallback = helpers.tryBuildMediaDedupeFallback({
-      sessionKey: params.sessionKey,
-      mediaUrl,
-      text: normalizedText,
-      replyToId: params.payload.replyToId,
-      currentTime,
-    });
-    helpers.enqueueSingleReplyMediaEntry({
-      params,
-      mediaUrl,
-      normalizedText,
-      text: params.payload.text,
-      fallback,
-      currentTime,
-    });
-  }
-}
+import type { NormalizedReplyPayload } from './reply-enqueue.ts';
 
 export function hasReplyMediaEntries(payload: NormalizedReplyPayload) {
   return payload.mediaList.length > 0;