@xmoxmo/bncr 0.3.6 → 0.3.8

package/src/plugin/state-store.ts

@@ -0,0 +1,249 @@
+import {
+  dumpRegisterDriftSnapshot,
+  normalizeRegisterDriftSnapshot,
+} from '../core/register-trace.ts';
+import type { BncrRoute, OutboxEntry } from '../core/types.ts';
+import {
+  readOpenClawJsonFileWithFallback,
+  writeOpenClawJsonFileAtomically,
+} from '../openclaw/sdk-helpers.ts';
+import type {
+  BncrPersistedAccountTimestamp,
+  BncrPersistedLastSession,
+  BncrPersistedSessionRoute,
+  PersistedState as BncrPersistedState,
+} from './channel-runtime-types.ts';
+
+type BncrPersistedStateStoreInput = {
+  outbox?: unknown;
+  deadLetter?: unknown;
+  sessionRoutes?: unknown;
+  lastSessionByAccount?: unknown;
+  lastActivityByAccount?: unknown;
+  lastInboundByAccount?: unknown;
+  lastOutboundByAccount?: unknown;
+  lastDriftSnapshot?: unknown;
+};
+
+type PersistedAccountTimestampInput = Partial<BncrPersistedAccountTimestamp>;
+type PersistedLastSessionInput = Partial<BncrPersistedLastSession>;
+type PersistedSessionRouteInput = Partial<BncrPersistedSessionRoute>;
+
+export function createBncrStateStore(runtime: {
+  getStatePath: () => string | null;
+  now: () => number;
+  asString: (value: unknown, fallback?: string) => string;
+  finiteNumberOr: (value: unknown, fallback: number) => number;
+  normalizeAccountId: (accountId: string) => string;
+  normalizeStoredSessionKey: (
+    sessionKey: string,
+    canonicalAgentId?: string,
+  ) => {
+    sessionKey: string;
+    route: BncrRoute;
+  } | null;
+  parseRouteLike: (value: unknown) => BncrRoute | null;
+  routeKey: (accountId: string, route: BncrRoute) => string;
+  formatDisplayScope: (route: BncrRoute) => string;
+  canonicalAgentId: () => string;
+  normalizePersistedOutboxEntry: (entry: unknown) => OutboxEntry | null;
+  maxDeadLetterEntries: number;
+  maxSessionRouteEntries: number;
+  maxAccountActivityEntries: number;
+  outbox: Map<string, OutboxEntry>;
+  getDeadLetter: () => OutboxEntry[];
+  setDeadLetter: (entries: OutboxEntry[]) => void;
+  sessionRoutes: Map<string, { accountId: string; route: BncrRoute; updatedAt: number }>;
+  routeAliases: Map<string, { accountId: string; route: BncrRoute; updatedAt: number }>;
+  lastSessionByAccount: Map<string, { sessionKey: string; scope: string; updatedAt: number }>;
+  lastActivityByAccount: Map<string, number>;
+  lastInboundByAccount: Map<string, number>;
+  lastOutboundByAccount: Map<string, number>;
+  getLastDriftSnapshot: () => BncrPersistedState['lastDriftSnapshot'];
+  setLastDriftSnapshot: (value: BncrPersistedState['lastDriftSnapshot']) => void;
+}) {
+  function loadPersistedAccountTimestampMap(target: Map<string, number>, persisted: unknown): void {
+    target.clear();
+    const items = Array.isArray(persisted)
+      ? (persisted.slice(-runtime.maxAccountActivityEntries) as PersistedAccountTimestampInput[])
+      : [];
+    for (const item of items) {
+      if (!item || typeof item !== 'object') continue;
+      const accountId = runtime.normalizeAccountId(runtime.asString(item.accountId || ''));
+      const updatedAt = runtime.finiteNumberOr(item.updatedAt, 0);
+      if (updatedAt <= 0) continue;
+      target.set(accountId, updatedAt);
+    }
+  }
+
+  function dumpPersistedAccountTimestampMap(source: Map<string, number>) {
+    return Array.from(source.entries())
+      .map(([accountId, updatedAt]) => ({
+        accountId,
+        updatedAt,
+      }))
+      .slice(-runtime.maxAccountActivityEntries);
+  }
+
+  function loadPersistedLastSessionMap(persisted: unknown): void {
+    runtime.lastSessionByAccount.clear();
+    const items = Array.isArray(persisted)
+      ? (persisted.slice(-runtime.maxAccountActivityEntries) as PersistedLastSessionInput[])
+      : [];
+    for (const item of items) {
+      if (!item || typeof item !== 'object') continue;
+      const accountId = runtime.normalizeAccountId(runtime.asString(item.accountId || ''));
+      const normalized = runtime.normalizeStoredSessionKey(
+        runtime.asString(item.sessionKey || ''),
+        runtime.canonicalAgentId(),
+      );
+      const updatedAt = runtime.finiteNumberOr(item.updatedAt, 0);
+      if (!normalized || updatedAt <= 0) continue;
+
+      runtime.lastSessionByAccount.set(accountId, {
+        sessionKey: normalized.sessionKey,
+        scope: runtime.formatDisplayScope(normalized.route),
+        updatedAt,
+      });
+    }
+  }
+
+  function dumpPersistedLastSessionMap() {
+    return Array.from(runtime.lastSessionByAccount.entries())
+      .map(([accountId, v]) => ({
+        accountId,
+        sessionKey: v.sessionKey,
+        scope: v.scope,
+        updatedAt: v.updatedAt,
+      }))
+      .slice(-runtime.maxAccountActivityEntries);
+  }
+
+  function loadPersistedSessionRoutes(persisted: unknown): void {
+    runtime.sessionRoutes.clear();
+    runtime.routeAliases.clear();
+    const items = Array.isArray(persisted)
+      ? (persisted.slice(-runtime.maxSessionRouteEntries) as PersistedSessionRouteInput[])
+      : [];
+    for (const item of items) {
+      if (!item || typeof item !== 'object') continue;
+      const normalized = runtime.normalizeStoredSessionKey(
+        runtime.asString(item.sessionKey || ''),
+        runtime.canonicalAgentId(),
+      );
+      if (!normalized) continue;
+
+      const route = runtime.parseRouteLike(item.route) || normalized.route;
+      const accountId = runtime.normalizeAccountId(runtime.asString(item.accountId || ''));
+      const updatedAt = runtime.finiteNumberOr(item.updatedAt, runtime.now());
+      const info = { accountId, route, updatedAt };
+
+      runtime.sessionRoutes.set(normalized.sessionKey, info);
+      runtime.routeAliases.set(runtime.routeKey(accountId, route), info);
+    }
+  }
+
+  function dumpPersistedSessionRoutes() {
+    return Array.from(runtime.sessionRoutes.entries())
+      .map(([sessionKey, v]) => ({
+        sessionKey,
+        accountId: v.accountId,
+        route: v.route,
+        updatedAt: v.updatedAt,
+      }))
+      .slice(-runtime.maxSessionRouteEntries);
+  }
+
+  function backfillAccountActivityFromSessionRoutes(): void {
+    if (runtime.lastSessionByAccount.size > 0 || runtime.sessionRoutes.size === 0) return;
+
+    for (const [sessionKey, info] of runtime.sessionRoutes.entries()) {
+      const acc = runtime.normalizeAccountId(info.accountId);
+      const updatedAt = runtime.finiteNumberOr(info.updatedAt, 0);
+      if (updatedAt <= 0) continue;
+
+      const current = runtime.lastSessionByAccount.get(acc);
+      if (!current || updatedAt >= current.updatedAt) {
+        runtime.lastSessionByAccount.set(acc, {
+          sessionKey,
+          scope: runtime.formatDisplayScope(info.route),
+          updatedAt,
+        });
+      }
+
+      const lastAct = runtime.lastActivityByAccount.get(acc) || 0;
+      if (updatedAt > lastAct) runtime.lastActivityByAccount.set(acc, updatedAt);
+
+      const lastIn = runtime.lastInboundByAccount.get(acc) || 0;
+      if (updatedAt > lastIn) runtime.lastInboundByAccount.set(acc, updatedAt);
+    }
+  }
+
+  async function loadState() {
+    const statePath = runtime.getStatePath();
+    if (!statePath) return;
+    const loaded = await readOpenClawJsonFileWithFallback(statePath, {
+      outbox: [],
+      deadLetter: [],
+      sessionRoutes: [],
+    });
+    const data = loaded.value as BncrPersistedStateStoreInput;
+
+    runtime.outbox.clear();
+    for (const entry of Array.isArray(data.outbox) ? data.outbox : []) {
+      const migratedEntry = runtime.normalizePersistedOutboxEntry(entry);
+      if (!migratedEntry) continue;
+      runtime.outbox.set(migratedEntry.messageId, migratedEntry);
+    }
+
+    const deadLetter: OutboxEntry[] = [];
+    const persistedDeadLetter = Array.isArray(data.deadLetter)
+      ? data.deadLetter.slice(-runtime.maxDeadLetterEntries)
+      : [];
+    for (const entry of persistedDeadLetter) {
+      const migratedEntry = runtime.normalizePersistedOutboxEntry(entry);
+      if (!migratedEntry) continue;
+      deadLetter.push(migratedEntry);
+    }
+    runtime.setDeadLetter(deadLetter);
+
+    loadPersistedSessionRoutes(data.sessionRoutes);
+    loadPersistedLastSessionMap(data.lastSessionByAccount);
+    loadPersistedAccountTimestampMap(runtime.lastActivityByAccount, data.lastActivityByAccount);
+    loadPersistedAccountTimestampMap(runtime.lastInboundByAccount, data.lastInboundByAccount);
+    loadPersistedAccountTimestampMap(runtime.lastOutboundByAccount, data.lastOutboundByAccount);
+
+    runtime.setLastDriftSnapshot(normalizeRegisterDriftSnapshot(data.lastDriftSnapshot));
+    backfillAccountActivityFromSessionRoutes();
+  }
+
+  async function flushState() {
+    const statePath = runtime.getStatePath();
+    if (!statePath) return;
+
+    const data: BncrPersistedState = {
+      outbox: Array.from(runtime.outbox.values()),
+      deadLetter: runtime.getDeadLetter().slice(-runtime.maxDeadLetterEntries),
+      sessionRoutes: dumpPersistedSessionRoutes(),
+      lastSessionByAccount: dumpPersistedLastSessionMap(),
+      lastActivityByAccount: dumpPersistedAccountTimestampMap(runtime.lastActivityByAccount),
+      lastInboundByAccount: dumpPersistedAccountTimestampMap(runtime.lastInboundByAccount),
+      lastOutboundByAccount: dumpPersistedAccountTimestampMap(runtime.lastOutboundByAccount),
+      lastDriftSnapshot: dumpRegisterDriftSnapshot(runtime.getLastDriftSnapshot() ?? null),
+    };
+
+    await writeOpenClawJsonFileAtomically(statePath, data);
+  }
+
+  return {
+    loadPersistedAccountTimestampMap,
+    dumpPersistedAccountTimestampMap,
+    loadPersistedLastSessionMap,
+    dumpPersistedLastSessionMap,
+    loadPersistedSessionRoutes,
+    dumpPersistedSessionRoutes,
+    backfillAccountActivityFromSessionRoutes,
+    loadState,
+    flushState,
+  };
+}

package/src/plugin/state-transient-runtime-group.ts

@@ -0,0 +1,105 @@
+import type { RegisterDriftSnapshot } from '../core/register-trace.ts';
+import type {
+  BncrConnection,
+  BncrRoute,
+  FileRecvTransferState,
+  FileSendTransferState,
+  OutboxEntry,
+} from '../core/types.ts';
+import { createBncrStateStore } from './state-store.ts';
+import { createBncrTransientStateRuntime } from './transient-state-runtime.ts';
+
+type StoredRouteRecord = { accountId: string; route: BncrRoute; updatedAt: number };
+type StoredLastSessionRecord = { sessionKey: string; scope: string; updatedAt: number };
+
+export function createBncrStateTransientRuntimeGroup(runtime: {
+  bridgeId: string;
+  getStatePath: () => string | null;
+  now: () => number;
+  asString: (value: unknown, fallback?: string) => string;
+  finiteNumberOr: (value: unknown, fallback: number) => number;
+  normalizeAccountId: (accountId: string) => string;
+  normalizeStoredSessionKey: (
+    sessionKey: string,
+    canonicalAgentId?: string,
+  ) => { sessionKey: string; route: BncrRoute } | null;
+  parseRouteLike: (value: unknown) => BncrRoute | null;
+  routeKey: (accountId: string, route: BncrRoute) => string;
+  formatDisplayScope: (route: BncrRoute) => string;
+  canonicalAgentId: () => string;
+  normalizePersistedOutboxEntry: (entry: unknown) => OutboxEntry | null;
+  maxDeadLetterEntries: number;
+  maxSessionRouteEntries: number;
+  maxAccountActivityEntries: number;
+  outbox: Map<string, OutboxEntry>;
+  getDeadLetter: () => OutboxEntry[];
+  setDeadLetter: (entries: OutboxEntry[]) => void;
+  sessionRoutes: Map<string, StoredRouteRecord>;
+  routeAliases: Map<string, StoredRouteRecord>;
+  lastSessionByAccount: Map<string, StoredLastSessionRecord>;
+  lastActivityByAccount: Map<string, number>;
+  lastInboundByAccount: Map<string, number>;
+  lastOutboundByAccount: Map<string, number>;
+  getLastDriftSnapshot: () => RegisterDriftSnapshot | null | undefined;
+  setLastDriftSnapshot: (value: RegisterDriftSnapshot | null | undefined) => void;
+  connectTtlMs: number;
+  fileTransferKeepMs: number;
+  fileTransferTerminalKeepMs: number;
+  fileTransferAckTtlMs: number;
+  connections: Map<string, BncrConnection>;
+  activeConnectionByAccount: Map<string, string>;
+  recentInbound: Map<string, number>;
+  fileSendTransfers: Map<string, FileSendTransferState>;
+  fileRecvTransfers: Map<string, FileRecvTransferState>;
+  earlyFileAcks: Map<string, { at: number }>;
+  logInfo: (scope: string | undefined, message: string, options?: { debugOnly?: boolean }) => void;
+}) {
+  const stateStore = createBncrStateStore({
+    getStatePath: runtime.getStatePath,
+    now: runtime.now,
+    asString: runtime.asString,
+    finiteNumberOr: runtime.finiteNumberOr,
+    normalizeAccountId: runtime.normalizeAccountId,
+    normalizeStoredSessionKey: runtime.normalizeStoredSessionKey,
+    parseRouteLike: runtime.parseRouteLike,
+    routeKey: runtime.routeKey,
+    formatDisplayScope: runtime.formatDisplayScope,
+    canonicalAgentId: runtime.canonicalAgentId,
+    normalizePersistedOutboxEntry: runtime.normalizePersistedOutboxEntry,
+    maxDeadLetterEntries: runtime.maxDeadLetterEntries,
+    maxSessionRouteEntries: runtime.maxSessionRouteEntries,
+    maxAccountActivityEntries: runtime.maxAccountActivityEntries,
+    outbox: runtime.outbox,
+    getDeadLetter: runtime.getDeadLetter,
+    setDeadLetter: runtime.setDeadLetter,
+    sessionRoutes: runtime.sessionRoutes,
+    routeAliases: runtime.routeAliases,
+    lastSessionByAccount: runtime.lastSessionByAccount,
+    lastActivityByAccount: runtime.lastActivityByAccount,
+    lastInboundByAccount: runtime.lastInboundByAccount,
+    lastOutboundByAccount: runtime.lastOutboundByAccount,
+    getLastDriftSnapshot: runtime.getLastDriftSnapshot,
+    setLastDriftSnapshot: runtime.setLastDriftSnapshot,
+  });
+
+  const transientStateRuntime = createBncrTransientStateRuntime({
+    now: runtime.now,
+    connectTtlMs: runtime.connectTtlMs,
+    fileTransferKeepMs: runtime.fileTransferKeepMs,
+    fileTransferTerminalKeepMs: runtime.fileTransferTerminalKeepMs,
+    fileTransferAckTtlMs: runtime.fileTransferAckTtlMs,
+    connections: runtime.connections,
+    activeConnectionByAccount: runtime.activeConnectionByAccount,
+    recentInbound: runtime.recentInbound,
+    fileSendTransfers: runtime.fileSendTransfers,
+    fileRecvTransfers: runtime.fileRecvTransfers,
+    earlyFileAcks: runtime.earlyFileAcks,
+    logInfo: runtime.logInfo,
+    bridgeId: runtime.bridgeId,
+  });
+
+  return {
+    stateStore,
+    transientStateRuntime,
+  };
+}

package/src/plugin/status-runtime.ts

@@ -0,0 +1,251 @@
+import path from 'node:path';
+import { normalizeAccountId } from '../core/accounts.ts';
+import { buildDownlinkHealth as buildDownlinkHealthFromRuntime } from '../core/downlink-health.ts';
+import {
+  buildAccountRuntimeSnapshot,
+  buildIntegratedDiagnostics as buildIntegratedDiagnosticsFromRuntime,
+  buildStatusHeadlineFromRuntime,
+  buildStatusMetaFromRuntime,
+} from '../core/status.ts';
+import type {
+  BncrAckObservability,
+  BncrAckStrategy,
+  BncrRuntimeLastSession,
+  OutboxEntry,
+} from '../core/types.ts';
+import { buildBncrRuntimeFlags, buildBncrRuntimeStatusInput } from '../runtime/outbound-flags.ts';
+import type { RuntimeStatusSnapshots } from '../runtime/status-snapshots.ts';
+import { buildRuntimeStatusSnapshots } from '../runtime/status-snapshots.ts';
+
+type RuntimeStatusInput = Parameters<typeof buildIntegratedDiagnosticsFromRuntime>[0];
+
+export type BncrStatusRuntimeHelpers = {
+  api: unknown;
+  getPluginRoot: () => string | null;
+  startedAt: number;
+  debugVerbose: boolean;
+  adaptiveAckTimeoutEnabled: boolean;
+  defaultMessageAckTimeoutMs: number;
+  fileAckTimeoutMs: number;
+  maxAckTimeoutMs: number;
+  now: () => number;
+  resolveMessageAckTimeoutMs: (accountId?: string) => number;
+  isOnline: (accountId: string) => boolean;
+  outboxValues: () => Iterable<OutboxEntry>;
+  deadLetterEntries: () => OutboxEntry[];
+  sessionRouteValues: () => Iterable<{ accountId: string }>;
+  countInvalidOutboxSessionKeys: (accountId: string) => number;
+  countLegacyAccountResidue: (accountId: string) => number;
+  connectEventsByAccount: Map<string, number>;
+  inboundEventsByAccount: Map<string, number>;
+  activityEventsByAccount: Map<string, number>;
+  ackEventsByAccount: Map<string, number>;
+  activeConnectionCount: (accountId: string) => number;
+  lastSessionByAccount: Map<string, BncrRuntimeLastSession>;
+  lastActivityByAccount: Map<string, number>;
+  lastInboundByAccount: Map<string, number>;
+  lastOutboundByAccount: Map<string, number>;
+  buildRuntimeAckObservability: (accountId: string) => BncrAckObservability;
+  buildRuntimeAckStrategy: (ackObservability: BncrAckObservability) => BncrAckStrategy;
+  lastAckOkByAccount: Map<string, number>;
+  lastAckTimeoutByAccount: Map<string, number>;
+  getAckTimeoutCount: (accountId: string) => number;
+  getAccountPendingOutboxEntries: (accountId: string) => OutboxEntry[];
+  getAccountDeadLetterEntries: (accountId: string) => OutboxEntry[];
+  connectionsValues: () => Iterable<{ lastSeenAt: number }>;
+  connectTtlMs: number;
+};
+
+export function createBncrStatusRuntime(runtime: BncrStatusRuntimeHelpers) {
+  const buildRuntimeFlags = (accountId?: string) =>
+    buildBncrRuntimeFlags({
+      api: runtime.api,
+      accountId,
+      resolveMessageAckTimeoutMs: (acc?: string) => runtime.resolveMessageAckTimeoutMs(acc),
+      adaptiveAckTimeoutEnabled: runtime.adaptiveAckTimeoutEnabled,
+      defaultMessageAckTimeoutMs: runtime.defaultMessageAckTimeoutMs,
+      fileAckTimeoutMs: runtime.fileAckTimeoutMs,
+      debugVerbose: runtime.debugVerbose,
+    });
+
+  const buildAccountQueueCounters = (accountId: string) => ({
+    activeConnections: runtime.activeConnectionCount(accountId),
+    pending: runtime.getAccountPendingOutboxEntries(accountId).length,
+    deadLetter: runtime.getAccountDeadLetterEntries(accountId).length,
+  });
+
+  const buildRuntimeStatusCore = (accountId: string, snapshots: RuntimeStatusSnapshots) => {
+    const acc = normalizeAccountId(accountId);
+    const counters = buildAccountQueueCounters(acc);
+    return {
+      accountId: acc,
+      connected: runtime.isOnline(acc),
+      pending: counters.pending,
+      deadLetter: counters.deadLetter,
+      activeConnections: counters.activeConnections,
+      connectEvents: snapshots.eventCounters?.connectEvents ?? 0,
+      inboundEvents: snapshots.eventCounters?.inboundEvents ?? 0,
+      activityEvents: snapshots.eventCounters?.activityEvents ?? 0,
+      ackEvents: snapshots.eventCounters?.ackEvents ?? 0,
+      lastSession: snapshots.activitySnapshot?.lastSession ?? null,
+      lastActivityAt: snapshots.activitySnapshot?.lastActivityAt ?? null,
+      lastInboundAt: snapshots.activitySnapshot?.lastInboundAt ?? null,
+      lastOutboundAt: snapshots.activitySnapshot?.lastOutboundAt ?? null,
+      sessionRoutesCount: snapshots.queueSnapshot?.sessionRoutesCount ?? 0,
+      invalidOutboxSessionKeys: snapshots.queueSnapshot?.invalidOutboxSessionKeys ?? 0,
+      legacyAccountResidue: snapshots.queueSnapshot?.legacyAccountResidue ?? 0,
+    };
+  };
+
+  const buildRuntimeStatusInput = (
+    accountId: string,
+    overrides: {
+      running?: boolean;
+      invalidOutboxSessionKeys?: number;
+      legacyAccountResidue?: number;
+    } = {},
+  ): RuntimeStatusInput => {
+    const acc = normalizeAccountId(accountId);
+    const snapshots: RuntimeStatusSnapshots = buildRuntimeStatusSnapshots({
+      accountId: acc,
+      outboxEntries: runtime.outboxValues(),
+      deadLetterEntries: runtime.deadLetterEntries(),
+      sessionRouteEntries: runtime.sessionRouteValues(),
+      countInvalidOutboxSessionKeys: (snapshotAccountId) =>
+        normalizeAccountId(snapshotAccountId) === acc &&
+        typeof overrides.invalidOutboxSessionKeys === 'number'
+          ? overrides.invalidOutboxSessionKeys
+          : runtime.countInvalidOutboxSessionKeys(snapshotAccountId),
+      countLegacyAccountResidue: (snapshotAccountId) =>
+        normalizeAccountId(snapshotAccountId) === acc &&
+        typeof overrides.legacyAccountResidue === 'number'
+          ? overrides.legacyAccountResidue
+          : runtime.countLegacyAccountResidue(snapshotAccountId),
+      connectEventsByAccount: runtime.connectEventsByAccount,
+      inboundEventsByAccount: runtime.inboundEventsByAccount,
+      activityEventsByAccount: runtime.activityEventsByAccount,
+      ackEventsByAccount: runtime.ackEventsByAccount,
+      activeConnectionCount: (snapshotAccountId) =>
+        runtime.activeConnectionCount(snapshotAccountId),
+      lastSessionByAccount: runtime.lastSessionByAccount,
+      lastActivityByAccount: runtime.lastActivityByAccount,
+      lastInboundByAccount: runtime.lastInboundByAccount,
+      lastOutboundByAccount: runtime.lastOutboundByAccount,
+    });
+    const core = buildRuntimeStatusCore(acc, snapshots);
+    const base = buildBncrRuntimeStatusInput({
+      accountId: core.accountId,
+      connected: core.connected,
+      ...snapshots,
+      startedAt: runtime.startedAt || runtime.now(),
+      running: overrides.running,
+      channelRoot: runtime.getPluginRoot() || path.join(process.cwd(), 'plugins', 'bncr'),
+    });
+    return {
+      ...core,
+      startedAt: Number(base.startedAt || runtime.startedAt || runtime.now()),
+      running: base.running,
+      channelRoot: base.channelRoot,
+    };
+  };
+
+  const buildIntegratedDiagnostics = (
+    accountId: string,
+    runtimeStatusInput?: RuntimeStatusInput,
+  ) => {
+    const ackObservability = runtime.buildRuntimeAckObservability(accountId);
+    const ackStrategy = runtime.buildRuntimeAckStrategy(ackObservability);
+    return {
+      ...buildIntegratedDiagnosticsFromRuntime(
+        runtimeStatusInput || buildRuntimeStatusInput(accountId),
+      ),
+      ackObservability,
+      ackStrategy,
+    };
+  };
+
+  const buildDownlinkHealth = (accountId: string) => {
+    const acc = normalizeAccountId(accountId);
+    return buildDownlinkHealthFromRuntime({
+      accountId: acc,
+      now: runtime.now(),
+      outboxEntries: runtime.outboxValues(),
+      lastAckOkAt: runtime.lastAckOkByAccount.get(acc) || null,
+      lastAckTimeoutAt: runtime.lastAckTimeoutByAccount.get(acc) || null,
+      recentAckTimeoutCount: runtime.getAckTimeoutCount(acc),
+      activeConnectionCount: runtime.activeConnectionCount(acc),
+      lastInboundAt: runtime.lastInboundByAccount.get(acc) || null,
+      lastActivityAt: runtime.lastActivityByAccount.get(acc) || null,
+      onlineByConn: runtime.isOnline(acc),
+    });
+  };
+
+  const buildStatusMeta = (accountId: string) =>
+    buildStatusMetaFromRuntime(buildRuntimeStatusInput(accountId));
+
+  const getAccountRuntimeSnapshot = (
+    accountId: string,
+    runtimeStatusInput = buildRuntimeStatusInput(accountId, { running: true }),
+  ) => {
+    const snapshot = buildAccountRuntimeSnapshot(runtimeStatusInput);
+    const ackObservability = runtime.buildRuntimeAckObservability(accountId);
+    const ackStrategy = runtime.buildRuntimeAckStrategy(ackObservability);
+    return {
+      ...snapshot,
+      ackObservability,
+      ackStrategy,
+      diagnostics: {
+        ...(snapshot.diagnostics || {}),
+        ackObservability,
+        ackStrategy,
+      },
+      meta: {
+        ...(snapshot.meta || {}),
+        ackObservability,
+        ackStrategy,
+        diagnostics: {
+          ...(snapshot.meta?.diagnostics || {}),
+          ackObservability,
+          ackStrategy,
+        },
+      },
+    };
+  };
+
+  const buildStatusHeadline = (accountId: string) =>
+    buildStatusHeadlineFromRuntime(buildRuntimeStatusInput(accountId));
+
+  const getStatusHeadline = (accountId: string) => buildStatusHeadline(accountId);
+
+  const getChannelSummary = (defaultAccountId: string) => {
+    const accountId = normalizeAccountId(defaultAccountId);
+    const runtimeSnapshot = getAccountRuntimeSnapshot(accountId);
+    const headline = buildStatusHeadline(accountId);
+
+    if (runtimeSnapshot.connected) {
+      return { linked: true, self: { e164: headline } };
+    }
+
+    const currentTime = runtime.now();
+    for (const connection of runtime.connectionsValues()) {
+      if (currentTime - connection.lastSeenAt <= runtime.connectTtlMs) {
+        return { linked: true, self: { e164: headline } };
+      }
+    }
+
+    return { linked: false, self: { e164: headline } };
+  };
+
+  return {
+    buildRuntimeFlags,
+    buildAccountQueueCounters,
+    buildRuntimeStatusInput,
+    buildIntegratedDiagnostics,
+    buildDownlinkHealth,
+    buildStatusMeta,
+    getAccountRuntimeSnapshot,
+    buildStatusHeadline,
+    getStatusHeadline,
+    getChannelSummary,
+  };
+}

package/src/plugin/status.ts

@@ -5,11 +5,31 @@ import {
 } from '../core/accounts.ts';
 import { buildAccountStatusSnapshot } from '../core/status.ts';
 import { createOpenClawDefaultChannelRuntimeState } from '../openclaw/sdk-helpers.ts';
+import type { BncrChannelConfigRoot, BncrStatusRuntimeSnapshot } from './channel-runtime-types.ts';
+
+type StatusSurfaceSummaryArgs = { defaultAccountId?: string };
+
+type StatusSurfaceAccount = { accountId?: string; name?: string; enabled?: boolean };
+
+type StatusSurfaceAccountSnapshotArgs = {
+  account?: StatusSurfaceAccount;
+  runtime?: BncrStatusRuntimeSnapshot;
+};
+
+type StatusSurfaceAccountStateArgs = {
+  enabled?: boolean;
+  configured?: boolean;
+  account?: StatusSurfaceAccount;
+  cfg: BncrChannelConfigRoot;
+  runtime?: BncrStatusRuntimeSnapshot;
+};
 
 export type BncrStatusBridge = {
-  getChannelSummary: (defaultAccountId: string) => unknown | Promise<unknown>;
-  getAccountRuntimeSnapshot: (accountId?: string) => unknown;
-  getStatusHeadline: (accountId?: string) => unknown;
+  getChannelSummary: (
+    defaultAccountId: string,
+  ) => Record<string, unknown> | Promise<Record<string, unknown>>;
+  getAccountRuntimeSnapshot: (accountId?: string) => BncrStatusRuntimeSnapshot;
+  getStatusHeadline: (accountId?: string) => string;
 };
 
 export function createBncrStatusSurface(getBridge: () => BncrStatusBridge) {
@@ -17,10 +37,10 @@ export function createBncrStatusSurface(getBridge: () => BncrStatusBridge) {
     defaultRuntime: createOpenClawDefaultChannelRuntimeState(BNCR_DEFAULT_ACCOUNT_ID, {
       mode: 'ws-offline',
     }),
-    buildChannelSummary: async ({ defaultAccountId }: any) => {
+    buildChannelSummary: async ({ defaultAccountId }: StatusSurfaceSummaryArgs) => {
       return getBridge().getChannelSummary(defaultAccountId || BNCR_DEFAULT_ACCOUNT_ID);
     },
-    buildAccountSnapshot: async ({ account, runtime }: any) => {
+    buildAccountSnapshot: async ({ account, runtime }: StatusSurfaceAccountSnapshotArgs) => {
       const runtimeBridge = getBridge();
       const accountId = account?.accountId || BNCR_DEFAULT_ACCOUNT_ID;
       const snapshotAccount = {
@@ -37,12 +57,18 @@ export function createBncrStatusSurface(getBridge: () => BncrStatusBridge) {
         displayName: resolveDefaultDisplayName(account?.name, accountId),
       });
     },
-    resolveAccountState: ({ enabled, configured, account, cfg, runtime }: any) => {
+    resolveAccountState: ({
+      enabled,
+      configured,
+      account,
+      cfg,
+      runtime,
+    }: StatusSurfaceAccountStateArgs) => {
       if (!enabled) return 'disabled';
       const resolved = resolveAccount(cfg, account?.accountId);
       if (!(resolved.enabled && configured)) return 'not configured';
       const rt = runtime || getBridge().getAccountRuntimeSnapshot(account?.accountId);
-      return (rt as any)?.connected ? 'linked' : 'configured';
+      return rt?.connected ? 'linked' : 'configured';
     },
   };
 }