@xmoxmo/bncr 0.3.6 → 0.3.8

package/src/plugin/bridge-status-worker-facade.ts

@@ -0,0 +1,72 @@
+import type { BncrConnection } from '../core/types.ts';
+import type { ChannelAccountWorkerHandle } from '../runtime/status-worker.ts';
+import {
+  buildStatusWorkerActiveConnections,
+  buildStatusWorkerLastEventAt,
+} from './bridge-surface-helpers.ts';
+
+export function createBncrBridgeStatusWorkerFacade(runtime: {
+  workers: Map<string, ChannelAccountWorkerHandle>;
+  bridgeId: string;
+  isOnline: (accountId: string) => boolean;
+  hasRecentInboundReachability: (accountId: string) => boolean;
+  lastActivityByAccount: Map<string, number>;
+  lastInboundByAccount: Map<string, number>;
+  lastOutboundByAccount: Map<string, number>;
+  getActiveConnectionKey: (accountId: string) => string | null;
+  connectionsValues: () => Iterable<BncrConnection>;
+  buildStatusMeta: (accountId: string) => {
+    pending?: number;
+    pendingAdmissionsCount?: number;
+    pendingAdmissions?: unknown[];
+    deadLetter?: number;
+    lastSessionScope?: string | null;
+    lastSessionAt?: number | null;
+    lastSessionAgo?: string | null;
+    lastActivityAt?: number | null;
+    lastActivityAgo?: string | null;
+    lastInboundAt?: number | null;
+    lastInboundAgo?: string | null;
+    lastOutboundAt?: number | null;
+    lastOutboundAgo?: string | null;
+    diagnostics?: Record<string, unknown>;
+  };
+  logInfo: (scope: string | undefined, message: string, options?: { debugOnly?: boolean }) => void;
+  logInfoDedup: (
+    scope: string | undefined,
+    message: string,
+    options: { key: string; sig: string; debugOnly?: boolean; windowMs?: number },
+  ) => void;
+}) {
+  return {
+    workers: runtime.workers,
+    bridgeId: runtime.bridgeId,
+    hooks: {
+      isOnline: (accountId: string) => runtime.isOnline(accountId),
+      hasRecentInboundReachability: (accountId: string) =>
+        runtime.hasRecentInboundReachability(accountId),
+      getLastActivityAt: (accountId: string, previous: { lastEventAt?: number | null }) =>
+        buildStatusWorkerLastEventAt({
+          accountId,
+          previous,
+          lastActivityByAccount: runtime.lastActivityByAccount,
+          lastInboundByAccount: runtime.lastInboundByAccount,
+          lastOutboundByAccount: runtime.lastOutboundByAccount,
+        }),
+      getActiveConnectionKey: (accountId: string) => runtime.getActiveConnectionKey(accountId),
+      getActiveConnections: (accountId: string) =>
+        buildStatusWorkerActiveConnections({
+          accountId,
+          connections: runtime.connectionsValues(),
+        }),
+      buildStatusMeta: (accountId: string) => runtime.buildStatusMeta(accountId),
+      logInfo: (scope: string | undefined, message: string, options?: { debugOnly?: boolean }) =>
+        runtime.logInfo(scope, message, options),
+      logInfoDedup: (
+        scope: string | undefined,
+        message: string,
+        options: { key: string; sig: string; debugOnly?: boolean; windowMs?: number },
+      ) => runtime.logInfoDedup(scope, message, options),
+    },
+  };
+}

package/src/plugin/bridge-support-runtime.ts

@@ -0,0 +1,137 @@
+import { asSanitizedString } from '../core/value-sanitize.ts';
+import type { BncrChannelConfigRoot } from './channel-runtime-types.ts';
+
+export function createBridgeSupportRuntime(args: {
+  isStopped: () => boolean;
+  hasSaveTimer: () => boolean;
+  setSaveTimer: (timer: NodeJS.Timeout | null) => void;
+  flushState: () => Promise<void>;
+  normalizeAccountId: (accountId: string) => string;
+  getCounterValue: (map: Map<string, number>, accountId: string) => number;
+  getRuntimeConfig: () => unknown;
+  channelId: string;
+  readCurrentCanonicalAgentId: () => string | null;
+  resolveAgentRoute: (args: {
+    cfg: BncrChannelConfigRoot;
+    channel: string;
+    accountId: string;
+    peer?: unknown;
+  }) => { agentId?: unknown } | null;
+  readCachedCanonicalAgentId: () => string | null;
+  writeCachedCanonicalAgentId: (agentId: string) => void;
+  logInfo: (scope: string, message: string, options?: { debugOnly?: boolean }) => void;
+  logWarn: (scope: string, message: string, options?: { debugOnly?: boolean }) => void;
+  readDebugVerbose: () => boolean;
+  writeDebugVerbose: (value: boolean) => void;
+}) {
+  const scheduleSave = () => {
+    if (args.isStopped()) return;
+    if (args.hasSaveTimer()) return;
+    args.setSaveTimer(
+      setTimeout(() => {
+        args.setSaveTimer(null);
+        if (args.isStopped()) return;
+        void args.flushState();
+      }, 300),
+    );
+  };
+
+  const incrementCounter = (map: Map<string, number>, accountId: string) => {
+    const acc = args.normalizeAccountId(accountId);
+    map.set(acc, args.getCounterValue(map, acc) + 1);
+  };
+
+  const getCounter = (map: Map<string, number>, accountId: string): number => {
+    return args.getCounterValue(map, args.normalizeAccountId(accountId));
+  };
+
+  const refreshDebugFlagFromConfig = async (options?: { forceLog?: boolean }) => {
+    try {
+      const cfg = args.getRuntimeConfig() as {
+        channels?: Record<string, { debug?: { verbose?: unknown } }>;
+      };
+      const raw = cfg?.channels?.[args.channelId]?.debug?.verbose;
+      const next = typeof raw === 'boolean' ? raw : false;
+      const changed = next !== args.readDebugVerbose();
+      args.writeDebugVerbose(next);
+      if (changed || options?.forceLog) {
+        args.logInfo('debug', `verbose=${next}`, { debugOnly: true });
+      }
+    } catch {
+      // ignore config read errors
+    }
+  };
+
+  const syncDebugFlag = async () => {
+    await refreshDebugFlagFromConfig();
+  };
+
+  const tryResolveBindingAgentId = (resolveArgs: {
+    cfg: BncrChannelConfigRoot;
+    accountId: string;
+    peer?: unknown;
+    channelId?: string;
+  }): string | null => {
+    try {
+      const resolved = args.resolveAgentRoute({
+        cfg: resolveArgs.cfg,
+        channel: resolveArgs.channelId || args.channelId,
+        accountId: args.normalizeAccountId(resolveArgs.accountId),
+        peer: resolveArgs.peer,
+      });
+      const agentId = asSanitizedString(resolved?.agentId || '').trim();
+      return agentId || null;
+    } catch {
+      return null;
+    }
+  };
+
+  const initializeCanonicalAgentId = (cfg: BncrChannelConfigRoot) => {
+    if (args.readCachedCanonicalAgentId()) return;
+    const agentId = tryResolveBindingAgentId({
+      cfg,
+      accountId: 'Primary',
+      channelId: args.channelId,
+      peer: { kind: 'direct', id: 'bootstrap' },
+    });
+    if (!agentId) return;
+    args.writeCachedCanonicalAgentId(agentId);
+  };
+
+  const ensureCanonicalAgentId = (resolveArgs: {
+    cfg: BncrChannelConfigRoot;
+    accountId: string;
+    peer?: unknown;
+    channelId?: string;
+  }) => {
+    const cached = args.readCachedCanonicalAgentId();
+    if (cached) return cached;
+
+    const agentId = tryResolveBindingAgentId(resolveArgs);
+    if (agentId) {
+      args.writeCachedCanonicalAgentId(agentId);
+      return agentId;
+    }
+
+    args.writeCachedCanonicalAgentId('main');
+    args.logWarn(
+      'target',
+      'binding agent unresolved; fallback to main for current process lifetime',
+      {
+        debugOnly: true,
+      },
+    );
+    return 'main';
+  };
+
+  return {
+    scheduleSave,
+    incrementCounter,
+    getCounter,
+    refreshDebugFlagFromConfig,
+    syncDebugFlag,
+    tryResolveBindingAgentId,
+    initializeCanonicalAgentId,
+    ensureCanonicalAgentId,
+  };
+}

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

@@ -0,0 +1,242 @@
+import type { GatewayRequestHandlerOptions } from 'openclaw/plugin-sdk/core';
+import type { BncrExtendedDiagnostics } from '../core/extended-diagnostics.ts';
+import type {
+  BncrAccountRuntimeSnapshot,
+  buildIntegratedDiagnostics as buildIntegratedDiagnosticsFromRuntime,
+} from '../core/status.ts';
+import type {
+  BncrDeadLetterDiagnosticsSummary,
+  BncrDownlinkHealthSummary,
+  FileSendTransferState,
+  OutboxEntry,
+} from '../core/types.ts';
+import type { BncrRuntimeFlags } from '../runtime/outbound-flags.ts';
+import {
+  createBncrBridgeDiagnosticsHandlersComponent,
+  createBncrConnectionHandlersComponent,
+} from './channel-components.ts';
+import type { ConnectionQueueCounters } from './connection-handlers.ts';
+
+type DiagnosticsRuntimeStatusInput = Parameters<typeof buildIntegratedDiagnosticsFromRuntime>[0] & {
+  running: boolean | undefined;
+  channelRoot: string;
+};
+
+type DiagnosticsComponentRuntime = Parameters<
+  typeof createBncrBridgeDiagnosticsHandlersComponent
+>[0];
+type ConnectionComponentRuntime = Parameters<typeof createBncrConnectionHandlersComponent>[0];
+type DiagnosticsExtendedArgs = Parameters<
+  DiagnosticsComponentRuntime['buildExtendedDiagnostics']
+>[1];
+
+export function createBncrBridgeSurfaceHandlersGroup(runtime: {
+  bridgeId: string;
+  gatewayPid: number;
+  pushEvent: string;
+  bridgeVersion: number;
+  getApi: DiagnosticsComponentRuntime['getApi'];
+  channelId: string;
+  asString: (value: unknown, fallback?: string) => string;
+  now: () => number;
+  finiteNonNegativeNumberOrNull: (value: unknown) => number | null;
+  syncDebugFlag: () => Promise<void>;
+  logInfo: (scope: string, message: string, options?: { debugOnly?: boolean }) => void;
+  logWarn: (scope: string, message: string, options?: { debugOnly?: boolean }) => void;
+  normalizeAccountId: (value: string) => string;
+  pluginRoot: string;
+  buildAccountQueueCounters: (accountId: string) => ConnectionQueueCounters;
+  buildExtendedDiagnostics: (
+    accountId: string,
+    args?: DiagnosticsExtendedArgs,
+  ) => BncrExtendedDiagnostics;
+  buildRuntimeFlags: (accountId: string) => BncrRuntimeFlags;
+  buildRuntimeStatusInput: (
+    accountId: string,
+    overrides: {
+      running: boolean;
+      invalidOutboxSessionKeys?: number;
+      legacyAccountResidue?: number;
+    },
+  ) => DiagnosticsRuntimeStatusInput;
+  getAccountRuntimeSnapshot: (
+    accountId: string,
+    runtimeStatusInput: DiagnosticsRuntimeStatusInput,
+  ) => BncrAccountRuntimeSnapshot;
+  buildIntegratedDiagnostics: (
+    accountId: string,
+    runtimeStatusInput: DiagnosticsRuntimeStatusInput,
+  ) => ReturnType<typeof buildIntegratedDiagnosticsFromRuntime>;
+  buildDownlinkHealth: (accountId: string) => BncrDownlinkHealthSummary;
+  isPrimaryConnection: (accountId: string, clientId?: string) => boolean;
+  acceptConnection: () => { leaseId: string; connectionEpoch: number; acceptedAt: number };
+  refreshLiveConnectionState: (args: {
+    accountId: string;
+    connId: string;
+    clientId?: string;
+    outboundReady: boolean;
+    preferredForOutbound: boolean;
+    inboundOnly: boolean;
+    context: GatewayRequestHandlerOptions['context'];
+  }) => void;
+  flushOnConnect: (accountId: string) => void;
+  flushOnActivity: (accountId: string) => 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;
+  incrementConnectEvents: (accountId: string) => void;
+  incrementActivityEvents: (accountId: string) => void;
+  incrementAckEvents: (accountId: string) => void;
+  markLastActivityAt: () => void;
+  markLastAckAt: () => void;
+  messageAckWaiterCount: () => number;
+  fileAckWaiterCount: () => number;
+  prepareAckHandling: (args: {
+    params: GatewayRequestHandlerOptions['params'];
+    respond: GatewayRequestHandlerOptions['respond'];
+    client: GatewayRequestHandlerOptions['client'];
+    context: GatewayRequestHandlerOptions['context'];
+  }) => ReturnType<ConnectionComponentRuntime['prepareAckHandling']>;
+  handleAckOutcome: (
+    args: {
+      params: GatewayRequestHandlerOptions['params'];
+      respond: GatewayRequestHandlerOptions['respond'];
+    } & NonNullable<ReturnType<ConnectionComponentRuntime['prepareAckHandling']>>,
+  ) => void;
+  fileSendTransfers: Map<string, FileSendTransferState>;
+  hasFileAckWaiter: (key: string) => boolean;
+  fileAckKey: (transferId: string, stage: string, chunkIndex?: number) => string;
+  observeLease: (
+    kind:
+      | 'connect'
+      | 'inbound'
+      | 'activity'
+      | 'ack'
+      | 'file.init'
+      | 'file.chunk'
+      | 'file.complete'
+      | 'file.abort',
+    payload: { leaseId?: string; connectionEpoch?: number },
+  ) => { stale: boolean };
+  tryAdoptTransferOwner: (args: {
+    accountId: string;
+    transfer: FileSendTransferState | undefined;
+    connId: string;
+    clientId?: string;
+  }) => boolean;
+  refreshAcceptedFileTransferLiveState: (args: {
+    accountId: string;
+    connId: string;
+    clientId?: string;
+    context: GatewayRequestHandlerOptions['context'];
+  }) => void;
+  resolveFileAck: (args: {
+    transferId: string;
+    stage: string;
+    chunkIndex?: number;
+    payload: {
+      ok: boolean;
+      transferId: string;
+      stage: string;
+      path: string;
+      errorCode: string;
+      errorMessage: string;
+    };
+    ok: boolean;
+  }) => void;
+  countInvalidOutboxSessionKeys: (accountId: string) => number;
+  countLegacyAccountResidue: (accountId: string) => number;
+  activeConnectionCount: (accountId: string) => number;
+  getMessageAckWaiterCount: () => number;
+  getFileAckWaiterCount: () => number;
+  filterDeadLetterEntries: (args: {
+    accountId: string;
+    reason: string | null;
+    olderThan: number | null;
+  }) => OutboxEntry[];
+  listDeadLetterEntries: () => OutboxEntry[];
+  buildDeadLetterDiagnostics: (accountId: string) => BncrDeadLetterDiagnosticsSummary;
+  replaceDeadLetterEntries: (nextEntries: OutboxEntry[]) => void;
+  scheduleSave: () => void;
+  logDeadLetterSummary: (accountId: string, args: { force: boolean; source: string }) => void;
+}) {
+  const connectionHandlers = createBncrConnectionHandlersComponent({
+    bridgeId: runtime.bridgeId,
+    gatewayPid: runtime.gatewayPid,
+    pushEvent: runtime.pushEvent,
+    bridgeVersion: runtime.bridgeVersion,
+    asString: runtime.asString,
+    now: runtime.now,
+    finiteNonNegativeNumberOrNull: runtime.finiteNonNegativeNumberOrNull,
+    syncDebugFlag: runtime.syncDebugFlag,
+    logInfo: runtime.logInfo,
+    logWarn: runtime.logWarn,
+    normalizeAccountId: runtime.normalizeAccountId,
+    buildAccountQueueCounters: runtime.buildAccountQueueCounters,
+    buildExtendedDiagnostics: runtime.buildExtendedDiagnostics,
+    buildRuntimeFlags: runtime.buildRuntimeFlags,
+    isPrimaryConnection: runtime.isPrimaryConnection,
+    acceptConnection: runtime.acceptConnection,
+    refreshLiveConnectionState: runtime.refreshLiveConnectionState,
+    flushOnConnect: runtime.flushOnConnect,
+    flushOnActivity: runtime.flushOnActivity,
+    shouldIgnoreStaleEvent: runtime.shouldIgnoreStaleEvent,
+    incrementConnectEvents: runtime.incrementConnectEvents,
+    incrementActivityEvents: runtime.incrementActivityEvents,
+    incrementAckEvents: runtime.incrementAckEvents,
+    markLastActivityAt: runtime.markLastActivityAt,
+    markLastAckAt: runtime.markLastAckAt,
+    messageAckWaiterCount: runtime.messageAckWaiterCount,
+    fileAckWaiterCount: runtime.fileAckWaiterCount,
+    prepareAckHandling: runtime.prepareAckHandling,
+    handleAckOutcome: runtime.handleAckOutcome,
+    fileSendTransfers: runtime.fileSendTransfers,
+    hasFileAckWaiter: runtime.hasFileAckWaiter,
+    fileAckKey: runtime.fileAckKey,
+    observeLease: runtime.observeLease,
+    tryAdoptTransferOwner: runtime.tryAdoptTransferOwner,
+    refreshAcceptedFileTransferLiveState: runtime.refreshAcceptedFileTransferLiveState,
+    resolveFileAck: runtime.resolveFileAck,
+  });
+
+  const diagnosticsHandlers = createBncrBridgeDiagnosticsHandlersComponent({
+    getApi: runtime.getApi,
+    channelId: runtime.channelId,
+    asString: runtime.asString,
+    now: runtime.now,
+    countInvalidOutboxSessionKeys: runtime.countInvalidOutboxSessionKeys,
+    countLegacyAccountResidue: runtime.countLegacyAccountResidue,
+    pluginRoot: runtime.pluginRoot,
+    buildRuntimeStatusInput: runtime.buildRuntimeStatusInput,
+    getAccountRuntimeSnapshot: runtime.getAccountRuntimeSnapshot,
+    buildIntegratedDiagnostics: runtime.buildIntegratedDiagnostics,
+    buildExtendedDiagnostics: runtime.buildExtendedDiagnostics,
+    buildDownlinkHealth: runtime.buildDownlinkHealth,
+    buildRuntimeFlags: runtime.buildRuntimeFlags,
+    activeConnectionCount: runtime.activeConnectionCount,
+    getMessageAckWaiterCount: runtime.getMessageAckWaiterCount,
+    getFileAckWaiterCount: runtime.getFileAckWaiterCount,
+    filterDeadLetterEntries: runtime.filterDeadLetterEntries,
+    listDeadLetterEntries: runtime.listDeadLetterEntries,
+    buildDeadLetterDiagnostics: runtime.buildDeadLetterDiagnostics,
+    replaceDeadLetterEntries: runtime.replaceDeadLetterEntries,
+    scheduleSave: runtime.scheduleSave,
+    logDeadLetterSummary: runtime.logDeadLetterSummary,
+  });
+
+  return {
+    connectionHandlers,
+    diagnosticsHandlers,
+  };
+}

package/src/plugin/bridge-surface-helpers.ts

@@ -0,0 +1,28 @@
+// Aggregated bridge runtime helper entrypoint.
+//
+// The helpers are grouped by concern so snapshot shaping, delivery-facing
+// runtime adapters, and support runtime ownership stay readable without
+// changing import sites.
+
+export {
+  buildBridgeDrainTriggers,
+  buildBridgeLifecycleMarkers,
+  buildBridgeRuntimeStatusInput,
+  buildBridgeStatusProjectionRuntime,
+  buildChannelSendTargetRuntime,
+  buildFlushBestEffortError,
+  buildFlushOnActivityArgs,
+  buildFlushOnConnectArgs,
+  buildInboundSurfaceActivityRuntime,
+  buildInboundSurfaceConnectionRuntime,
+} from './bridge-runtime-helpers.ts';
+
+export {
+  buildConnectionRuntimeSnapshot,
+  buildOutboundRuntimeSnapshot,
+  buildRegisterRuntimeSnapshot,
+  buildStatusWorkerActiveConnections,
+  buildStatusWorkerLastEventAt,
+} from './bridge-runtime-snapshots.ts';
+
+export { createBridgeSupportRuntime } from './bridge-support-runtime.ts';

package/src/plugin/capabilities.ts

@@ -1,7 +1,5 @@
-import type { ChatType } from 'openclaw/plugin-sdk';
-
 export const BNCR_CHANNEL_CAPABILITIES = {
-  chatTypes: ['direct'] as ChatType[],
+  chatTypes: ['direct'] as ('direct' | 'group' | 'thread')[],
   media: true,
   reply: true,
   nativeCommands: true,