@xmoxmo/bncr 0.6.6 → 0.6.8

package/src/bootstrap/register-runtime-observation.ts

@@ -0,0 +1,170 @@
+export const REGISTRY_RUNTIME_OBSERVATION_TIMEOUT_MS = 30_000;
+export const REGISTRY_RUNTIME_OBSERVATION_POLL_MS = 5_000;
+
+export type RegistryRuntimeObservationPhase = 'awaiting' | 'polling' | 'ready' | 'retired';
+
+export type RegistryRuntimeProbe = {
+  serviceRunning?: boolean;
+  channelRunning?: boolean;
+  activeChannelAccounts?: number;
+};
+
+export type RegistryRuntimeObservation = {
+  phase: RegistryRuntimeObservationPhase;
+  startedAt: number;
+  deadlineAt: number;
+  pollingStartedAt: number | null;
+  readyAt: number | null;
+  retiredAt: number | null;
+  lastProbeAt: number | null;
+  probeCount: number;
+  serviceObservedAt: number | null;
+  channelObservedAt: number | null;
+};
+
+export type RegistryRuntimeObservationDecision = {
+  observation: RegistryRuntimeObservation;
+  action: 'wait' | 'poll' | 'ready' | 'retired';
+  transitionedToPolling: boolean;
+  transitionedToReady: boolean;
+};
+
+function finiteTimestamp(value: unknown): number | null {
+  return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+
+function nonNegativeInteger(value: unknown): number {
+  return typeof value === 'number' && Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}
+
+export function createRegistryRuntimeObservation(now: number): RegistryRuntimeObservation {
+  return {
+    phase: 'awaiting',
+    startedAt: now,
+    deadlineAt: now + REGISTRY_RUNTIME_OBSERVATION_TIMEOUT_MS,
+    pollingStartedAt: null,
+    readyAt: null,
+    retiredAt: null,
+    lastProbeAt: null,
+    probeCount: 0,
+    serviceObservedAt: null,
+    channelObservedAt: null,
+  };
+}
+
+export function normalizeRegistryRuntimeObservation(
+  value: unknown,
+): RegistryRuntimeObservation | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined;
+  const source = value as Record<string, unknown>;
+  const phase = source.phase;
+  if (phase !== 'awaiting' && phase !== 'polling' && phase !== 'ready' && phase !== 'retired') {
+    return undefined;
+  }
+  const startedAt = finiteTimestamp(source.startedAt);
+  const deadlineAt = finiteTimestamp(source.deadlineAt);
+  if (startedAt === null || deadlineAt === null) return undefined;
+  return {
+    phase,
+    startedAt,
+    deadlineAt,
+    pollingStartedAt: finiteTimestamp(source.pollingStartedAt),
+    readyAt: finiteTimestamp(source.readyAt),
+    retiredAt: finiteTimestamp(source.retiredAt),
+    lastProbeAt: finiteTimestamp(source.lastProbeAt),
+    probeCount: nonNegativeInteger(source.probeCount),
+    serviceObservedAt: finiteTimestamp(source.serviceObservedAt),
+    channelObservedAt: finiteTimestamp(source.channelObservedAt),
+  };
+}
+
+function retireObservation(
+  observation: RegistryRuntimeObservation,
+  now: number,
+): RegistryRuntimeObservationDecision {
+  return {
+    observation: {
+      ...observation,
+      phase: 'retired',
+      retiredAt: observation.retiredAt ?? now,
+      lastProbeAt: now,
+      probeCount: observation.probeCount + 1,
+    },
+    action: 'retired',
+    transitionedToPolling: false,
+    transitionedToReady: false,
+  };
+}
+
+export function evaluateRegistryRuntimeObservation(args: {
+  observation: RegistryRuntimeObservation;
+  now: number;
+  lifecycleActive: boolean;
+  probe: RegistryRuntimeProbe;
+}): RegistryRuntimeObservationDecision {
+  const { observation, now, lifecycleActive, probe } = args;
+  if (observation.phase === 'retired') {
+    return {
+      observation,
+      action: 'retired',
+      transitionedToPolling: false,
+      transitionedToReady: false,
+    };
+  }
+  if (!lifecycleActive) {
+    return retireObservation(observation, now);
+  }
+  if (observation.phase === 'ready') {
+    return {
+      observation,
+      action: 'ready',
+      transitionedToPolling: false,
+      transitionedToReady: false,
+    };
+  }
+
+  const serviceRunning = probe.serviceRunning === true;
+  const channelRunning = probe.channelRunning === true || (probe.activeChannelAccounts ?? 0) > 0;
+  const serviceObservedAt = observation.serviceObservedAt ?? (serviceRunning ? now : null);
+  const channelObservedAt = observation.channelObservedAt ?? (channelRunning ? now : null);
+  const observed = {
+    ...observation,
+    lastProbeAt: now,
+    probeCount: observation.probeCount + 1,
+    serviceObservedAt,
+    channelObservedAt,
+  };
+
+  if (serviceRunning && channelRunning) {
+    return {
+      observation: {
+        ...observed,
+        phase: 'ready',
+        readyAt: observed.readyAt ?? now,
+      },
+      action: 'ready',
+      transitionedToPolling: false,
+      transitionedToReady: true,
+    };
+  }
+
+  if (now >= observation.deadlineAt) {
+    return {
+      observation: {
+        ...observed,
+        phase: 'polling',
+        pollingStartedAt: observed.pollingStartedAt ?? now,
+      },
+      action: 'poll',
+      transitionedToPolling: observation.phase === 'awaiting',
+      transitionedToReady: false,
+    };
+  }
+
+  return {
+    observation: observed,
+    action: 'wait',
+    transitionedToPolling: false,
+    transitionedToReady: false,
+  };
+}

package/src/bootstrap/register-runtime-singleton.ts

@@ -2,7 +2,6 @@ import {
   type BridgeOwner,
   type BridgeRegisterStateCarrier,
   hydrateBridgeRegisterState,
-  sameBridgeOwner,
   snapshotBridgeRegisterState,
 } from './register-runtime-helpers.ts';
 import type { ChannelModule, LoadedRuntime } from './runtime-loader.ts';
@@ -17,6 +16,8 @@ type BridgeOwnedCarrier = BridgeRegisterStateCarrier & {
 };
 type GlobalBridgeStore = typeof globalThis & { __bncrBridge?: BridgeSingleton };
 
+export type BridgeAdoptionMode = 'create' | 'reuse' | 'replace';
+
 function isBridgeOwner(value: unknown): value is BridgeOwner {
   return Boolean(
     value &&
@@ -48,10 +49,13 @@ export function createBncrBridgeSingletonManager(runtime: {
     return bridge;
   };
 
-  const getBridgeSingleton = (api: OpenClawPluginApi) => {
+  const adoptBridgeSingleton = (
+    api: OpenClawPluginApi,
+    owner: BridgeOwner,
+    mode: BridgeAdoptionMode,
+  ) => {
     const loaded = runtime.loadBncrRuntimeSync();
     const g = globalThis as GlobalBridgeStore;
-    const owner = runtime.getBridgeOwner(api, loaded);
     const previousOwnerRaw = g.__bncrBridge
       ? getBridgeOwnedCarrier(g.__bncrBridge)[runtime.bridgeOwnerSymbol]
       : undefined;
@@ -59,57 +63,56 @@ export function createBncrBridgeSingletonManager(runtime: {
 
     let created = false;
     let rebuilt = false;
+    let bridge: BridgeSingleton | undefined;
 
-    if (g.__bncrBridge) {
-      const mustRebuild =
-        !sameBridgeOwner(previousOwner, owner) &&
-        (previousOwner?.moduleEpoch !== owner.moduleEpoch ||
-          previousOwner?.bridgeFactoryId !== owner.bridgeFactoryId ||
-          previousOwner?.registrationMode !== owner.registrationMode ||
-          previousOwner?.apiInstanceId !== owner.apiInstanceId ||
-          previousOwner?.registryFingerprint !== owner.registryFingerprint);
-
-      if (mustRebuild) {
-        const registerState = snapshotBridgeRegisterState(
-          getBridgeRegisterStateCarrier(g.__bncrBridge),
-        );
-        try {
-          g.__bncrBridge.stopService?.();
-        } catch {
-          // ignore stop errors during hot-restart recovery
-        }
-        const rebuiltBridge = assignBridgeOwner(
-          loaded.createBncrBridge(api, {
-            pluginRoot: runtime.pluginRoot,
-            pluginFile: runtime.pluginFile,
-          }),
-          owner,
-        );
-        hydrateBridgeRegisterState(getBridgeRegisterStateCarrier(rebuiltBridge), registerState);
-        g.__bncrBridge = rebuiltBridge;
-        created = true;
-        rebuilt = true;
-      } else {
-        g.__bncrBridge.bindApi?.(api);
-        assignBridgeOwner(g.__bncrBridge, owner);
-      }
-    } else {
-      g.__bncrBridge = assignBridgeOwner(
+    if (!g.__bncrBridge || mode === 'create' || mode === 'replace') {
+      const registerState =
+        mode === 'replace' && g.__bncrBridge
+          ? snapshotBridgeRegisterState(getBridgeRegisterStateCarrier(g.__bncrBridge))
+          : null;
+      bridge = assignBridgeOwner(
         loaded.createBncrBridge(api, {
           pluginRoot: runtime.pluginRoot,
           pluginFile: runtime.pluginFile,
         }),
         owner,
       );
+      hydrateBridgeRegisterState(getBridgeRegisterStateCarrier(bridge), registerState);
+      g.__bncrBridge = bridge;
       created = true;
+      rebuilt = mode === 'replace' && Boolean(previousOwner);
+    } else {
+      bridge = g.__bncrBridge;
+      bridge.bindApi?.(api);
+      assignBridgeOwner(bridge, owner);
     }
 
-    g.__bncrBridge?.bindRuntimePaths?.({
+    bridge.bindRuntimePaths?.({
       pluginRoot: runtime.pluginRoot,
       pluginFile: runtime.pluginFile,
     });
 
-    return { bridge: g.__bncrBridge, runtime: loaded, created, rebuilt, owner, previousOwner };
+    return { bridge, runtime: loaded, created, rebuilt, owner, previousOwner };
+  };
+
+  const getBridgeSingleton = (api: OpenClawPluginApi) => {
+    const loaded = runtime.loadBncrRuntimeSync();
+    const owner = runtime.getBridgeOwner(api, loaded);
+    const g = globalThis as GlobalBridgeStore;
+    const previous = getBridgeOwnerFromBridge(g.__bncrBridge);
+    const sameGeneration =
+      previous?.moduleEpoch === owner.moduleEpoch &&
+      previous?.bridgeFactoryId === owner.bridgeFactoryId &&
+      previous?.pluginVersion === owner.pluginVersion &&
+      previous?.registrationMode === owner.registrationMode &&
+      previous?.pluginRoot === owner.pluginRoot &&
+      previous?.pluginFile === owner.pluginFile;
+    const mode: BridgeAdoptionMode = !g.__bncrBridge
+      ? 'create'
+      : sameGeneration
+        ? 'reuse'
+        : 'replace';
+    return adoptBridgeSingleton(api, owner, mode);
   };
 
   const getExistingBridgeSingleton = () => {
@@ -129,6 +132,7 @@ export function createBncrBridgeSingletonManager(runtime: {
 
   return {
     assignBridgeOwner,
+    adoptBridgeSingleton,
     getBridgeRegisterStateCarrier,
     getBridgeSingleton,
     getExistingBridgeSingleton,