@camstack/addon-pipeline 0.1.19 → 0.1.20

package/dist/pipeline-runner/index.mjs

@@ -1,4 +1,4 @@
-import { e as errMsg, o as object, s as string, _ as _enum, l as lazy, a as array, b as boolean, n as number, d as defineCustomActions, c as customAction, B as BaseAddon, E as EventCategory, p as pipelineRunnerCapability, f as createEvent } from "../index-Bmlkm0Fd.mjs";
+import { e as errMsg, o as object, s as string, _ as _enum, l as lazy, a as array, b as boolean, n as number, d as defineCustomActions, c as customAction, B as BaseAddon, E as EventCategory, p as pipelineRunnerCapability, m as makeSourceBrokerId, f as createEvent } from "../index-5aYef068.mjs";
 import { FrameRingReaderCache } from "@camstack/shm-ring";
 class FrameQueue {
   /**
@@ -606,36 +606,87 @@ class PipelineRunner {
 const PULL_MAX_COUNT = 4;
 const MIN_POLL_INTERVAL_MS = 20;
 const FALLBACK_POLL_INTERVAL_MS = 200;
+const INITIAL_SUBSCRIBE_RETRY_BACKOFF_MS = 250;
+const MAX_SUBSCRIBE_RETRY_BACKOFF_MS = 5e3;
 async function startFrameHandlePoller(options) {
-  const { api, brokerId, format, maxFps, tag, onFrame, logger } = options;
-  let result;
-  try {
-    result = await api.streamBroker.subscribeFrames.mutate({
-      brokerId,
-      format,
-      maxFps,
-      tag
-    });
-  } catch (err) {
-    logger.warn("frame-handle poller: subscribeFrames failed", {
-      meta: { brokerId, format, tag, error: errMsg(err) }
-    });
-    return null;
+  const lifecycle = {
+    stopped: false,
+    retryTimer: void 0,
+    activeTeardown: null
+  };
+  const teardown = () => {
+    if (lifecycle.stopped) return;
+    lifecycle.stopped = true;
+    if (lifecycle.retryTimer) {
+      clearTimeout(lifecycle.retryTimer);
+      lifecycle.retryTimer = void 0;
+    }
+    lifecycle.activeTeardown?.();
+  };
+  void subscribeWithRetry(options, lifecycle);
+  return teardown;
+}
+async function subscribeWithRetry(options, lifecycle) {
+  const { api, brokerId, format, maxFps, tag, logger } = options;
+  let backoffMs = INITIAL_SUBSCRIBE_RETRY_BACKOFF_MS;
+  let attempt = 0;
+  while (!lifecycle.stopped) {
+    attempt += 1;
+    try {
+      const result = await api.streamBroker.subscribeFrames.mutate({
+        brokerId,
+        format,
+        maxFps,
+        tag
+      });
+      if (lifecycle.stopped) {
+        await api.streamBroker.unsubscribeFrames.mutate({ subscriptionId: result.subscriptionId }).catch((err) => {
+          logger.warn("frame-handle poller: late unsubscribe failed", {
+            meta: { brokerId, subscriptionId: result.subscriptionId, error: errMsg(err) }
+          });
+        });
+        return;
+      }
+      lifecycle.activeTeardown = startPolling(options, result.subscriptionId, result.maxFps, lifecycle);
+      return;
+    } catch (err) {
+      if (lifecycle.stopped) return;
+      if (attempt === 1) {
+        logger.warn("frame-handle poller: subscribeFrames failed, retrying", {
+          meta: { brokerId, format, tag, error: errMsg(err), nextRetryInMs: backoffMs }
+        });
+      } else {
+        logger.debug("frame-handle poller: subscribeFrames still failing", {
+          meta: { brokerId, format, tag, attempt, error: errMsg(err), nextRetryInMs: backoffMs }
+        });
+      }
+      await sleep(backoffMs, lifecycle);
+      backoffMs = Math.min(MAX_SUBSCRIBE_RETRY_BACKOFF_MS, backoffMs * 2);
+    }
   }
-  const { subscriptionId } = result;
+}
+function sleep(ms, lifecycle) {
+  return new Promise((resolve) => {
+    lifecycle.retryTimer = setTimeout(() => {
+      lifecycle.retryTimer = void 0;
+      resolve();
+    }, ms);
+  });
+}
+function startPolling(options, subscriptionId, resolvedMaxFps, lifecycle) {
+  const { api, brokerId, onFrame, logger } = options;
   const readers = new FrameRingReaderCache(logger);
-  const pollIntervalMs = result.maxFps > 0 ? Math.max(MIN_POLL_INTERVAL_MS, Math.round(1e3 / result.maxFps)) : FALLBACK_POLL_INTERVAL_MS;
-  let stopped = false;
+  const pollIntervalMs = resolvedMaxFps > 0 ? Math.max(MIN_POLL_INTERVAL_MS, Math.round(1e3 / resolvedMaxFps)) : FALLBACK_POLL_INTERVAL_MS;
   let timer;
   const tick = async () => {
-    if (stopped) return;
+    if (lifecycle.stopped) return;
     try {
       const handles = await api.streamBroker.pullFrameHandles.query({
         subscriptionId,
         maxCount: PULL_MAX_COUNT
       });
       for (const handle of handles) {
-        if (stopped) break;
+        if (lifecycle.stopped) break;
         const frame = readers.read(handle);
         if (frame) onFrame(frame, handle);
       }
@@ -644,14 +695,12 @@ async function startFrameHandlePoller(options) {
         meta: { brokerId, subscriptionId, error: errMsg(err) }
       });
     }
-    if (!stopped) {
+    if (!lifecycle.stopped) {
       timer = setTimeout(() => void tick(), pollIntervalMs);
     }
   };
   void tick();
   return () => {
-    if (stopped) return;
-    stopped = true;
     if (timer) {
       clearTimeout(timer);
       timer = void 0;
@@ -767,14 +816,12 @@ function toFrameInput(frame) {
     timestamp: frame.timestamp
   };
 }
-const STEP_LOG_INTERVAL_MS = 3e4;
 const METRICS_SNAPSHOT_INTERVAL_MS = 1e3;
 const METRICS_HEARTBEAT_MS = 3e4;
 class PipelineRunnerAddon extends BaseAddon {
   runner = null;
   attached = /* @__PURE__ */ new Map();
   nodeId = "unknown";
-  stepLogTimer = null;
   metricsSnapshotTimer = null;
   unsubMotionEvents = null;
   /** Last analyzer-detected state per device — gates the
@@ -879,7 +926,6 @@ class PipelineRunnerAddon extends BaseAddon {
         }
       );
     }
-    this.stepLogTimer = setInterval(() => this.logAttachedSteps(), STEP_LOG_INTERVAL_MS);
     this.metricsSnapshotTimer = setInterval(
       () => this.emitMetricsSnapshot(),
       METRICS_SNAPSHOT_INTERVAL_MS
@@ -899,10 +945,6 @@ class PipelineRunnerAddon extends BaseAddon {
       clearInterval(this.metricsSnapshotTimer);
       this.metricsSnapshotTimer = null;
     }
-    if (this.stepLogTimer) {
-      clearInterval(this.stepLogTimer);
-      this.stepLogTimer = null;
-    }
     if (this.benchFrameSweeper) {
       clearInterval(this.benchFrameSweeper);
       this.benchFrameSweeper = null;
@@ -1302,51 +1344,6 @@ class PipelineRunnerAddon extends BaseAddon {
     this.runner?.reportMotion(input.deviceId, input.detected, input.source, input.regions);
     return { success: true };
   }
-  /**
-   * Periodic per-camera step roster dump. Once every
-   * STEP_LOG_INTERVAL_MS (30s) emits one log line per attached camera
-   * with the configured detection step tree + audio classifier branch
-   * so an operator looking at the agent log can quickly see what each
-   * camera is currently running without crossing tRPC. Skips when no
-   * cameras are attached so quiet dev runs stay silent.
-   */
-  logAttachedSteps() {
-    if (this.attached.size === 0) return;
-    for (const [deviceId, attachment] of this.attached) {
-      const cfg = attachment.config;
-      const detectionSteps = cfg.steps && cfg.steps.length > 0 ? this.flattenSteps(cfg.steps).filter((s) => s.enabled) : [];
-      const detectionLabel = detectionSteps.length > 0 ? detectionSteps.map((s) => `${s.addonId}/${s.modelId}`).join(" → ") : "<none>";
-      const audioLabel = cfg.audio && cfg.audio.enabled ? `${cfg.audio.engine.runtime}/${cfg.audio.engine.backend}/${cfg.audio.modelId}` : "<off>";
-      const engineLabel = cfg.engine ? `${cfg.engine.runtime}/${cfg.engine.backend}${cfg.engine.device ? `/${cfg.engine.device}` : ""}` : "<unset>";
-      this.ctx.logger.info("Camera pipeline roster", {
-        tags: { deviceId },
-        meta: {
-          phase: "roster",
-          intervalSec: STEP_LOG_INTERVAL_MS / 1e3,
-          pipelineEnabled: cfg.pipelineEnabled,
-          motionSources: cfg.motionSources,
-          motionFps: cfg.motionFps,
-          detectionFps: cfg.detectionFps,
-          engine: engineLabel,
-          videoSteps: detectionLabel,
-          videoStepCount: detectionSteps.length,
-          audio: audioLabel
-        }
-      });
-    }
-  }
-  /** Recursively flatten the step tree → ordered list of every node. */
-  flattenSteps(steps) {
-    const out = [];
-    const walk = (s) => {
-      out.push(s);
-      if (s.children) {
-        for (const c of s.children) walk(c);
-      }
-    };
-    for (const s of steps) walk(s);
-    return out;
-  }
   detachInternal(deviceId) {
     const attachment = this.attached.get(deviceId);
     if (!attachment) return;
@@ -1471,7 +1468,7 @@ class PipelineRunnerAddon extends BaseAddon {
     }
     return startFrameHandlePoller({
       api,
-      brokerId: `${config.deviceId}/${config.motionStreamId}`,
+      brokerId: makeSourceBrokerId(config.deviceId, config.motionStreamId),
       format: "gray",
       maxFps: config.motionFps,
       tag: "motion",
@@ -1557,7 +1554,7 @@ class PipelineRunnerAddon extends BaseAddon {
     }
     return startFrameHandlePoller({
       api,
-      brokerId: `${config.deviceId}/${config.detectionStreamId}`,
+      brokerId: makeSourceBrokerId(config.deviceId, config.detectionStreamId),
       format: "rgb",
       maxFps: config.detectionFps,
       tag: "detection",