@camstack/core 0.1.0 → 0.1.1

package/dist/index.mjs

@@ -1,9 +1,10 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
+import {
+  FsStorageBackend,
+  StorageLocationManager
+} from "./chunk-2F3XZYRW.mjs";
+import {
+  __require
+} from "./chunk-LZOMFHX3.mjs";
 
 // src/events/event-bus.ts
 var EventBus = class {
@@ -60,10 +61,10 @@ async function downloadModel(options) {
     try {
       const bytes = await downloadFile(tryUrl, destPath, onProgress);
       if (expectedSha256) {
-        const hash = await computeSha256(destPath);
-        if (hash !== expectedSha256) {
+        const hash2 = await computeSha256(destPath);
+        if (hash2 !== expectedSha256) {
           fs.unlinkSync(destPath);
-          throw new Error(`SHA256 mismatch: expected ${expectedSha256}, got ${hash}`);
+          throw new Error(`SHA256 mismatch: expected ${expectedSha256}, got ${hash2}`);
         }
       }
       return { filePath: destPath, downloadedBytes: bytes, fromCache: false };
@@ -104,10 +105,10 @@ async function downloadFile(url, destPath, onProgress) {
 }
 async function computeSha256(filePath) {
   return new Promise((resolve, reject) => {
-    const hash = createHash("sha256");
+    const hash2 = createHash("sha256");
     const stream = fs.createReadStream(filePath);
-    stream.on("data", (chunk) => hash.update(chunk));
-    stream.on("end", () => resolve(hash.digest("hex")));
+    stream.on("data", (chunk) => hash2.update(chunk));
+    stream.on("end", () => resolve(hash2.digest("hex")));
     stream.on("error", reject);
   });
 }
@@ -180,6 +181,13 @@ var PythonEnvManager = class {
 // src/addon/addon-loader.ts
 import * as fs3 from "fs";
 import * as path3 from "path";
+function resolveAddonClass(mod) {
+  let candidate = mod["default"] ?? mod[Object.keys(mod)[0]];
+  if (candidate && typeof candidate === "object" && "default" in candidate) {
+    candidate = candidate["default"];
+  }
+  return typeof candidate === "function" ? candidate : void 0;
+}
 var AddonLoader = class {
   addons = /* @__PURE__ */ new Map();
   /** Load all addons from an npm package */
@@ -195,7 +203,7 @@ var AddonLoader = class {
         `${packageName}/${declaration.entry.replace("./dist/", "").replace(/\.js$/, "")}`
       );
       const mod = await import(entryPath);
-      const AddonClass = mod["default"] ?? mod[Object.keys(mod)[0]];
+      const AddonClass = resolveAddonClass(mod);
       if (!AddonClass) {
         throw new Error(`Addon ${declaration.id} from ${packageName} has no default export`);
       }
@@ -207,14 +215,19 @@ var AddonLoader = class {
     }
   }
   /** Load addon from a direct path (for development/testing) */
-  async loadFromPath(addonId, modulePath, packageName) {
+  async loadFromPath(addonId, modulePath, packageName, declaration) {
     const mod = await import(modulePath);
-    const AddonClass = mod["default"] ?? mod[Object.keys(mod)[0]];
+    const AddonClass = resolveAddonClass(mod);
     if (!AddonClass) {
       throw new Error(`Module ${modulePath} has no default export`);
     }
     this.addons.set(addonId, {
-      declaration: { id: addonId, entry: modulePath, slot: "detector" },
+      declaration: {
+        id: addonId,
+        entry: modulePath,
+        slot: "detector",
+        ...declaration
+      },
       packageName,
       addonClass: AddonClass
     });
@@ -262,7 +275,7 @@ var AddonLoader = class {
     for (const declaration of manifest.addons) {
       const entryPath = path3.join(packagePath, declaration.entry);
       const mod = await import(entryPath);
-      const AddonClass = mod["default"] ?? mod[Object.keys(mod)[0]];
+      const AddonClass = resolveAddonClass(mod);
       if (!AddonClass) {
         throw new Error(`Addon ${declaration.id} from ${packageName} has no default export`);
       }
@@ -359,7 +372,15 @@ var AddonInstaller = class {
   }
   /** Install builtin packages if not already present */
   async installBuiltins() {
-    const missing = this.config.builtinPackages.filter((pkg) => !this.isInstalled(pkg));
+    await this.ensureInstalled([...this.config.builtinPackages]);
+  }
+  /**
+   * Ensure a set of packages are installed — installs any that are missing.
+   * This is the public entry-point used during boot to guarantee required
+   * addon packages are present before the loader tries to resolve them.
+   */
+  async ensureInstalled(packages) {
+    const missing = packages.filter((pkg) => !this.isInstalled(pkg));
     if (missing.length === 0) return;
     await this.installPackages(missing);
   }
@@ -441,6 +462,13 @@ var AddonInstaller = class {
       timeout: 12e4
     });
   }
+  /** Install an addon from a local .tgz file */
+  async installFromTgz(tgzPath) {
+    await execFileAsync2("npm", ["install", "--save", tgzPath], {
+      cwd: this.config.addonsDir,
+      timeout: 6e4
+    });
+  }
   /** Update all packages */
   async updateAll() {
     await execFileAsync2("npm", ["update"], {
@@ -454,9 +482,15 @@ var AddonInstaller = class {
   }
 };
 var BUILTIN_PACKAGES = [
-  "@camstack/vision",
-  "@camstack/pipeline-analysis",
-  "@camstack/benchmark"
+  "@camstack/addon-pipeline",
+  "@camstack/addon-vision",
+  "@camstack/addon-go2rtc",
+  "@camstack/addon-benchmark",
+  "@camstack/addon-cloudflare-tunnel",
+  "@camstack/addon-cloudflare-turn",
+  "@camstack/addon-provider-frigate",
+  "@camstack/addon-provider-onvif",
+  "@camstack/addon-provider-rtsp"
 ];
 
 // src/pipeline/pipeline-validator.ts
@@ -526,6 +560,64 @@ var PipelineRunner = class {
       frameTimestamp: frame.timestamp
     };
   }
+  /**
+   * Run only the audio classification node on an audio chunk.
+   * Used by the audio path in DetectionWiringService (separate from video pipeline).
+   */
+  async runAudioNode(chunk, audioNode) {
+    const startTime = performance.now();
+    const results = [];
+    const timings = {};
+    const resultId = randomUUID();
+    const stepStart = performance.now();
+    try {
+      const globalConfig = this.addonConfigs.get(audioNode.addon) ?? {};
+      const engine = await this.engineManager.getOrCreateEngine(
+        audioNode.addon,
+        globalConfig,
+        audioNode.configOverride
+      );
+      if (!("classifyAudio" in engine) || typeof engine["classifyAudio"] !== "function") {
+        throw new Error(`Addon "${audioNode.addon}" has no classifyAudio method`);
+      }
+      const output = await engine.classifyAudio(chunk);
+      const stepMs = performance.now() - stepStart;
+      const stepResult = {
+        addon: audioNode.addon,
+        slot: "classifier",
+        output,
+        resultId,
+        inferenceMs: output.inferenceMs,
+        preprocessMs: 0,
+        totalMs: stepMs
+      };
+      results.push(stepResult);
+      timings[audioNode.step] = stepMs;
+    } catch (error) {
+      const stepMs = performance.now() - stepStart;
+      const message = error instanceof Error ? error.message : String(error);
+      results.push({
+        addon: audioNode.addon,
+        slot: "classifier",
+        output: { classifications: [], inferenceMs: 0, modelId: "" },
+        resultId,
+        inferenceMs: 0,
+        preprocessMs: 0,
+        totalMs: stepMs,
+        error: {
+          code: "ADDON_ERROR",
+          message,
+          childrenSkipped: true
+        }
+      });
+    }
+    return {
+      results,
+      totalMs: performance.now() - startTime,
+      timings,
+      frameTimestamp: chunk.timestamp
+    };
+  }
   async executeNode(node, frame, parentDetection, results, timings) {
     const resultId = randomUUID();
     const stepStart = performance.now();
@@ -605,26 +697,3838 @@ var PipelineRunner = class {
     }
   }
   async executeChildren(children, frame, parentDetections, parentResultId, results, timings) {
-    const promises = [];
+    const promises2 = [];
     for (const detection of parentDetections) {
       for (const child of children) {
-        promises.push(
+        promises2.push(
           this.executeNode(child, frame, { det: detection, resultId: parentResultId }, results, timings)
         );
       }
     }
-    await Promise.allSettled(promises);
+    await Promise.allSettled(promises2);
+  }
+};
+
+// src/capability/capability-registry.ts
+var CapabilityRegistry = class {
+  constructor(logger, configReader) {
+    this.logger = logger;
+    this.configReader = configReader;
+  }
+  capabilities = /* @__PURE__ */ new Map();
+  /** Per-device singleton overrides: deviceId → (capability → addonId) */
+  deviceOverrides = /* @__PURE__ */ new Map();
+  /** Per-device collection filters: deviceId → (capability → addonIds[]) */
+  deviceCollectionFilters = /* @__PURE__ */ new Map();
+  /**
+   * Declare a capability (typically called when addon manifests are loaded).
+   * Must be called before registerProvider/registerConsumer for that capability.
+   */
+  declareCapability(declaration) {
+    if (this.capabilities.has(declaration.name)) {
+      this.logger.debug(`Capability "${declaration.name}" already declared, skipping`);
+      return;
+    }
+    this.capabilities.set(declaration.name, {
+      declaration,
+      available: /* @__PURE__ */ new Map(),
+      activeAddonId: null,
+      activeProvider: null,
+      activeCollection: [],
+      consumers: /* @__PURE__ */ new Set()
+    });
+    this.logger.debug(`Capability declared: ${declaration.name} (mode=${declaration.mode})`);
+  }
+  /**
+   * Register a capability provider (called by addon loader when addon is enabled).
+   * For singleton: auto-activates if user-preferred or first registered.
+   * For collection: adds to active set and notifies consumers.
+   */
+  registerProvider(capability, addonId, provider) {
+    const state = this.capabilities.get(capability);
+    if (!state) {
+      this.logger.warn(`Cannot register provider for undeclared capability "${capability}"`);
+      return;
+    }
+    state.available.set(addonId, provider);
+    this.logger.info(`Provider registered: ${addonId} \u2192 ${capability}`);
+    if (state.declaration.mode === "singleton") {
+      const userChoice = this.configReader(capability);
+      if (userChoice === addonId) {
+        this.activateSingleton(state, addonId, provider);
+      } else if (userChoice === void 0 && state.activeAddonId === null) {
+        this.activateSingleton(state, addonId, provider);
+      }
+    } else {
+      state.activeCollection.push({ addonId, provider });
+      for (const consumer of state.consumers) {
+        if (consumer.onAdded) {
+          try {
+            consumer.onAdded(provider);
+          } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Consumer onAdded failed for ${capability}: ${msg}`);
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Unregister a provider (called when addon is disabled/uninstalled).
+   */
+  unregisterProvider(capability, addonId) {
+    const state = this.capabilities.get(capability);
+    if (!state) return;
+    const provider = state.available.get(addonId);
+    state.available.delete(addonId);
+    if (state.declaration.mode === "singleton") {
+      if (state.activeAddonId === addonId) {
+        state.activeAddonId = null;
+        state.activeProvider = null;
+        this.logger.info(`Singleton deactivated: ${capability} (was ${addonId})`);
+      }
+    } else {
+      const idx = state.activeCollection.findIndex((e) => e.addonId === addonId);
+      if (idx !== -1) {
+        state.activeCollection.splice(idx, 1);
+        for (const consumer of state.consumers) {
+          if (consumer.onRemoved && provider !== void 0) {
+            try {
+              consumer.onRemoved(provider);
+            } catch (error) {
+              const msg = error instanceof Error ? error.message : String(error);
+              this.logger.error(`Consumer onRemoved failed for ${capability}: ${msg}`);
+            }
+          }
+        }
+      }
+    }
+  }
+  /**
+   * Register a consumer that wants to be notified when providers change.
+   * If a provider is already active, the consumer is immediately notified.
+   * Returns a disposer function for cleanup.
+   */
+  registerConsumer(registration) {
+    const state = this.capabilities.get(registration.capability);
+    if (!state) {
+      this.logger.debug(`Consumer registered for undeclared capability "${registration.capability}" \u2014 auto-declaring`);
+      this.declareCapability({ name: registration.capability, mode: "singleton" });
+      return this.registerConsumer(registration);
+    }
+    const untypedReg = registration;
+    state.consumers.add(untypedReg);
+    if (state.declaration.mode === "singleton") {
+      if (state.activeProvider !== null && registration.onSet) {
+        try {
+          registration.onSet(state.activeProvider);
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          this.logger.error(`Consumer onSet (immediate) failed for ${registration.capability}: ${msg}`);
+        }
+      }
+    } else {
+      if (registration.onAdded) {
+        for (const entry of state.activeCollection) {
+          try {
+            registration.onAdded(entry.provider);
+          } catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            this.logger.error(`Consumer onAdded (immediate) failed for ${registration.capability}: ${msg}`);
+          }
+        }
+      }
+    }
+    return () => {
+      state.consumers.delete(untypedReg);
+    };
+  }
+  /**
+   * Get the active singleton provider for a capability.
+   * Returns null if none set.
+   */
+  getSingleton(capability) {
+    const state = this.capabilities.get(capability);
+    if (!state || state.declaration.mode !== "singleton") return null;
+    return state.activeProvider ?? null;
+  }
+  /**
+   * Get all active collection providers for a capability.
+   */
+  getCollection(capability) {
+    const state = this.capabilities.get(capability);
+    if (!state || state.declaration.mode !== "collection") return [];
+    return state.activeCollection.map((e) => e.provider);
+  }
+  /**
+   * Set which addon should be the active singleton for a capability.
+   * Call with `immediate: true` to also swap the runtime provider now
+   * (consumers' onSet will be awaited).
+   */
+  async setActiveSingleton(capability, addonId, immediate = false) {
+    const state = this.capabilities.get(capability);
+    if (!state) {
+      throw new Error(`Unknown capability: ${capability}`);
+    }
+    if (state.declaration.mode !== "singleton") {
+      throw new Error(`Capability "${capability}" is not a singleton`);
+    }
+    const provider = state.available.get(addonId);
+    if (!provider) {
+      throw new Error(`No provider "${addonId}" registered for capability "${capability}"`);
+    }
+    if (immediate) {
+      await this.activateSingletonAsync(state, addonId, provider);
+    }
+    this.logger.info(`Singleton preference set: ${capability} \u2192 ${addonId}`);
+  }
+  /**
+   * Get the mode declared for a capability.
+   */
+  getMode(capability) {
+    return this.capabilities.get(capability)?.declaration.mode;
+  }
+  /**
+   * List all registered capabilities with their providers.
+   */
+  listCapabilities() {
+    const result = [];
+    for (const [name, state] of this.capabilities) {
+      result.push({
+        name,
+        mode: state.declaration.mode,
+        providers: [...state.available.keys()],
+        activeProvider: state.activeAddonId
+      });
+    }
+    return result;
+  }
+  /**
+   * Check if all dependencies for a capability are satisfied (have active providers).
+   */
+  areDependenciesMet(declaration) {
+    if (!declaration.dependsOn?.length) return true;
+    return declaration.dependsOn.every((dep) => {
+      const state = this.capabilities.get(dep);
+      if (!state) return false;
+      if (state.declaration.mode === "singleton") {
+        return state.activeProvider !== null;
+      }
+      return state.activeCollection.length > 0;
+    });
+  }
+  /**
+   * Get the dependency-ordered list of capability names for boot sequencing.
+   * Returns capabilities sorted topologically by dependsOn.
+   * Throws if a cycle is detected.
+   */
+  getBootOrder() {
+    const visited = /* @__PURE__ */ new Set();
+    const visiting = /* @__PURE__ */ new Set();
+    const order = [];
+    const visit = (name) => {
+      if (visited.has(name)) return;
+      if (visiting.has(name)) {
+        throw new Error(`Circular dependency detected involving capability "${name}"`);
+      }
+      visiting.add(name);
+      const state = this.capabilities.get(name);
+      if (state?.declaration.dependsOn) {
+        for (const dep of state.declaration.dependsOn) {
+          visit(dep);
+        }
+      }
+      visiting.delete(name);
+      visited.add(name);
+      order.push(name);
+    };
+    for (const name of this.capabilities.keys()) {
+      visit(name);
+    }
+    return order;
+  }
+  // ---- Per-device overrides ----
+  /**
+   * Set a per-device singleton override. When resolveForDevice is called for
+   * this device + capability, the specified addon's provider is returned
+   * instead of the global singleton.
+   */
+  setDeviceOverride(deviceId, capability, addonId) {
+    const state = this.capabilities.get(capability);
+    if (!state) {
+      this.logger.warn(`Cannot set device override for undeclared capability "${capability}"`);
+      return;
+    }
+    if (!state.available.has(addonId)) {
+      this.logger.warn(`Cannot set device override: addon "${addonId}" not registered for "${capability}"`);
+      return;
+    }
+    let deviceMap = this.deviceOverrides.get(deviceId);
+    if (!deviceMap) {
+      deviceMap = /* @__PURE__ */ new Map();
+      this.deviceOverrides.set(deviceId, deviceMap);
+    }
+    deviceMap.set(capability, addonId);
+    this.logger.info(`Device override set: ${deviceId} \u2192 ${capability} = ${addonId}`);
+  }
+  /**
+   * Clear a per-device singleton override, reverting to the global singleton.
+   */
+  clearDeviceOverride(deviceId, capability) {
+    const deviceMap = this.deviceOverrides.get(deviceId);
+    if (!deviceMap) return;
+    deviceMap.delete(capability);
+    if (deviceMap.size === 0) {
+      this.deviceOverrides.delete(deviceId);
+    }
+    this.logger.info(`Device override cleared: ${deviceId} \u2192 ${capability}`);
+  }
+  /**
+   * Get all per-device singleton overrides for a device.
+   * Returns a Map of capability name to addon ID.
+   */
+  getDeviceOverrides(deviceId) {
+    return new Map(this.deviceOverrides.get(deviceId) ?? []);
+  }
+  /**
+   * Resolve a singleton provider for a specific device.
+   * 1. Check device override — return that addon's provider
+   * 2. Fallback to global singleton
+   */
+  resolveForDevice(capability, deviceId) {
+    const state = this.capabilities.get(capability);
+    if (!state || state.declaration.mode !== "singleton") return null;
+    const deviceMap = this.deviceOverrides.get(deviceId);
+    if (deviceMap) {
+      const overrideAddonId = deviceMap.get(capability);
+      if (overrideAddonId) {
+        const provider = state.available.get(overrideAddonId);
+        if (provider) return provider;
+        this.logger.warn(
+          `Device override for ${deviceId}/${capability} references unregistered addon "${overrideAddonId}" \u2014 falling back to global`
+        );
+      }
+    }
+    return state.activeProvider ?? null;
+  }
+  /**
+   * Set a per-device collection filter. When resolveCollectionForDevice is called
+   * for this device + capability, only providers from the specified addon IDs
+   * are returned instead of the full collection.
+   */
+  setDeviceCollectionFilter(deviceId, capability, addonIds) {
+    const state = this.capabilities.get(capability);
+    if (!state) {
+      this.logger.warn(`Cannot set device collection filter for undeclared capability "${capability}"`);
+      return;
+    }
+    let deviceMap = this.deviceCollectionFilters.get(deviceId);
+    if (!deviceMap) {
+      deviceMap = /* @__PURE__ */ new Map();
+      this.deviceCollectionFilters.set(deviceId, deviceMap);
+    }
+    deviceMap.set(capability, [...addonIds]);
+    this.logger.info(`Device collection filter set: ${deviceId} \u2192 ${capability} = [${addonIds.join(", ")}]`);
+  }
+  /**
+   * Clear a per-device collection filter, reverting to the full collection.
+   */
+  clearDeviceCollectionFilter(deviceId, capability) {
+    const deviceMap = this.deviceCollectionFilters.get(deviceId);
+    if (!deviceMap) return;
+    deviceMap.delete(capability);
+    if (deviceMap.size === 0) {
+      this.deviceCollectionFilters.delete(deviceId);
+    }
+    this.logger.info(`Device collection filter cleared: ${deviceId} \u2192 ${capability}`);
+  }
+  /**
+   * Resolve collection providers for a specific device.
+   * If a filter exists for the device + capability, only those addon's providers are returned.
+   * If no filter exists, the full collection is returned.
+   */
+  resolveCollectionForDevice(capability, deviceId) {
+    const state = this.capabilities.get(capability);
+    if (!state || state.declaration.mode !== "collection") return [];
+    const deviceMap = this.deviceCollectionFilters.get(deviceId);
+    if (deviceMap) {
+      const filterAddonIds = deviceMap.get(capability);
+      if (filterAddonIds) {
+        const filterSet = new Set(filterAddonIds);
+        return state.activeCollection.filter((e) => filterSet.has(e.addonId)).map((e) => e.provider);
+      }
+    }
+    return state.activeCollection.map((e) => e.provider);
+  }
+  /**
+   * Get a specific addon's provider by addon ID, regardless of whether it's the active singleton.
+   * Useful for per-device overrides that need to look up any registered provider.
+   */
+  getProviderByAddonId(capability, addonId) {
+    const state = this.capabilities.get(capability);
+    if (!state) return null;
+    const provider = state.available.get(addonId);
+    return provider ?? null;
+  }
+  activateSingleton(state, addonId, provider) {
+    state.activeAddonId = addonId;
+    state.activeProvider = provider;
+    this.logger.info(`Singleton activated: ${state.declaration.name} \u2192 ${addonId}`);
+    for (const consumer of state.consumers) {
+      if (consumer.onSet) {
+        try {
+          consumer.onSet(provider);
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          this.logger.error(`Consumer onSet failed for ${state.declaration.name}: ${msg}`);
+        }
+      }
+    }
+  }
+  async activateSingletonAsync(state, addonId, provider) {
+    state.activeAddonId = addonId;
+    state.activeProvider = provider;
+    this.logger.info(`Singleton activated (async): ${state.declaration.name} \u2192 ${addonId}`);
+    for (const consumer of state.consumers) {
+      if (consumer.onSet) {
+        try {
+          await consumer.onSet(provider);
+        } catch (error) {
+          const msg = error instanceof Error ? error.message : String(error);
+          this.logger.error(`Consumer onSet (async) failed for ${state.declaration.name}: ${msg}`);
+        }
+      }
+    }
+  }
+};
+
+// src/capability/infra-capabilities.ts
+var INFRA_CAPABILITIES = [
+  { name: "storage", required: true },
+  { name: "log-destination", required: false }
+];
+var infraNames = new Set(INFRA_CAPABILITIES.map((c) => c.name));
+function isInfraCapability(name) {
+  return infraNames.has(name);
+}
+
+// src/process/managed-process.ts
+import { fork, spawn as spawn2 } from "child_process";
+var DEFAULT_MAX_RESTARTS = 10;
+var MAX_BACKOFF_MS = 6e4;
+var GRACEFUL_SHUTDOWN_MS = 5e3;
+var ManagedProcess = class {
+  constructor(config, events, logger) {
+    this.config = config;
+    this.events = events;
+    this.logger = logger;
+  }
+  childProcess = null;
+  _state = "stopped";
+  _startedAt;
+  restartTimer;
+  _restartCount = 0;
+  _lastCrashAt;
+  _lastCrashError;
+  get state() {
+    return this._state;
+  }
+  async start() {
+    this._state = "starting";
+    try {
+      if (this.config.modulePath) {
+        this.childProcess = fork(this.config.modulePath, this.config.args ?? [], {
+          env: { ...process.env, ...this.config.env },
+          stdio: ["pipe", "pipe", "pipe", "ipc"]
+        });
+      } else if (this.config.command) {
+        this.childProcess = spawn2(this.config.command, this.config.args ?? [], {
+          env: { ...process.env, ...this.config.env },
+          stdio: ["pipe", "pipe", "pipe"]
+        });
+      } else {
+        throw new Error("No command or modulePath specified");
+      }
+      this.childProcess.stdout?.on("data", (data) => {
+        this.logger.debug(data.toString().trim());
+      });
+      this.childProcess.stderr?.on("data", (data) => {
+        this.logger.warn(data.toString().trim());
+      });
+      this.childProcess.on("exit", (code, signal) => {
+        const msg = `Process exited: code=${code}, signal=${signal}`;
+        if (code === 0) {
+          this.logger.info(msg);
+          this._state = "stopped";
+        } else {
+          this._lastCrashAt = Date.now();
+          this._lastCrashError = msg;
+          this.logger.error(msg);
+          this._state = "error";
+          this.events.emitProcessCrashed(
+            this.config.id,
+            code,
+            signal,
+            this._restartCount
+          );
+          const maxRestarts = this.config.maxRestarts ?? DEFAULT_MAX_RESTARTS;
+          if (this.config.autoRestart && this._restartCount < maxRestarts) {
+            this.scheduleRestart();
+          }
+        }
+        this.childProcess = null;
+      });
+      this.childProcess.on("error", (err) => {
+        this.logger.error(`Process error: ${err.message}`);
+        this._lastCrashError = err.message;
+        this._state = "error";
+      });
+      this._state = "running";
+      this._startedAt = Date.now();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this._state = "error";
+      this._lastCrashError = msg;
+      throw err;
+    }
+  }
+  async stop() {
+    if (this.restartTimer) {
+      clearTimeout(this.restartTimer);
+      this.restartTimer = void 0;
+    }
+    if (this._state === "stopped") {
+      return;
+    }
+    this._state = "stopping";
+    if (this.childProcess && !this.childProcess.killed) {
+      this.childProcess.kill("SIGTERM");
+      await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+          if (this.childProcess && !this.childProcess.killed) {
+            this.childProcess.kill("SIGKILL");
+          }
+          resolve();
+        }, GRACEFUL_SHUTDOWN_MS);
+        this.childProcess?.on("exit", () => {
+          clearTimeout(timeout);
+          resolve();
+        });
+      });
+    }
+    const currentState = this._state;
+    if (currentState !== "stopped") {
+      this._state = "stopped";
+    }
+  }
+  getStatus() {
+    return {
+      id: this.config.id,
+      label: this.config.label,
+      state: this._state,
+      pid: this.childProcess?.pid,
+      stats: this.childProcess?.pid ? this.getStats() : void 0,
+      lastCrashAt: this._lastCrashAt,
+      lastCrashError: this._lastCrashError,
+      restartCount: this._restartCount,
+      nextRestartAt: this.restartTimer ? this.getNextRestartTime() : void 0
+    };
+  }
+  scheduleRestart() {
+    this._restartCount++;
+    const delayMs = Math.min(1e3 * Math.pow(2, this._restartCount - 1), MAX_BACKOFF_MS);
+    this.logger.info(`Scheduling restart #${this._restartCount} in ${delayMs}ms`);
+    this.events.emitProcessRestartScheduled(
+      this.config.id,
+      this._restartCount,
+      delayMs
+    );
+    this.restartTimer = setTimeout(async () => {
+      this.restartTimer = void 0;
+      try {
+        await this.start();
+        this.events.emitProcessRestarted(this.config.id, this._restartCount);
+      } catch (err) {
+        this.logger.error(`Restart failed: ${err}`);
+      }
+    }, delayMs);
+  }
+  getStats() {
+    if (!this.childProcess?.pid) return void 0;
+    const uptime = this._startedAt ? Date.now() - this._startedAt : 0;
+    return {
+      pid: this.childProcess.pid,
+      cpu: 0,
+      memory: 0,
+      uptime,
+      restartCount: this._restartCount
+    };
+  }
+  getNextRestartTime() {
+    if (!this._lastCrashAt) return void 0;
+    const delayMs = Math.min(1e3 * Math.pow(2, this._restartCount - 1), MAX_BACKOFF_MS);
+    return this._lastCrashAt + delayMs;
+  }
+};
+
+// src/process/process-manager.ts
+var ProcessManager = class {
+  constructor(events, loggerFactory) {
+    this.events = events;
+    this.loggerFactory = loggerFactory;
+  }
+  processes = /* @__PURE__ */ new Map();
+  register(config) {
+    if (this.processes.has(config.id)) {
+      throw new Error(`Process already registered: ${config.id}`);
+    }
+    const logger = this.loggerFactory.createLogger(`process:${config.id}`);
+    const managed = new ManagedProcess(config, this.events, logger);
+    this.processes.set(config.id, managed);
+    return managed;
+  }
+  async start(id) {
+    const p = this.get(id);
+    await p.start();
+  }
+  async stop(id) {
+    const p = this.get(id);
+    await p.stop();
+  }
+  async restart(id) {
+    const p = this.get(id);
+    await p.stop();
+    await p.start();
+  }
+  get(id) {
+    const p = this.processes.get(id);
+    if (!p) throw new Error(`Process not found: ${id}`);
+    return p;
+  }
+  listAll() {
+    return [...this.processes.values()].map((p) => p.getStatus());
+  }
+  async shutdownAll() {
+    const running = [...this.processes.values()].filter(
+      (p) => p.getStatus().state === "running"
+    );
+    await Promise.all(running.map((p) => p.stop()));
+  }
+};
+
+// src/network/network-quality.ts
+var NetworkQualityTracker = class _NetworkQualityTracker {
+  devices = /* @__PURE__ */ new Map();
+  static MAX_SAMPLES = 30;
+  // ~5 min at 10s reporting interval
+  reportStreamStats(deviceId, streamId, bitrateKbps, packetLoss) {
+    const device = this.getOrCreateDevice(deviceId);
+    let stream = device.streams.get(streamId);
+    if (!stream) {
+      stream = { nominalBitrateKbps: bitrateKbps, samples: [], peakBitrateKbps: 0, packetLossSamples: [], lastUpdated: 0 };
+      device.streams.set(streamId, stream);
+    }
+    stream.samples.push(bitrateKbps);
+    if (stream.samples.length > _NetworkQualityTracker.MAX_SAMPLES) stream.samples.shift();
+    stream.peakBitrateKbps = Math.max(stream.peakBitrateKbps, bitrateKbps);
+    if (packetLoss !== void 0) {
+      stream.packetLossSamples.push(packetLoss);
+      if (stream.packetLossSamples.length > _NetworkQualityTracker.MAX_SAMPLES) stream.packetLossSamples.shift();
+    }
+    stream.lastUpdated = Date.now();
+  }
+  reportClientStats(deviceId, stats) {
+    const device = this.getOrCreateDevice(deviceId);
+    device.client = { ...stats, lastUpdated: Date.now() };
+  }
+  getDeviceStats(deviceId) {
+    const device = this.devices.get(deviceId);
+    if (!device) return null;
+    const streams = {};
+    for (const [streamId, s] of device.streams) {
+      const avg = (arr) => arr.length === 0 ? 0 : arr.reduce((a, b) => a + b, 0) / arr.length;
+      streams[streamId] = {
+        nominalBitrateKbps: s.nominalBitrateKbps,
+        observedBitrateKbps: Math.round(avg(s.samples)),
+        peakBitrateKbps: s.peakBitrateKbps,
+        packetLossPercent: Math.round(avg(s.packetLossSamples) * 10) / 10,
+        lastUpdated: s.lastUpdated
+      };
+    }
+    return { deviceId, streams, client: device.client ?? void 0 };
+  }
+  getAllStats() {
+    const results = [];
+    for (const deviceId of this.devices.keys()) {
+      const stats = this.getDeviceStats(deviceId);
+      if (stats) results.push(stats);
+    }
+    return results;
+  }
+  getOrCreateDevice(deviceId) {
+    let device = this.devices.get(deviceId);
+    if (!device) {
+      device = { streams: /* @__PURE__ */ new Map(), client: null };
+      this.devices.set(deviceId, device);
+    }
+    return device;
+  }
+};
+
+// src/repl/repl-engine.ts
+import * as vm from "vm";
+import * as util from "util";
+var EXECUTION_TIMEOUT_MS = 5e3;
+var COMPLETION_TIMEOUT_MS = 1e3;
+var ReplEngine = class {
+  constructor(contextProvider) {
+    this.contextProvider = contextProvider;
+  }
+  async execute(code, context) {
+    const start = Date.now();
+    const sandbox = this.buildSandbox(context);
+    try {
+      const vmContext = vm.createContext(sandbox);
+      const script = new vm.Script(code);
+      let result = script.runInContext(vmContext, { timeout: EXECUTION_TIMEOUT_MS });
+      if (result && typeof result.then === "function") {
+        result = await Promise.race([
+          result,
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("Async timeout (5s)")), EXECUTION_TIMEOUT_MS)
+          )
+        ]);
+      }
+      const duration = Date.now() - start;
+      if (result === void 0) {
+        return { output: "undefined", type: "void", duration };
+      }
+      return {
+        output: util.inspect(result, {
+          depth: 4,
+          colors: false,
+          maxArrayLength: 50,
+          maxStringLength: 1e3
+        }),
+        type: "value",
+        duration
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : typeof err === "object" && err !== null && "message" in err ? String(err.message) : String(err);
+      return {
+        output: message,
+        type: "error",
+        duration: Date.now() - start
+      };
+    }
+  }
+  async getCompletions(partial, context) {
+    const sandbox = this.buildSandbox(context);
+    const keys = Object.keys(sandbox);
+    if (!partial) return keys;
+    const lastDot = partial.lastIndexOf(".");
+    if (lastDot === -1) {
+      return keys.filter((k) => k.startsWith(partial));
+    }
+    const objPath = partial.substring(0, lastDot);
+    const propPrefix = partial.substring(lastDot + 1);
+    try {
+      const vmContext = vm.createContext(sandbox);
+      const obj = vm.runInContext(objPath, vmContext, { timeout: COMPLETION_TIMEOUT_MS });
+      if (obj && typeof obj === "object") {
+        const proto = Object.getPrototypeOf(obj);
+        const objKeys = Object.getOwnPropertyNames(obj).concat(Object.getOwnPropertyNames(proto ?? {})).filter((k) => k.startsWith(propPrefix));
+        return [...new Set(objKeys)].map((k) => `${objPath}.${k}`);
+      }
+    } catch {
+    }
+    return [];
+  }
+  buildSandbox(context) {
+    const base = {
+      console: {
+        log: (...args) => util.inspect(args),
+        warn: (...args) => util.inspect(args)
+      },
+      JSON,
+      Math,
+      Date,
+      Array,
+      Object,
+      String,
+      Number,
+      Boolean,
+      Map,
+      Set,
+      Promise,
+      Buffer,
+      // Blocked globals
+      setTimeout: void 0,
+      setInterval: void 0,
+      fetch: void 0,
+      require: void 0,
+      process: void 0,
+      // Merge user-provided variables
+      ...context.variables
+    };
+    switch (context.scope.type) {
+      case "system":
+        return { ...base, ...this.contextProvider.getSystemSandbox() };
+      case "device":
+        return { ...base, ...this.contextProvider.getDeviceSandbox(context.scope.deviceId) };
+      case "provider":
+        return { ...base, ...this.contextProvider.getProviderSandbox(context.scope.providerId) };
+      case "addon":
+        return { ...base, ...this.contextProvider.getAddonSandbox(context.scope.addonId) };
+      default:
+        return base;
+    }
+  }
+};
+
+// src/agent/agent-registry.ts
+var AgentRegistry = class {
+  constructor(events, heartbeatTimeoutMs = 3e4, heartbeatCheckIntervalMs = 1e4) {
+    this.events = events;
+    this.heartbeatTimeoutMs = heartbeatTimeoutMs;
+    this.heartbeatCheckIntervalMs = heartbeatCheckIntervalMs;
+  }
+  agents = /* @__PURE__ */ new Map();
+  heartbeatIntervals = /* @__PURE__ */ new Map();
+  /** Register a new agent */
+  registerAgent(info) {
+    const entry = {
+      info,
+      state: "online",
+      connectedSince: Date.now(),
+      lastHeartbeat: Date.now(),
+      activeTaskCount: 0,
+      completedTaskCount: 0,
+      failedTaskCount: 0
+    };
+    this.agents.set(info.id, entry);
+    this.startHeartbeatCheck(info.id);
+    this.events.emitAgentRegistered(info.id, [...info.capabilities]);
+  }
+  /** Remove agent */
+  unregisterAgent(id) {
+    const interval = this.heartbeatIntervals.get(id);
+    if (interval) {
+      clearInterval(interval);
+      this.heartbeatIntervals.delete(id);
+    }
+    this.agents.delete(id);
+    this.events.emitAgentUnregistered(id);
+  }
+  /** Update heartbeat timestamp */
+  heartbeat(id) {
+    const entry = this.agents.get(id);
+    if (!entry) return;
+    entry.lastHeartbeat = Date.now();
+    if (entry.state === "offline") {
+      entry.state = "online";
+      this.events.emitAgentOnline(id);
+    }
+  }
+  /** Find agents with a specific capability */
+  getAgentsWithCapability(capability) {
+    return [...this.agents.values()].filter(
+      (a) => a.state === "online" && a.info.capabilities.includes(capability)
+    );
+  }
+  /** Get best agent for a task (least loaded) */
+  selectAgent(capability, preferredId) {
+    const capable = this.getAgentsWithCapability(capability);
+    if (capable.length === 0) return null;
+    if (preferredId) {
+      const preferred = capable.find((a) => a.info.id === preferredId);
+      if (preferred) return preferred;
+    }
+    const sorted = [...capable].sort((a, b) => a.activeTaskCount - b.activeTaskCount);
+    return sorted[0] ?? null;
+  }
+  /** List all agents with status */
+  listAgents() {
+    return [...this.agents.values()].map((entry) => ({
+      id: entry.info.id,
+      name: entry.info.name,
+      state: entry.state,
+      capabilities: [...entry.info.capabilities],
+      lastHeartbeat: entry.lastHeartbeat,
+      connectedSince: entry.connectedSince,
+      resources: entry.info.resources,
+      activeTaskCount: entry.activeTaskCount,
+      completedTaskCount: entry.completedTaskCount,
+      failedTaskCount: entry.failedTaskCount
+    }));
+  }
+  /** Get single agent */
+  getAgent(id) {
+    return this.agents.get(id) ?? null;
+  }
+  /** Destroy all heartbeat intervals */
+  destroy() {
+    for (const interval of this.heartbeatIntervals.values()) {
+      clearInterval(interval);
+    }
+    this.heartbeatIntervals.clear();
+  }
+  startHeartbeatCheck(id) {
+    const interval = setInterval(() => {
+      const entry = this.agents.get(id);
+      if (!entry) return;
+      const elapsed = Date.now() - entry.lastHeartbeat;
+      if (elapsed > this.heartbeatTimeoutMs && entry.state === "online") {
+        entry.state = "offline";
+        this.events.emitAgentOffline(id);
+      }
+    }, this.heartbeatCheckIntervalMs);
+    this.heartbeatIntervals.set(id, interval);
+  }
+};
+
+// src/agent/task-dispatcher.ts
+var TaskDispatcher = class {
+  constructor(agentRegistry, events) {
+    this.agentRegistry = agentRegistry;
+    this.events = events;
+  }
+  pendingTasks = /* @__PURE__ */ new Map();
+  localExecutors = /* @__PURE__ */ new Map();
+  /** Dispatch a task to the best available agent */
+  async dispatch(task, options) {
+    const capability = options?.capability ?? task.capability;
+    const agent = this.agentRegistry.selectAgent(capability, options?.preferredAgent);
+    if (!agent && !options?.remoteOnly) {
+      return this.executeLocally(task);
+    }
+    if (!agent) {
+      return {
+        taskId: task.id,
+        agentId: "none",
+        status: "error",
+        error: "No agent available",
+        durationMs: 0
+      };
+    }
+    return this.sendToAgent(task, agent);
+  }
+  /** Register a local executor for a capability (in-process fallback) */
+  registerLocalExecutor(capability, executor) {
+    this.localExecutors.set(capability, executor);
+  }
+  /** Called when an agent returns a result */
+  handleTaskResult(result) {
+    const pending = this.pendingTasks.get(result.taskId);
+    if (pending) {
+      clearTimeout(pending.timeout);
+      this.pendingTasks.delete(result.taskId);
+      pending.resolve(result);
+    }
+    const agent = this.agentRegistry.getAgent(result.agentId);
+    if (agent) {
+      agent.activeTaskCount--;
+      if (result.status === "success") {
+        agent.completedTaskCount++;
+      } else {
+        agent.failedTaskCount++;
+      }
+    }
+  }
+  async executeLocally(task) {
+    const executor = this.localExecutors.get(task.capability);
+    if (!executor) {
+      return {
+        taskId: task.id,
+        agentId: "local",
+        status: "error",
+        error: `No local executor for ${task.capability}`,
+        durationMs: 0
+      };
+    }
+    const start = Date.now();
+    try {
+      const output = await executor(task.input);
+      return {
+        taskId: task.id,
+        agentId: "local",
+        status: "success",
+        output,
+        durationMs: Date.now() - start
+      };
+    } catch (err) {
+      return {
+        taskId: task.id,
+        agentId: "local",
+        status: "error",
+        error: String(err),
+        durationMs: Date.now() - start
+      };
+    }
+  }
+  sendToAgent(task, agent) {
+    agent.activeTaskCount++;
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        this.pendingTasks.delete(task.id);
+        agent.activeTaskCount--;
+        agent.failedTaskCount++;
+        resolve({
+          taskId: task.id,
+          agentId: agent.info.id,
+          status: "timeout",
+          durationMs: task.timeout,
+          error: "Task timed out"
+        });
+      }, task.timeout);
+      this.pendingTasks.set(task.id, { resolve, reject: () => {
+      }, timeout });
+      this.events.emitTaskDispatched(task.id, agent.info.id, task.capability);
+    });
+  }
+};
+
+// src/agent/agent-client.ts
+var RECONNECT_BASE_MS = 1e3;
+var RECONNECT_MAX_MS = 3e4;
+var HEARTBEAT_INTERVAL_MS = 1e4;
+var AgentClient = class {
+  ws = null;
+  reconnectAttempt = 0;
+  reconnectTimer = null;
+  heartbeatTimer = null;
+  destroyed = false;
+  messageHandlers = [];
+  binaryHandlers = [];
+  connectHandlers = [];
+  disconnectHandlers = [];
+  logger;
+  hubUrl;
+  token;
+  registrationInfo;
+  runtimeStatus = {
+    activeCameras: 0,
+    cpuPercent: 0,
+    memoryPercent: 0,
+    fps: {},
+    errors: []
+  };
+  constructor(config) {
+    this.hubUrl = config.hubUrl;
+    this.token = config.token;
+    this.logger = config.logger;
+    this.registrationInfo = config.registrationInfo;
+  }
+  /** Connect to the hub WebSocket */
+  async connect() {
+    return new Promise((resolve, reject) => {
+      this.destroyed = false;
+      this.doConnect(resolve, reject);
+    });
+  }
+  /** Disconnect and stop reconnecting */
+  disconnect() {
+    this.destroyed = true;
+    this.clearTimers();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  /** Send a JSON control message to the hub */
+  send(msg) {
+    if (!this.ws || this.ws.readyState !== 1) {
+      this.logger.warn("send() called while not connected");
+      return;
+    }
+    this.ws.send(JSON.stringify(msg));
+  }
+  /** Send a binary frame to the hub */
+  sendBinary(data) {
+    if (!this.ws || this.ws.readyState !== 1) {
+      return;
+    }
+    this.ws.send(data);
+  }
+  /** Register a handler for JSON messages from hub */
+  onMessage(handler) {
+    this.messageHandlers.push(handler);
+  }
+  /** Register a handler for binary frames from hub */
+  onBinaryFrame(handler) {
+    this.binaryHandlers.push(handler);
+  }
+  /** Register a handler for successful connection */
+  onConnect(handler) {
+    this.connectHandlers.push(handler);
+  }
+  /** Register a handler for disconnection */
+  onDisconnect(handler) {
+    this.disconnectHandlers.push(handler);
+  }
+  /** Update the runtime status (used in heartbeat) */
+  updateStatus(status) {
+    this.runtimeStatus = status;
+  }
+  /** Whether currently connected */
+  get connected() {
+    return this.ws?.readyState === 1;
+  }
+  doConnect(onConnect, onError) {
+    if (this.destroyed) return;
+    import("./wrapper-NTBY5HOA.mjs").then(({ default: WebSocket }) => {
+      if (this.destroyed) return;
+      const url = this.token ? `${this.hubUrl}?token=${encodeURIComponent(this.token)}` : this.hubUrl;
+      try {
+        this.ws = new WebSocket(url);
+      } catch (err) {
+        this.scheduleReconnect();
+        if (onError) {
+          onError(err instanceof Error ? err : new Error(String(err)));
+          onError = void 0;
+        }
+        return;
+      }
+      this.ws.once("open", () => {
+        this.reconnectAttempt = 0;
+        this.logger.info(`Connected to hub: ${this.hubUrl}`);
+        this.send({ type: "register", info: this.registrationInfo });
+        this.startHeartbeat();
+        for (const h of this.connectHandlers) h();
+        if (onConnect) {
+          onConnect();
+          onConnect = void 0;
+        }
+      });
+      this.ws.on("message", (data, isBinary) => {
+        const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+        if (isBinary) {
+          for (const h of this.binaryHandlers) h(buf);
+        } else {
+          try {
+            const msg = JSON.parse(buf.toString());
+            this.handleBuiltinMessage(msg);
+            for (const h of this.messageHandlers) h(msg);
+          } catch {
+            this.logger.warn("Failed to parse message from hub");
+          }
+        }
+      });
+      this.ws.once("close", () => {
+        this.stopHeartbeat();
+        for (const h of this.disconnectHandlers) h();
+        if (!this.destroyed) {
+          this.logger.warn("Disconnected from hub, scheduling reconnect");
+          this.scheduleReconnect();
+        }
+      });
+      this.ws.once("error", (err) => {
+        this.logger.error("WebSocket error", { message: err.message });
+        if (onError) {
+          onError(err);
+          onError = void 0;
+        }
+      });
+    }).catch((err) => {
+      this.logger.error("Failed to import ws module", { message: String(err) });
+      if (onError) {
+        onError(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+  handleBuiltinMessage(msg) {
+    if (msg.type === "ping") {
+      this.send({ type: "pong" });
+    }
+  }
+  scheduleReconnect() {
+    if (this.destroyed) return;
+    const delay = Math.min(
+      RECONNECT_BASE_MS * Math.pow(2, this.reconnectAttempt),
+      RECONNECT_MAX_MS
+    );
+    this.reconnectAttempt++;
+    this.logger.info(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempt})`);
+    this.reconnectTimer = setTimeout(() => {
+      this.doConnect();
+    }, delay);
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatTimer = setInterval(() => {
+      this.send({ type: "heartbeat", status: this.runtimeStatus });
+    }, HEARTBEAT_INTERVAL_MS);
+  }
+  stopHeartbeat() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  clearTimers() {
+    this.stopHeartbeat();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+};
+
+// src/agent/agent-task-runner.ts
+var AgentTaskRunner = class {
+  constructor(agentId, client, logger) {
+    this.agentId = agentId;
+    this.client = client;
+    this.logger = logger.child("TaskRunner");
+  }
+  handlers = /* @__PURE__ */ new Map();
+  runningTasks = /* @__PURE__ */ new Map();
+  logger;
+  /** Register a task handler for a given task type */
+  registerHandler(handler) {
+    if (this.handlers.has(handler.taskType)) {
+      this.logger.warn(`Overwriting handler for task type: ${handler.taskType}`);
+    }
+    this.handlers.set(handler.taskType, handler);
+    this.logger.debug(`Registered handler: ${handler.taskType}`);
+  }
+  /** Unregister a task handler */
+  unregisterHandler(taskType) {
+    this.handlers.delete(taskType);
+  }
+  /** Get all registered task types */
+  getTaskTypes() {
+    return [...this.handlers.keys()];
+  }
+  /** Get a handler by task type */
+  getHandler(taskType) {
+    return this.handlers.get(taskType);
+  }
+  /**
+   * Execute a task dispatched from the hub.
+   * Sends result or error back to hub via the AgentClient.
+   */
+  async executeTask(taskId, taskType, payload) {
+    const handler = this.handlers.get(taskType);
+    if (!handler) {
+      this.client.send({
+        type: "task.result",
+        taskId,
+        success: false,
+        error: `No handler registered for task type: ${taskType}`
+      });
+      return;
+    }
+    const runningTask = { taskId, taskType, cancelled: false };
+    this.runningTasks.set(taskId, runningTask);
+    const context = {
+      taskId,
+      agentId: this.agentId,
+      logger: this.logger.child(taskType),
+      reportProgress: (progress) => {
+        this.client.send({ type: "task.progress", taskId, progress });
+      },
+      isCancelled: () => runningTask.cancelled
+    };
+    try {
+      const result = await handler.handle(payload, context);
+      this.runningTasks.delete(taskId);
+      if (!runningTask.cancelled) {
+        this.client.send({
+          type: "task.result",
+          taskId,
+          success: true,
+          result
+        });
+      }
+    } catch (err) {
+      this.runningTasks.delete(taskId);
+      this.logger.error(`Task ${taskType} (${taskId}) failed`, {
+        message: err instanceof Error ? err.message : String(err)
+      });
+      this.client.send({
+        type: "task.result",
+        taskId,
+        success: false,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  /** Cancel a running task */
+  async cancelTask(taskId) {
+    const running = this.runningTasks.get(taskId);
+    if (!running) return;
+    running.cancelled = true;
+    const handler = this.handlers.get(running.taskType);
+    if (handler?.cancel) {
+      try {
+        await handler.cancel();
+      } catch (err) {
+        this.logger.error(`Error cancelling task ${taskId}`, {
+          message: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+    this.runningTasks.delete(taskId);
+  }
+  /** Number of currently running tasks */
+  get activeTaskCount() {
+    return this.runningTasks.size;
+  }
+  /** Destroy: cancel all running tasks */
+  async destroy() {
+    const taskIds = [...this.runningTasks.keys()];
+    for (const taskId of taskIds) {
+      await this.cancelTask(taskId);
+    }
+    this.handlers.clear();
+  }
+};
+
+// src/agent/pipeline-task-handlers.ts
+var DecodeTaskHandler = class {
+  taskType = "pipeline.decode";
+  description = "Decode an RTSP stream and produce JPEG frames";
+  async handle(payload, context) {
+    const { logger } = context;
+    const config = payload;
+    if (!config.cameraId || !config.rtspUrl) {
+      throw new Error("pipeline.decode requires cameraId and rtspUrl in payload");
+    }
+    logger.info(`Decode task started: camera=${config.cameraId} url=${config.rtspUrl} fps=${config.fps ?? 1}`);
+    return { status: "started", cameraId: config.cameraId };
+  }
+  async cancel() {
+  }
+};
+var DetectTaskHandler = class {
+  taskType = "pipeline.detect";
+  description = "Run object detection on received frames";
+  async handle(payload, context) {
+    const { logger } = context;
+    const config = payload;
+    if (!config.cameraId) {
+      throw new Error("pipeline.detect requires cameraId in payload");
+    }
+    logger.info(`Detect task started: camera=${config.cameraId} model=${config.modelId ?? "default"} runtime=${config.runtime ?? "auto"}`);
+    return { status: "started", cameraId: config.cameraId };
+  }
+  async cancel() {
+  }
+};
+var RecordTaskHandler = class {
+  taskType = "pipeline.record";
+  description = "Record an RTSP stream to disk segments";
+  async handle(payload, context) {
+    const { logger } = context;
+    const config = payload;
+    if (!config.cameraId || !config.rtspUrl) {
+      throw new Error("pipeline.record requires cameraId and rtspUrl in payload");
+    }
+    logger.info(`Record task started: camera=${config.cameraId} url=${config.rtspUrl}`);
+    return { status: "started", cameraId: config.cameraId };
+  }
+  async cancel() {
+  }
+};
+
+// src/builtins/sqlite-storage/sqlite-storage.provider.ts
+import Database from "better-sqlite3";
+import * as fs5 from "fs";
+import * as path5 from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+var LOCATION_TYPES = {
+  // New location names (from StorageLocationManager)
+  data: "structured",
+  // settings, events, trails — SQL only
+  media: "files",
+  // crops, snapshots, thumbnails — files only
+  recordings: "files",
+  // video segments — files only
+  models: "files",
+  // ONNX/TFLite models — files only
+  cache: "files",
+  // temp files — files only
+  logs: "files",
+  // Winston log files — files only
+  // Legacy location names (backward compat)
+  config: "structured",
+  events: "structured",
+  addon: "both"
+};
+var SqliteStructuredStorage = class {
+  constructor(db) {
+    this.db = db;
+  }
+  ensuredTables = /* @__PURE__ */ new Set();
+  ensureTable(collection) {
+    if (this.ensuredTables.has(collection)) return;
+    this.db.exec(
+      `CREATE TABLE IF NOT EXISTS "${collection}" (id TEXT PRIMARY KEY, data TEXT)`
+    );
+    this.ensuredTables.add(collection);
+  }
+  async insert(record) {
+    this.ensureTable(record.collection);
+    const id = record.id || randomUUID2();
+    const newRecord = {
+      collection: record.collection,
+      id,
+      data: record.data
+    };
+    this.db.prepare(`INSERT INTO "${record.collection}" (id, data) VALUES (?, ?)`).run(id, JSON.stringify(newRecord.data));
+    return newRecord;
+  }
+  async query(collection, filter) {
+    this.ensureTable(collection);
+    const { sql, params } = this.buildSelect(collection, filter);
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((row) => ({
+      collection,
+      id: row.id,
+      data: JSON.parse(row.data)
+    }));
+  }
+  async update(collection, id, data) {
+    this.ensureTable(collection);
+    this.db.prepare(`UPDATE "${collection}" SET data = ? WHERE id = ?`).run(JSON.stringify(data), id);
+    return { collection, id, data };
+  }
+  async delete(collection, id) {
+    this.ensureTable(collection);
+    this.db.prepare(`DELETE FROM "${collection}" WHERE id = ?`).run(id);
+  }
+  async count(collection, filter) {
+    this.ensureTable(collection);
+    const { sql, params } = this.buildCount(collection, filter);
+    const row = this.db.prepare(sql).get(...params);
+    return row.cnt;
+  }
+  buildWhereClause(filter) {
+    if (!filter) return { clause: "", params: [] };
+    const conditions = [];
+    const params = [];
+    if (filter.where) {
+      for (const [field, value] of Object.entries(filter.where)) {
+        if (field === "id") {
+          conditions.push("id = ?");
+          params.push(value);
+        } else {
+          conditions.push(`json_extract(data, '$.${field}') = ?`);
+          params.push(value);
+        }
+      }
+    }
+    if (filter.whereIn) {
+      for (const [field, values] of Object.entries(filter.whereIn)) {
+        const placeholders = values.map(() => "?").join(", ");
+        if (field === "id") {
+          conditions.push(`id IN (${placeholders})`);
+        } else {
+          conditions.push(`json_extract(data, '$.${field}') IN (${placeholders})`);
+        }
+        params.push(...values);
+      }
+    }
+    if (filter.whereBetween) {
+      for (const [field, [low, high]] of Object.entries(filter.whereBetween)) {
+        if (field === "id") {
+          conditions.push("id BETWEEN ? AND ?");
+        } else {
+          conditions.push(`json_extract(data, '$.${field}') BETWEEN ? AND ?`);
+        }
+        params.push(low, high);
+      }
+    }
+    const clause = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
+    return { clause, params };
+  }
+  buildSelect(collection, filter) {
+    const { clause, params } = this.buildWhereClause(filter);
+    let sql = `SELECT id, data FROM "${collection}"${clause}`;
+    if (filter?.orderBy) {
+      const dir = filter.orderBy.direction === "desc" ? "DESC" : "ASC";
+      if (filter.orderBy.field === "id") {
+        sql += ` ORDER BY id ${dir}`;
+      } else {
+        sql += ` ORDER BY json_extract(data, '$.${filter.orderBy.field}') ${dir}`;
+      }
+    }
+    if (filter?.limit !== void 0) {
+      sql += ` LIMIT ?`;
+      params.push(filter.limit);
+    }
+    if (filter?.offset !== void 0) {
+      sql += ` OFFSET ?`;
+      params.push(filter.offset);
+    }
+    return { sql, params };
+  }
+  buildCount(collection, filter) {
+    const { clause, params } = this.buildWhereClause(filter);
+    return { sql: `SELECT COUNT(*) as cnt FROM "${collection}"${clause}`, params };
+  }
+};
+var FileSystemStorage = class {
+  constructor(basePath) {
+    this.basePath = basePath;
+  }
+  async readFile(filePath) {
+    const fullPath = path5.join(this.basePath, filePath);
+    return fs5.promises.readFile(fullPath);
+  }
+  async writeFile(filePath, data) {
+    const fullPath = path5.join(this.basePath, filePath);
+    fs5.mkdirSync(path5.dirname(fullPath), { recursive: true });
+    await fs5.promises.writeFile(fullPath, data);
+  }
+  async deleteFile(filePath) {
+    const fullPath = path5.join(this.basePath, filePath);
+    await fs5.promises.unlink(fullPath);
+  }
+  async listFiles(prefix) {
+    const searchDir = prefix ? path5.join(this.basePath, prefix) : this.basePath;
+    try {
+      const entries = await fs5.promises.readdir(searchDir, { recursive: true });
+      const files = [];
+      for (const entry of entries) {
+        const entryStr = String(entry);
+        const relative = prefix ? path5.join(prefix, entryStr) : entryStr;
+        const fullPath = path5.join(this.basePath, relative);
+        try {
+          const stat = await fs5.promises.stat(fullPath);
+          if (stat.isFile()) {
+            files.push(relative);
+          }
+        } catch {
+        }
+      }
+      return files;
+    } catch {
+      return [];
+    }
+  }
+  async getFileUrl(_path) {
+    return null;
+  }
+  async exists(filePath) {
+    const fullPath = path5.join(this.basePath, filePath);
+    try {
+      await fs5.promises.access(fullPath, fs5.constants.F_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+var SqliteStorageProvider = class {
+  mainDb = null;
+  sharedStructured = null;
+  locations = /* @__PURE__ */ new Map();
+  async initialize() {
+  }
+  /**
+   * Configure all storage locations.
+   * ONE single SQLite database (camstack.db) is used for ALL structured storage.
+   * File-based locations use the filesystem at their configured path.
+   */
+  async configure(config) {
+    const dataPath = config.locations["data"] ?? config.locations["config"] ?? Object.values(config.locations)[0];
+    if (!dataPath) throw new Error("No data path configured for SQLite storage");
+    fs5.mkdirSync(dataPath, { recursive: true });
+    const dbPath = path5.join(dataPath, "camstack.db");
+    this.mainDb = new Database(dbPath);
+    this.mainDb.pragma("journal_mode = WAL");
+    this.sharedStructured = new SqliteStructuredStorage(this.mainDb);
+    for (const [name, dirPath] of Object.entries(config.locations)) {
+      const locationName = name;
+      const locationType = LOCATION_TYPES[name] ?? "files";
+      fs5.mkdirSync(dirPath, { recursive: true });
+      const location = {};
+      if (locationType === "structured" || locationType === "both") {
+        location.structured = this.sharedStructured;
+      }
+      if (locationType === "files" || locationType === "both") {
+        location.files = new FileSystemStorage(dirPath);
+      }
+      this.locations.set(locationName, location);
+    }
+  }
+  getLocation(name) {
+    const location = this.locations.get(name);
+    if (!location) {
+      throw new Error(`Storage location "${name}" not found`);
+    }
+    return location;
+  }
+  async shutdown() {
+    if (this.mainDb) {
+      this.mainDb.close();
+      this.mainDb = null;
+      this.sharedStructured = null;
+    }
+    this.locations.clear();
+  }
+  async export(_locationName) {
+    throw new Error("Export not yet implemented");
+  }
+  async import(_locationName, _data) {
+    throw new Error("Import not yet implemented");
+  }
+};
+
+// src/builtins/sqlite-storage/sqlite-storage.addon.ts
+var SqliteStorageAddon = class {
+  manifest = {
+    id: "sqlite-storage",
+    name: "SQLite Storage",
+    version: "1.0.0",
+    capabilities: ["storage"]
+  };
+  provider = null;
+  async initialize(context) {
+    const storageConfig = {
+      locations: { ...context.locationPaths }
+    };
+    this.provider = new SqliteStorageProvider();
+    await this.provider.configure(storageConfig);
+    context.logger.info("SQLite storage initialized");
+  }
+  async shutdown() {
+    await this.provider?.shutdown();
+  }
+  getProvider() {
+    if (!this.provider) throw new Error("SQLite storage not initialized");
+    return this.provider;
+  }
+  getCapabilityProvider(name) {
+    if (name === "storage" && this.provider) {
+      return this.provider;
+    }
+    return null;
+  }
+  getConfigSchema() {
+    return {
+      sections: []
+    };
+  }
+  getConfig() {
+    return {};
+  }
+  async onConfigChange(_config) {
+  }
+};
+
+// src/builtins/winston-logging/winston-destination.ts
+import * as winston from "winston";
+import DailyRotateFile from "winston-daily-rotate-file";
+import * as path6 from "path";
+function formatScope(scope) {
+  if (scope.length === 0) return "";
+  const [first, ...rest] = scope;
+  const restFormatted = rest.map((s) => `[${s}]`).join("");
+  return `(${first})${restFormatted}`;
+}
+var WinstonDestination = class {
+  logger = null;
+  async initialize(config) {
+    const {
+      level = "info",
+      retentionDays = 30,
+      logsDir = path6.join("./data", "logs")
+    } = config ?? {};
+    const consoleFormat = winston.format.combine(
+      winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
+      winston.format.colorize(),
+      winston.format.printf(({ timestamp, level: lvl, message, scope }) => {
+        const scopeStr = scope ? ` ${scope}` : "";
+        return `${timestamp} [${lvl}]${scopeStr} - ${message}`;
+      })
+    );
+    const fileFormat = winston.format.combine(
+      winston.format.timestamp(),
+      winston.format.json()
+    );
+    this.logger = winston.createLogger({
+      level,
+      transports: [
+        new winston.transports.Console({
+          format: consoleFormat
+        }),
+        new DailyRotateFile({
+          dirname: logsDir,
+          filename: "camstack-%DATE%.log",
+          datePattern: "YYYY-MM-DD",
+          maxFiles: `${retentionDays}d`,
+          format: fileFormat
+        })
+      ]
+    });
+  }
+  write(entry) {
+    if (!this.logger) return;
+    const scope = formatScope(entry.scope);
+    const meta = entry.meta ?? {};
+    this.logger.log({
+      level: entry.level,
+      message: entry.message,
+      scope,
+      timestamp: entry.timestamp.toISOString(),
+      ...meta
+    });
+  }
+  async query(_filter) {
+    return [];
+  }
+  async shutdown() {
+    if (!this.logger) return;
+    await new Promise((resolve) => {
+      this.logger.on("finish", resolve);
+      this.logger.end();
+    });
+    this.logger = null;
+  }
+};
+
+// src/builtins/winston-logging/winston-logging.addon.ts
+var WinstonLoggingAddon = class {
+  manifest = {
+    id: "winston-logging",
+    name: "Winston Logging",
+    version: "1.0.0",
+    capabilities: ["log-destination"]
+  };
+  destination = null;
+  currentConfig = {
+    level: "info",
+    retentionDays: 30
+  };
+  async initialize(context) {
+    this.currentConfig = {
+      level: context.addonConfig.level ?? this.currentConfig.level,
+      retentionDays: context.addonConfig.retentionDays ?? this.currentConfig.retentionDays
+    };
+    const logsDir = context.locationPaths.logs;
+    this.destination = new WinstonDestination();
+    await this.destination.initialize({ ...this.currentConfig, logsDir });
+    context.logger.info("Winston logging initialized");
+  }
+  async shutdown() {
+    await this.destination?.shutdown();
+  }
+  getDestination() {
+    if (!this.destination) throw new Error("Winston not initialized");
+    return this.destination;
+  }
+  getCapabilityProvider(name) {
+    if (name === "log-destination" && this.destination) {
+      return this.destination;
+    }
+    return null;
+  }
+  getConfigSchema() {
+    return {
+      sections: [
+        {
+          id: "logging",
+          title: "Logging Settings",
+          columns: 2,
+          fields: [
+            {
+              type: "select",
+              key: "level",
+              label: "Log Level",
+              description: "Minimum severity of messages that will be written to log files",
+              options: [
+                { value: "error", label: "Error", description: "Only critical errors" },
+                { value: "warn", label: "Warning", description: "Errors and warnings" },
+                { value: "info", label: "Info", description: "General operational messages (recommended)" },
+                { value: "debug", label: "Debug", description: "Verbose output for debugging" }
+              ]
+            },
+            {
+              type: "number",
+              key: "retentionDays",
+              label: "Log Retention",
+              description: "Number of days to keep log files before automatic deletion",
+              min: 1,
+              max: 365,
+              step: 1,
+              unit: "days"
+            }
+          ]
+        }
+      ]
+    };
+  }
+  getConfig() {
+    return { ...this.currentConfig };
+  }
+  async onConfigChange(config) {
+    this.currentConfig = {
+      level: config.level ?? this.currentConfig.level,
+      retentionDays: config.retentionDays ?? this.currentConfig.retentionDays
+    };
+  }
+};
+
+// src/builtins/local-backup/local-backup.ts
+import { randomUUID as randomUUID3 } from "crypto";
+var LocalBackupService = class {
+  constructor(config, logger, eventBus, storage) {
+    this.config = config;
+    this.logger = logger;
+    this.eventBus = eventBus;
+    this.storage = storage;
+  }
+  manifests = [];
+  /** Create a backup of specified locations */
+  async backup(options) {
+    const id = randomUUID3();
+    const timestamp = Date.now();
+    const locations = options?.locations ?? ["config", "events", "logs"];
+    this.logger.info(`Starting backup ${id} (${locations.join(", ")})`);
+    const manifest = {
+      id,
+      timestamp,
+      label: options?.label,
+      locations,
+      sizeMB: 0,
+      path: `${this.config.backupDir}/${id}`
+    };
+    const updated = [...this.manifests, manifest];
+    this.manifests = updated;
+    await this.pruneOldBackups();
+    this.eventBus.emit({
+      id: randomUUID3(),
+      timestamp: /* @__PURE__ */ new Date(),
+      source: { type: "addon", id: "local-backup" },
+      category: "backup.completed",
+      data: { backupId: id, locations: [...locations], sizeMB: manifest.sizeMB }
+    });
+    this.logger.info(`Backup ${id} completed`);
+    return manifest;
+  }
+  /** Restore from a backup */
+  async restore(backupId) {
+    const manifest = this.manifests.find((m) => m.id === backupId);
+    if (!manifest) throw new Error(`Backup ${backupId} not found`);
+    this.logger.info(`Restoring from backup ${backupId}`);
+    this.eventBus.emit({
+      id: randomUUID3(),
+      timestamp: /* @__PURE__ */ new Date(),
+      source: { type: "addon", id: "local-backup" },
+      category: "backup.restored",
+      data: { backupId }
+    });
+  }
+  /** List all backups sorted by timestamp descending */
+  list() {
+    return [...this.manifests].sort((a, b) => b.timestamp - a.timestamp);
+  }
+  /** Delete a specific backup */
+  async delete(backupId) {
+    this.manifests = this.manifests.filter((m) => m.id !== backupId);
+  }
+  async pruneOldBackups() {
+    const sorted = [...this.manifests].sort((a, b) => a.timestamp - b.timestamp);
+    while (sorted.length > this.config.retentionCount) {
+      const oldest = sorted.shift();
+      if (oldest) {
+        this.logger.info(`Pruning old backup ${oldest.id}`);
+        this.manifests = this.manifests.filter((m) => m.id !== oldest.id);
+      }
+    }
+  }
+};
+
+// src/builtins/local-backup/local-backup.addon.ts
+import * as path7 from "path";
+var LocalBackupAddon = class {
+  manifest = {
+    id: "local-backup",
+    name: "Local Backup",
+    version: "1.0.0",
+    capabilities: ["backup"]
+  };
+  service = null;
+  currentConfig = {
+    retentionCount: 7
+  };
+  async initialize(context) {
+    this.currentConfig = {
+      retentionCount: context.addonConfig.retentionCount ?? this.currentConfig.retentionCount
+    };
+    const backupConfig = {
+      backupDir: path7.join(context.locationPaths.data, "backups"),
+      retentionCount: this.currentConfig.retentionCount
+    };
+    this.service = new LocalBackupService(
+      backupConfig,
+      context.logger,
+      context.eventBus,
+      context.storage
+    );
+    context.logger.info("Local Backup initialized");
+  }
+  async shutdown() {
+    this.service = null;
+  }
+  getService() {
+    if (!this.service) throw new Error("Local Backup not initialized");
+    return this.service;
+  }
+  getCapabilityProvider(name) {
+    if (name === "backup" && this.service) {
+      return this.service;
+    }
+    return null;
+  }
+  getConfigSchema() {
+    return {
+      sections: [
+        {
+          id: "backup",
+          title: "Backup Settings",
+          fields: [
+            {
+              type: "number",
+              key: "retentionCount",
+              label: "Backups to Keep",
+              description: "Maximum number of backup archives to keep; oldest are deleted first",
+              min: 1,
+              max: 100,
+              step: 1,
+              unit: "backups"
+            }
+          ]
+        }
+      ]
+    };
+  }
+  getConfig() {
+    return { ...this.currentConfig };
+  }
+  async onConfigChange(config) {
+    this.currentConfig = {
+      retentionCount: config.retentionCount ?? this.currentConfig.retentionCount
+    };
+  }
+};
+
+// src/builtins/admin-ui/addon.ts
+import path8 from "path";
+function resolveAdminUiDistDir() {
+  try {
+    const adminUiPkg = __require.resolve("@camstack/addon-admin-ui/package.json");
+    return path8.join(path8.dirname(adminUiPkg), "dist");
+  } catch {
+    return path8.resolve(__dirname, "..", "..", "..", "..", "addon-admin-ui", "dist");
+  }
+}
+var AdminUIAddon = class {
+  id = "admin-ui";
+  manifest = {
+    id: "admin-ui",
+    name: "CamStack Admin UI",
+    version: "0.1.0",
+    description: "Web-based administration interface for CamStack",
+    packageName: "@camstack/addon-admin-ui",
+    capabilities: [{ name: "admin-ui", mode: "singleton" }]
+  };
+  async initialize(_ctx) {
+  }
+  async shutdown() {
+  }
+  getCapabilityProvider(name) {
+    if (name === "admin-ui") {
+      const provider = {
+        getStaticDir: () => resolveAdminUiDistDir(),
+        getVersion: () => this.manifest.version
+      };
+      return provider;
+    }
+    return null;
+  }
+};
+
+// src/lifecycle/lifecycle-state-machine.ts
+import { randomUUID as randomUUID4 } from "crypto";
+var VALID_TRANSITIONS = {
+  stopped: ["starting", "disabled"],
+  starting: ["running", "error", "stopping"],
+  running: ["stopping", "error"],
+  stopping: ["stopped", "error"],
+  error: ["starting", "stopped", "disabled"],
+  disabled: ["stopped"]
+};
+var LifecycleStateMachine = class {
+  constructor(elementId, elementType, eventBus, logger) {
+    this.elementId = elementId;
+    this.elementType = elementType;
+    this.eventBus = eventBus;
+    this.logger = logger;
+  }
+  _state = "stopped";
+  _error;
+  _startedAt;
+  _stoppedAt;
+  _restartCount = 0;
+  _hasStartedOnce = false;
+  get state() {
+    return this._state;
+  }
+  getStatus() {
+    return {
+      state: this._state,
+      error: this._error,
+      startedAt: this._startedAt,
+      stoppedAt: this._stoppedAt,
+      restartCount: this._restartCount,
+      uptime: this._state === "running" && this._startedAt ? Date.now() - this._startedAt : 0
+    };
+  }
+  transition(to, error) {
+    const from = this._state;
+    if (!this.isValidTransition(from, to)) {
+      this.logger.warn(`Invalid state transition: ${from} \u2192 ${to}`);
+      return false;
+    }
+    this._state = to;
+    this._error = error;
+    if (to === "running") {
+      if (this._hasStartedOnce) {
+        this._restartCount++;
+      }
+      this._hasStartedOnce = true;
+      this._startedAt = Date.now();
+      this._stoppedAt = void 0;
+    }
+    if (to === "stopped" || to === "error" || to === "disabled") {
+      this._stoppedAt = Date.now();
+    }
+    this.logger.info(`State: ${from} \u2192 ${to}${error ? ` (${error})` : ""}`);
+    this.eventBus.emit({
+      id: randomUUID4(),
+      timestamp: /* @__PURE__ */ new Date(),
+      source: { type: this.elementType, id: this.elementId },
+      category: `${this.elementType}.state.${to}`,
+      data: { from, to, error, elementId: this.elementId }
+    });
+    return true;
+  }
+  incrementRestartCount() {
+    this._restartCount++;
+  }
+  isValidTransition(from, to) {
+    return VALID_TRANSITIONS[from]?.includes(to) ?? false;
+  }
+};
+
+// src/feature/feature-manager.ts
+var FeatureManager = class {
+  constructor(configReader) {
+    this.configReader = configReader;
+  }
+  isEnabled(flag) {
+    return this.configReader.features[flag];
+  }
+  getManifest() {
+    return { ...this.configReader.features };
+  }
+};
+
+// src/config/config-manager.ts
+import * as fs6 from "fs";
+import * as yaml from "js-yaml";
+
+// src/config/config-schema.ts
+import { z } from "zod";
+var bootstrapSchema = z.object({
+  /** Server mode: 'hub' (full server) or 'agent' (worker node) */
+  mode: z.enum(["hub", "agent"]).default("hub"),
+  server: z.object({
+    port: z.number().default(4443),
+    host: z.string().default("0.0.0.0"),
+    dataPath: z.string().default("./data")
+  }).default({}),
+  auth: z.object({
+    jwtSecret: z.string().nullable().default(null),
+    adminUsername: z.string().default("admin"),
+    adminPassword: z.string().default(process.env.ADMIN_PASSWORD ?? "changeme")
+  }).default({}),
+  /** Hub connection config — only used when mode='agent' */
+  hub: z.object({
+    url: z.string().default("ws://localhost:4443/agent"),
+    token: z.string().default("")
+  }).default({}),
+  /** Agent-specific config — only used when mode='agent' */
+  agent: z.object({
+    name: z.string().default(""),
+    /** Port for the agent status page (minimal HTML) */
+    statusPort: z.number().default(4444)
+  }).default({})
+});
+var RUNTIME_DEFAULTS = {
+  "features.streaming": true,
+  "features.notifications": true,
+  "features.objectDetection": false,
+  "features.remoteAccess": true,
+  "features.agentCluster": false,
+  "features.smartHome": true,
+  "features.recordings": true,
+  "features.backup": true,
+  "features.repl": true,
+  "retention.detectionEventsDays": 30,
+  "retention.audioLevelsDays": 7,
+  "logging.level": "info",
+  "logging.retentionDays": 30,
+  "eventBus.ringBufferSize": 1e4,
+  "storage.provider": "sqlite-storage",
+  "storage.locations": {
+    data: "./data/data",
+    media: "./data/media",
+    recordings: "./data/recordings",
+    cache: "/tmp/camstack-cache",
+    logs: "./data/logs",
+    models: "./data/models"
+  },
+  "addons.enabled": [
+    "sqlite-storage",
+    "winston-logging",
+    "go2rtc",
+    "recording-engine",
+    "local-backup",
+    "cloudflare-tunnel",
+    "cloudflare-turn"
+  ],
+  "providers": []
+};
+
+// src/config/config-manager.ts
+var ENV_VAR_MAP = {
+  CAMSTACK_PORT: "server.port",
+  CAMSTACK_HOST: "server.host",
+  CAMSTACK_DATA_PATH: "server.dataPath",
+  CAMSTACK_JWT_SECRET: "auth.jwtSecret",
+  CAMSTACK_ADMIN_USER: "auth.adminUsername",
+  CAMSTACK_ADMIN_PASS: "auth.adminPassword"
+};
+var ConfigManager = class {
+  constructor(configPath) {
+    this.configPath = configPath;
+    const rawYaml = this.loadYaml();
+    const merged = this.applyEnvOverrides(rawYaml);
+    this.bootstrapConfig = bootstrapSchema.parse(merged);
+    this.warnDefaultCredentials();
+  }
+  // Non-readonly so update() can sync the in-memory view after a write.
+  bootstrapConfig;
+  settingsStore = null;
+  /** Called by main.ts after the SQLite DB is ready (Phase 2). */
+  setSettingsStore(store) {
+    this.settingsStore = store;
+  }
+  /**
+   * Get a config value by dot-notation path.
+   * Priority: bootstrap config -> SQL system_settings -> RUNTIME_DEFAULTS fallback.
+   */
+  get(path9) {
+    const bootstrapValue = this.getFromBootstrap(path9);
+    if (bootstrapValue !== void 0) {
+      return bootstrapValue;
+    }
+    if (this.settingsStore !== null) {
+      const sqlValue = this.settingsStore.getSystem(path9);
+      if (sqlValue !== void 0) {
+        return sqlValue;
+      }
+      const sqlNested = this.getNestedFromSystemSettings(path9);
+      if (sqlNested !== void 0) {
+        return sqlNested;
+      }
+    }
+    if (path9 in RUNTIME_DEFAULTS) {
+      return RUNTIME_DEFAULTS[path9];
+    }
+    const nested = this.getFromRuntimeDefaults(path9);
+    if (nested !== void 0) {
+      return nested;
+    }
+    return void 0;
+  }
+  /**
+   * Write a value to SQL system_settings.
+   * Throws if the settings store is not yet wired.
+   */
+  set(key, value) {
+    if (this.settingsStore === null) {
+      throw new Error("[ConfigManager] SettingsStore not initialized -- call setSettingsStore() first");
+    }
+    this.settingsStore.setSystem(key, value);
+  }
+  /**
+   * Bulk-read all system_settings keys that belong to a logical section.
+   * A "section" is the first segment of a dot-notation key (e.g. 'features', 'logging').
+   */
+  getSection(section) {
+    if (this.settingsStore !== null) {
+      const nested = this.getNestedFromSystemSettings(section);
+      if (nested !== void 0) return nested;
+    }
+    return this.getFromRuntimeDefaults(section) ?? {};
+  }
+  /**
+   * Bulk-write a section of runtime settings to SQL system_settings.
+   * Each entry in `data` is stored as `section.key`.
+   */
+  setSection(section, data) {
+    if (this.settingsStore === null) {
+      throw new Error("[ConfigManager] SettingsStore not initialized -- call setSettingsStore() first");
+    }
+    for (const [key, value] of Object.entries(data)) {
+      this.settingsStore.setSystem(`${section}.${key}`, value);
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Addon / Provider / Device scoped config
+  // ---------------------------------------------------------------------------
+  /** Read all config for an addon from addon_settings. */
+  getAddonConfig(addonId) {
+    if (this.settingsStore !== null) {
+      return this.settingsStore.getAllAddon(addonId);
+    }
+    return this.getFromBootstrap(`addons.${addonId}`) ?? {};
+  }
+  /** Write (bulk-replace) config for an addon to addon_settings. */
+  setAddonConfig(addonId, config) {
+    if (this.settingsStore === null) {
+      throw new Error("[ConfigManager] SettingsStore not initialized -- call setSettingsStore() first");
+    }
+    this.settingsStore.setAllAddon(addonId, config);
+  }
+  /** Read all config for a provider from provider_settings. */
+  getProviderConfig(providerId) {
+    if (this.settingsStore !== null) {
+      return this.settingsStore.getAllProvider(providerId);
+    }
+    return {};
+  }
+  /** Write (upsert) a single key for a provider to provider_settings. */
+  setProviderConfig(providerId, key, value) {
+    if (this.settingsStore === null) {
+      throw new Error("[ConfigManager] SettingsStore not initialized -- call setSettingsStore() first");
+    }
+    this.settingsStore.setProvider(providerId, key, value);
+  }
+  /** Read all config for a device from device_settings. */
+  getDeviceConfig(deviceId) {
+    if (this.settingsStore !== null) {
+      return this.settingsStore.getAllDevice(deviceId);
+    }
+    return {};
+  }
+  /** Write (upsert) a single key for a device to device_settings. */
+  setDeviceConfig(deviceId, key, value) {
+    if (this.settingsStore === null) {
+      throw new Error("[ConfigManager] SettingsStore not initialized -- call setSettingsStore() first");
+    }
+    this.settingsStore.setDevice(deviceId, key, value);
+  }
+  /** Get a value from the parsed bootstrap config */
+  getBootstrap(path9) {
+    return this.getFromBootstrap(path9);
+  }
+  /** Features accessor -- reads from SQL when available, falls back to RUNTIME_DEFAULTS */
+  get features() {
+    const g = (key) => this.get(`features.${key}`) ?? RUNTIME_DEFAULTS[`features.${key}`];
+    return {
+      streaming: g("streaming"),
+      notifications: g("notifications"),
+      objectDetection: g("objectDetection"),
+      remoteAccess: g("remoteAccess"),
+      agentCluster: g("agentCluster"),
+      smartHome: g("smartHome"),
+      recordings: g("recordings"),
+      backup: g("backup"),
+      repl: g("repl")
+    };
+  }
+  /**
+   * Returns a merged view of bootstrap config + runtime defaults for backward compat.
+   */
+  get raw() {
+    const features = {
+      streaming: RUNTIME_DEFAULTS["features.streaming"],
+      notifications: RUNTIME_DEFAULTS["features.notifications"],
+      objectDetection: RUNTIME_DEFAULTS["features.objectDetection"],
+      remoteAccess: RUNTIME_DEFAULTS["features.remoteAccess"],
+      agentCluster: RUNTIME_DEFAULTS["features.agentCluster"],
+      smartHome: RUNTIME_DEFAULTS["features.smartHome"],
+      recordings: RUNTIME_DEFAULTS["features.recordings"],
+      backup: RUNTIME_DEFAULTS["features.backup"],
+      repl: RUNTIME_DEFAULTS["features.repl"]
+    };
+    return {
+      ...this.bootstrapConfig,
+      features,
+      storage: RUNTIME_DEFAULTS["storage.locations"] !== void 0 ? {
+        provider: RUNTIME_DEFAULTS["storage.provider"],
+        locations: RUNTIME_DEFAULTS["storage.locations"]
+      } : { provider: "sqlite-storage", locations: {} },
+      logging: {
+        level: RUNTIME_DEFAULTS["logging.level"],
+        retentionDays: RUNTIME_DEFAULTS["logging.retentionDays"]
+      },
+      eventBus: {
+        ringBufferSize: RUNTIME_DEFAULTS["eventBus.ringBufferSize"]
+      },
+      addons: {
+        enabled: RUNTIME_DEFAULTS["addons.enabled"]
+      },
+      retention: {
+        detectionEventsDays: RUNTIME_DEFAULTS["retention.detectionEventsDays"],
+        audioLevelsDays: RUNTIME_DEFAULTS["retention.audioLevelsDays"]
+      },
+      providers: RUNTIME_DEFAULTS["providers"]
+    };
+  }
+  /**
+   * Atomically update one top-level section of config.yaml and sync in-memory.
+   * Only bootstrap sections (server, auth) are persisted. Runtime settings should
+   * go to SQL (Plan B).
+   */
+  update(section, data) {
+    let raw = {};
+    if (fs6.existsSync(this.configPath)) {
+      raw = yaml.load(fs6.readFileSync(this.configPath, "utf-8")) ?? {};
+    }
+    const existing = raw[section] ?? {};
+    raw[section] = { ...existing, ...data };
+    const bootstrapSections = {};
+    if (raw.server) bootstrapSections.server = raw.server;
+    if (raw.auth) bootstrapSections.auth = raw.auth;
+    const validation = bootstrapSchema.safeParse(bootstrapSections);
+    if (!validation.success) {
+      throw new Error(`[ConfigManager] Invalid config update for section "${section}": ${validation.error.message}`);
+    }
+    const tmpPath = `${this.configPath}.tmp`;
+    fs6.writeFileSync(tmpPath, yaml.dump(raw, { lineWidth: 120, indent: 2, quotingType: '"' }), "utf-8");
+    fs6.renameSync(tmpPath, this.configPath);
+    this.bootstrapConfig = validation.data;
+  }
+  /**
+   * Deep-set a value in a nested plain object using a dot-notation path.
+   * Returns a new object (immutable).
+   */
+  setNested(obj, path9, value) {
+    const [head, ...rest] = path9.split(".");
+    if (!head) return obj;
+    if (rest.length === 0) {
+      return { ...obj, [head]: value };
+    }
+    const child = obj[head] ?? {};
+    return { ...obj, [head]: this.setNested(child, rest.join("."), value) };
+  }
+  /**
+   * Apply env var overrides onto the raw YAML object.
+   * Only bootstrap-level env vars are applied.
+   */
+  applyEnvOverrides(raw) {
+    let result = { ...raw };
+    for (const [envKey, configPath] of Object.entries(ENV_VAR_MAP)) {
+      const envValue = process.env[envKey];
+      if (envValue === void 0 || envValue === "") continue;
+      const coerced = configPath === "server.port" ? Number(envValue) : envValue;
+      result = this.setNested(result, configPath, coerced);
+      console.log(`[ConfigManager] Env override applied: ${envKey} \u2192 ${configPath}`);
+    }
+    return result;
+  }
+  loadYaml() {
+    if (!fs6.existsSync(this.configPath)) {
+      console.warn(
+        `[ConfigManager] Config file not found at: ${this.configPath}
+  \u2192 Using built-in defaults. Set CONFIG_PATH env var or create the file.
+  \u2192 Example path from project root: ./server/backend/data/config.yaml`
+      );
+      return {};
+    }
+    const content = fs6.readFileSync(this.configPath, "utf-8");
+    const parsed = yaml.load(content) ?? {};
+    console.log(`[ConfigManager] Loaded config from: ${this.configPath}`);
+    return parsed;
+  }
+  warnDefaultCredentials() {
+    if (this.bootstrapConfig.auth.adminPassword === "changeme") {
+      console.warn(
+        `[ConfigManager] Warning: Using default admin password "changeme". Set auth.adminPassword in your config.yaml or the ADMIN_PASSWORD env var.`
+      );
+    }
+  }
+  getFromBootstrap(path9) {
+    const keys = path9.split(".");
+    let current = this.bootstrapConfig;
+    for (const key of keys) {
+      if (current === null || current === void 0 || typeof current !== "object") {
+        return void 0;
+      }
+      current = current[key];
+    }
+    return current;
+  }
+  getFromRuntimeDefaults(path9) {
+    const prefix = path9 + ".";
+    const result = {};
+    let found = false;
+    for (const [key, value] of Object.entries(RUNTIME_DEFAULTS)) {
+      if (key.startsWith(prefix)) {
+        const subKey = key.slice(prefix.length);
+        result[subKey] = value;
+        found = true;
+      }
+    }
+    return found ? result : void 0;
+  }
+  /**
+   * Perform a prefix-based nested lookup against SQL system_settings.
+   * e.g. path='features' matches keys 'features.streaming', 'features.notifications', etc.
+   * Returns an object keyed by the sub-key, or undefined if nothing is found.
+   */
+  getNestedFromSystemSettings(path9) {
+    if (this.settingsStore === null) return void 0;
+    const all = this.settingsStore.getAllSystem();
+    const prefix = path9 + ".";
+    const result = {};
+    let found = false;
+    for (const [key, value] of Object.entries(all)) {
+      if (key.startsWith(prefix)) {
+        result[key.slice(prefix.length)] = value;
+        found = true;
+      }
+    }
+    return found ? result : void 0;
+  }
+};
+
+// src/events/system-event-bus.ts
+var EventRingBuffer = class {
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.buffer = new Array(capacity);
+  }
+  buffer;
+  head = 0;
+  count = 0;
+  push(event) {
+    this.buffer[this.head] = event;
+    this.head = (this.head + 1) % this.capacity;
+    if (this.count < this.capacity) {
+      this.count++;
+    }
+  }
+  getAll() {
+    const result = [];
+    for (let i = 0; i < this.count; i++) {
+      const index = (this.head - 1 - i + this.capacity) % this.capacity;
+      result.push(this.buffer[index]);
+    }
+    return result;
+  }
+  query(filter, limit) {
+    let result = [...this.getAll()];
+    if (filter) {
+      result = result.filter((event) => matchesFilter(event, filter));
+    }
+    if (limit !== void 0 && limit > 0) {
+      return result.slice(0, limit);
+    }
+    return result;
+  }
+};
+function matchesCategory(eventCategory, filterCategory) {
+  if (filterCategory.endsWith(".*")) {
+    const prefix = filterCategory.slice(0, -2);
+    return eventCategory.startsWith(prefix + ".") || eventCategory === prefix;
+  }
+  return eventCategory === filterCategory;
+}
+function matchesFilter(event, filter) {
+  if (filter.category && !matchesCategory(event.category, filter.category)) {
+    return false;
+  }
+  if (filter.source) {
+    if (event.source.type !== filter.source.type || event.source.id !== filter.source.id) {
+      return false;
+    }
+  }
+  if (filter.since && event.timestamp < filter.since) {
+    return false;
+  }
+  return true;
+}
+var SystemEventBus = class {
+  ringBuffer;
+  subscribers = [];
+  constructor(bufferSize = 1e4) {
+    this.ringBuffer = new EventRingBuffer(bufferSize);
+  }
+  emit(event) {
+    this.ringBuffer.push(event);
+    for (const subscriber of this.subscribers) {
+      if (matchesFilter(event, subscriber.filter)) {
+        subscriber.callback(event);
+      }
+    }
+  }
+  subscribe(filter, handler) {
+    const subscriber = { filter, callback: handler };
+    this.subscribers.push(subscriber);
+    return () => {
+      const index = this.subscribers.indexOf(subscriber);
+      if (index !== -1) {
+        this.subscribers.splice(index, 1);
+      }
+    };
+  }
+  getRecent(filter, limit) {
+    return this.ringBuffer.query(filter, limit);
+  }
+};
+
+// src/logging/log-ring-buffer.ts
+var LogRingBuffer = class {
+  constructor(capacity = 1e4) {
+    this.capacity = capacity;
+    this.buffer = new Array(capacity);
+  }
+  buffer;
+  head = 0;
+  count = 0;
+  push(entry) {
+    this.buffer[this.head] = entry;
+    this.head = (this.head + 1) % this.capacity;
+    if (this.count < this.capacity) {
+      this.count++;
+    }
+  }
+  getAll() {
+    const result = [];
+    for (let i = 0; i < this.count; i++) {
+      const index = (this.head - 1 - i + this.capacity) % this.capacity;
+      result.push(this.buffer[index]);
+    }
+    return result;
+  }
+  query(filter) {
+    const all = this.getAll();
+    let result = all;
+    if (filter.scope && filter.scope.length > 0) {
+      result = result.filter((entry) => {
+        for (let i = 0; i < filter.scope.length; i++) {
+          if (entry.scope[i] !== filter.scope[i]) return false;
+        }
+        return true;
+      });
+    }
+    if (filter.level) {
+      result = result.filter((entry) => entry.level === filter.level);
+    }
+    if (filter.since) {
+      result = result.filter((entry) => entry.timestamp >= filter.since);
+    }
+    if (filter.until) {
+      result = result.filter((entry) => entry.timestamp <= filter.until);
+    }
+    if (filter.limit !== void 0 && filter.limit > 0) {
+      result = result.slice(0, filter.limit);
+    }
+    return result;
+  }
+};
+
+// src/logging/scoped-logger.ts
+var ScopedLogger = class _ScopedLogger {
+  constructor(scope, writeFn) {
+    this.scope = scope;
+    this.writeFn = writeFn;
+  }
+  debug(message, meta) {
+    this.write("debug", message, meta);
+  }
+  info(message, meta) {
+    this.write("info", message, meta);
+  }
+  warn(message, meta) {
+    this.write("warn", message, meta);
+  }
+  error(message, meta) {
+    this.write("error", message, meta);
+  }
+  child(childScope) {
+    return new _ScopedLogger([...this.scope, childScope], this.writeFn);
+  }
+  write(level, message, meta) {
+    const entry = {
+      timestamp: /* @__PURE__ */ new Date(),
+      level,
+      scope: this.scope,
+      message,
+      ...meta !== void 0 ? { meta } : {}
+    };
+    this.writeFn(entry);
+  }
+};
+
+// src/logging/log-manager.ts
+var LogManager = class {
+  ringBuffer;
+  destinations = [];
+  constructor(bufferSize = 1e4) {
+    this.ringBuffer = new LogRingBuffer(bufferSize);
+  }
+  createLogger(scope) {
+    return new ScopedLogger([scope], (entry) => {
+      this.ringBuffer.push(entry);
+      for (const dest of this.destinations) {
+        dest.write(entry);
+      }
+    });
+  }
+  addDestination(dest) {
+    this.destinations.push(dest);
+  }
+  removeDestination(dest) {
+    const index = this.destinations.indexOf(dest);
+    if (index !== -1) {
+      this.destinations.splice(index, 1);
+    }
+  }
+  query(filter) {
+    return this.ringBuffer.query(filter);
+  }
+};
+
+// src/storage/storage-manager.ts
+var StorageManager = class {
+  provider = null;
+  locationManager = null;
+  setProvider(provider) {
+    this.provider = provider;
+  }
+  getProvider() {
+    if (!this.provider) {
+      throw new Error("No storage provider configured");
+    }
+    return this.provider;
+  }
+  /**
+   * Set the StorageLocationManager (called from main.ts during Phase 2 boot,
+   * before NestJS lifecycle hooks run).
+   */
+  setLocationManager(manager) {
+    this.locationManager = manager;
+  }
+  /**
+   * Get the StorageLocationManager (for file path resolution).
+   * Available after Phase 2 boot (main.ts calls setLocationManager).
+   */
+  getLocationManager() {
+    if (!this.locationManager) {
+      throw new Error("StorageLocationManager not initialized -- ensure Phase 2 boot ran before accessing this");
+    }
+    return this.locationManager;
+  }
+  /**
+   * Initialize the StorageLocationManager with a dataPath and set it on this service.
+   * Called during 3-phase boot from main.ts (Phase 2).
+   */
+  async initializeLocations(dataPath) {
+    const { StorageLocationManager: StorageLocationManager2 } = await import("./storage-location-manager-F4YZMHGM.mjs");
+    const manager = new StorageLocationManager2(dataPath);
+    await manager.initializeDefaults();
+    this.locationManager = manager;
+  }
+  /**
+   * Return the base filesystem path for a named storage location.
+   * Convenience wrapper around locationManager.getBackend(name).basePath.
+   * Available after Phase 2 boot (main.ts calls setLocationManager).
+   */
+  getLocationPath(name) {
+    return this.getLocationManager().getBackend(name).basePath;
+  }
+  /**
+   * Get a storage location, optionally namespaced.
+   * Without namespace: returns the raw location (e.g., 'config' -> config DB)
+   * With namespace: returns a scoped view where all collections/paths are prefixed
+   *   e.g., getLocation('addon', 'providers/frigate-1') -> collections prefixed with 'providers/frigate-1/'
+   */
+  getLocation(name, namespace) {
+    const LEGACY_MAP = {
+      config: "data",
+      // old 'config' -> new 'data' (SQLite DB location)
+      events: "data",
+      // old 'events' -> new 'data'
+      addon: "data"
+      // old 'addon' -> new 'data'
+    };
+    const mappedName = LEGACY_MAP[name] ?? name;
+    const location = this.getProvider().getLocation(mappedName);
+    if (!namespace) return location;
+    return this.createNamespacedLocation(location, namespace);
+  }
+  createNamespacedLocation(location, namespace) {
+    const prefix = namespace.endsWith("/") ? namespace : `${namespace}/`;
+    return {
+      structured: location.structured ? {
+        async query(collection, filter) {
+          return location.structured.query(`${prefix}${collection}`, filter);
+        },
+        async insert(record) {
+          return location.structured.insert({ ...record, collection: `${prefix}${record.collection}` });
+        },
+        async update(collection, id, data) {
+          return location.structured.update(`${prefix}${collection}`, id, data);
+        },
+        async delete(collection, id) {
+          return location.structured.delete(`${prefix}${collection}`, id);
+        },
+        async count(collection, filter) {
+          return location.structured.count(`${prefix}${collection}`, filter);
+        }
+      } : void 0,
+      files: location.files ? {
+        async readFile(path9) {
+          return location.files.readFile(`${prefix}${path9}`);
+        },
+        async writeFile(path9, data) {
+          return location.files.writeFile(`${prefix}${path9}`, data);
+        },
+        async deleteFile(path9) {
+          return location.files.deleteFile(`${prefix}${path9}`);
+        },
+        async listFiles(filePrefix) {
+          return location.files.listFiles(`${prefix}${filePrefix ?? ""}`);
+        },
+        async getFileUrl(path9) {
+          return location.files.getFileUrl(`${prefix}${path9}`);
+        },
+        async exists(path9) {
+          return location.files.exists(`${prefix}${path9}`);
+        }
+      } : void 0
+    };
+  }
+};
+
+// src/storage/settings-store.ts
+import Database2 from "better-sqlite3";
+
+// src/storage/sql-schema.ts
+var CORE_TABLE_DDL = [
+  // Settings tables
+  `CREATE TABLE IF NOT EXISTS system_settings (
+    key TEXT PRIMARY KEY,
+    value JSON NOT NULL,
+    updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+  )`,
+  `CREATE TABLE IF NOT EXISTS addon_settings (
+    addon_id TEXT NOT NULL,
+    key TEXT NOT NULL,
+    value JSON NOT NULL,
+    updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
+    PRIMARY KEY (addon_id, key)
+  )`,
+  `CREATE TABLE IF NOT EXISTS provider_settings (
+    provider_id TEXT NOT NULL,
+    key TEXT NOT NULL,
+    value JSON NOT NULL,
+    updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
+    PRIMARY KEY (provider_id, key)
+  )`,
+  `CREATE TABLE IF NOT EXISTS device_settings (
+    device_id TEXT NOT NULL,
+    key TEXT NOT NULL,
+    value JSON NOT NULL,
+    updated_at INTEGER NOT NULL DEFAULT (unixepoch()),
+    PRIMARY KEY (device_id, key)
+  )`,
+  // Detection events
+  `CREATE TABLE IF NOT EXISTS detection_events (
+    id TEXT PRIMARY KEY,
+    timestamp INTEGER NOT NULL,
+    device_id TEXT NOT NULL,
+    class_name TEXT NOT NULL,
+    score REAL NOT NULL,
+    severity TEXT NOT NULL,
+    track_id TEXT,
+    zones JSON,
+    recognition JSON,
+    media_files JSON,
+    data JSON
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_det_device_ts ON detection_events(device_id, timestamp)`,
+  `CREATE INDEX IF NOT EXISTS idx_det_class_ts ON detection_events(class_name, timestamp)`,
+  // Audio levels
+  `CREATE TABLE IF NOT EXISTS audio_levels (
+    id TEXT PRIMARY KEY,
+    timestamp INTEGER NOT NULL,
+    device_id TEXT NOT NULL,
+    dbfs REAL NOT NULL,
+    rms REAL NOT NULL,
+    state TEXT NOT NULL
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_audio_device_ts ON audio_levels(device_id, timestamp)`,
+  // Track trails
+  `CREATE TABLE IF NOT EXISTS track_trails (
+    track_id TEXT PRIMARY KEY,
+    device_id TEXT NOT NULL,
+    class_name TEXT NOT NULL,
+    first_seen INTEGER NOT NULL,
+    last_seen INTEGER NOT NULL,
+    positions JSON NOT NULL,
+    snapshots JSON,
+    total_distance REAL,
+    zones_visited JSON
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_trails_device_ts ON track_trails(device_id, first_seen)`
+];
+function addonTableToDdl(schema) {
+  const pks = schema.columns.filter((c) => c.primaryKey).map((c) => c.name);
+  const colDefs = schema.columns.map((c) => {
+    const parts = [c.name, c.type];
+    if (c.notNull) parts.push("NOT NULL");
+    return parts.join(" ");
+  });
+  let ddl = `CREATE TABLE IF NOT EXISTS ${schema.name} (
+  ${colDefs.join(",\n  ")}`;
+  if (pks.length > 0) {
+    ddl += `,
+  PRIMARY KEY (${pks.join(", ")})`;
+  }
+  ddl += "\n)";
+  const stmts = [ddl];
+  for (const idx of schema.indexes ?? []) {
+    const unique = idx.unique ? "UNIQUE " : "";
+    stmts.push(`CREATE ${unique}INDEX IF NOT EXISTS ${idx.name} ON ${schema.name}(${idx.columns.join(", ")})`);
+  }
+  return stmts;
+}
+
+// src/storage/settings-store.ts
+var SettingsStore = class {
+  db;
+  constructor(dbPath) {
+    this.db = new Database2(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.initTables();
+  }
+  // ---------------------------------------------------------------------------
+  // System settings
+  // ---------------------------------------------------------------------------
+  getSystem(key) {
+    const row = this.db.prepare("SELECT value FROM system_settings WHERE key = ?").get(key);
+    if (row === void 0) return void 0;
+    return JSON.parse(row.value);
+  }
+  setSystem(key, value) {
+    this.db.prepare(
+      `INSERT INTO system_settings (key, value, updated_at) VALUES (?, json(?), unixepoch())
+         ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`
+    ).run(key, JSON.stringify(value));
+  }
+  getAllSystem() {
+    const rows = this.db.prepare("SELECT key, value FROM system_settings").all();
+    return Object.fromEntries(rows.map((r) => [r.key, JSON.parse(r.value)]));
+  }
+  // ---------------------------------------------------------------------------
+  // Addon settings
+  // ---------------------------------------------------------------------------
+  getAddon(addonId, key) {
+    const row = this.db.prepare(
+      "SELECT value FROM addon_settings WHERE addon_id = ? AND key = ?"
+    ).get(addonId, key);
+    if (row === void 0) return void 0;
+    return JSON.parse(row.value);
+  }
+  setAddon(addonId, key, value) {
+    this.db.prepare(
+      `INSERT INTO addon_settings (addon_id, key, value, updated_at) VALUES (?, ?, json(?), unixepoch())
+         ON CONFLICT(addon_id, key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`
+    ).run(addonId, key, JSON.stringify(value));
+  }
+  getAllAddon(addonId) {
+    const rows = this.db.prepare(
+      "SELECT key, value FROM addon_settings WHERE addon_id = ?"
+    ).all(addonId);
+    return Object.fromEntries(rows.map((r) => [r.key, JSON.parse(r.value)]));
+  }
+  /** Bulk-replace all keys for an addon (within a transaction). */
+  setAllAddon(addonId, config) {
+    const deleteStmt = this.db.prepare("DELETE FROM addon_settings WHERE addon_id = ?");
+    const insertStmt = this.db.prepare(
+      `INSERT INTO addon_settings (addon_id, key, value, updated_at) VALUES (?, ?, json(?), unixepoch())`
+    );
+    this.db.transaction(() => {
+      deleteStmt.run(addonId);
+      for (const [key, value] of Object.entries(config)) {
+        insertStmt.run(addonId, key, JSON.stringify(value));
+      }
+    })();
+  }
+  // ---------------------------------------------------------------------------
+  // Provider settings
+  // ---------------------------------------------------------------------------
+  getProvider(providerId, key) {
+    const row = this.db.prepare(
+      "SELECT value FROM provider_settings WHERE provider_id = ? AND key = ?"
+    ).get(providerId, key);
+    if (row === void 0) return void 0;
+    return JSON.parse(row.value);
+  }
+  setProvider(providerId, key, value) {
+    this.db.prepare(
+      `INSERT INTO provider_settings (provider_id, key, value, updated_at) VALUES (?, ?, json(?), unixepoch())
+         ON CONFLICT(provider_id, key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`
+    ).run(providerId, key, JSON.stringify(value));
+  }
+  getAllProvider(providerId) {
+    const rows = this.db.prepare(
+      "SELECT key, value FROM provider_settings WHERE provider_id = ?"
+    ).all(providerId);
+    return Object.fromEntries(rows.map((r) => [r.key, JSON.parse(r.value)]));
+  }
+  // ---------------------------------------------------------------------------
+  // Device settings
+  // ---------------------------------------------------------------------------
+  getDevice(deviceId, key) {
+    const row = this.db.prepare(
+      "SELECT value FROM device_settings WHERE device_id = ? AND key = ?"
+    ).get(deviceId, key);
+    if (row === void 0) return void 0;
+    return JSON.parse(row.value);
+  }
+  setDevice(deviceId, key, value) {
+    this.db.prepare(
+      `INSERT INTO device_settings (device_id, key, value, updated_at) VALUES (?, ?, json(?), unixepoch())
+         ON CONFLICT(device_id, key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`
+    ).run(deviceId, key, JSON.stringify(value));
+  }
+  getAllDevice(deviceId) {
+    const rows = this.db.prepare(
+      "SELECT key, value FROM device_settings WHERE device_id = ?"
+    ).all(deviceId);
+    return Object.fromEntries(rows.map((r) => [r.key, JSON.parse(r.value)]));
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle
+  // ---------------------------------------------------------------------------
+  /** Close the SQLite connection (call on shutdown). */
+  close() {
+    this.db.close();
+  }
+  /** Check if system_settings is empty (used for first-boot seeding). */
+  isSystemSettingsEmpty() {
+    const row = this.db.prepare("SELECT COUNT(*) AS cnt FROM system_settings").get();
+    return (row?.cnt ?? 0) === 0;
+  }
+  /** Seed system_settings with RUNTIME_DEFAULTS (only on first boot). */
+  seedDefaults() {
+    const insert = this.db.prepare(
+      `INSERT OR IGNORE INTO system_settings (key, value, updated_at) VALUES (?, json(?), unixepoch())`
+    );
+    this.db.transaction(() => {
+      for (const [key, value] of Object.entries(RUNTIME_DEFAULTS)) {
+        insert.run(key, JSON.stringify(value));
+      }
+    })();
+  }
+  // ---------------------------------------------------------------------------
+  // Private helpers
+  // ---------------------------------------------------------------------------
+  initTables() {
+    this.db.transaction(() => {
+      for (const stmt of CORE_TABLE_DDL) {
+        this.db.prepare(stmt).run();
+      }
+    })();
+  }
+};
+
+// src/auth/auth-manager.ts
+import * as jwt from "jsonwebtoken";
+import * as bcrypt from "bcryptjs";
+import * as crypto from "crypto";
+var AuthManager = class {
+  constructor(config) {
+    this.config = config;
+    const configured = this.config.get("auth.jwtSecret");
+    if (configured) {
+      this.jwtSecret = configured;
+    } else {
+      const secret = crypto.randomBytes(32).toString("hex");
+      this.config.update("auth", { jwtSecret: secret });
+      console.log("[AuthManager] Generated JWT secret and saved to config.yaml (auth.jwtSecret)");
+      this.jwtSecret = secret;
+    }
+  }
+  jwtSecret;
+  scopedTokenManager = null;
+  signToken(payload) {
+    return jwt.sign({ ...payload }, this.jwtSecret, { expiresIn: "24h" });
+  }
+  verifyToken(token) {
+    return jwt.verify(token, this.jwtSecret);
+  }
+  async hashPassword(password) {
+    return bcrypt.hash(password, 10);
+  }
+  async comparePassword(password, hash2) {
+    return bcrypt.compare(password, hash2);
+  }
+  generateApiKey() {
+    const token = crypto.randomBytes(32).toString("hex");
+    const hash2 = crypto.createHash("sha256").update(token).digest("hex");
+    const prefix = token.slice(0, 8);
+    return { token, hash: hash2, prefix };
+  }
+  validateApiKey(token, storedHash) {
+    const hash2 = crypto.createHash("sha256").update(token).digest("hex");
+    return hash2 === storedHash;
+  }
+  /**
+   * Set the scoped token manager for the auth chain.
+   */
+  setScopedTokenManager(manager) {
+    this.scopedTokenManager = manager;
+  }
+  /**
+   * Validate a scoped token string.
+   * Returns the token record if valid, null otherwise.
+   */
+  async validateScopedToken(rawToken) {
+    if (!this.scopedTokenManager) {
+      return null;
+    }
+    return this.scopedTokenManager.validate(rawToken);
+  }
+  /**
+   * Check whether a scoped token grants access to a given addon/route/capability.
+   */
+  matchesScopedTokenScope(token, addonId, routePath, capability) {
+    if (!this.scopedTokenManager) {
+      return false;
+    }
+    return this.scopedTokenManager.matchesScope(token, addonId, routePath, capability);
+  }
+};
+
+// src/auth/api-key-manager.ts
+import * as crypto2 from "crypto";
+var API_KEYS_COLLECTION = "api_keys";
+var ApiKeyManager = class {
+  constructor(storageAccess, auth) {
+    this.storageAccess = storageAccess;
+    this.auth = auth;
+  }
+  get structured() {
+    return this.storageAccess.getStructuredStorage();
+  }
+  async create(input) {
+    const { token, hash: hash2, prefix } = this.auth.generateApiKey();
+    const now = Date.now();
+    const record = {
+      id: crypto2.randomUUID(),
+      label: input.label,
+      role: input.role,
+      allowedProviders: input.allowedProviders ?? "*",
+      allowedDevices: input.allowedDevices ?? {},
+      tokenHash: hash2,
+      tokenPrefix: prefix,
+      createdAt: now
+    };
+    await this.structured.insert({
+      collection: API_KEYS_COLLECTION,
+      id: record.id,
+      data: record
+    });
+    return { record, token };
+  }
+  async validateToken(token) {
+    const allKeys = await this.structured.query(API_KEYS_COLLECTION);
+    for (const entry of allKeys) {
+      const record = entry.data;
+      if (this.auth.validateApiKey(token, record.tokenHash)) {
+        const updatedData = {
+          ...record,
+          lastUsedAt: Date.now()
+        };
+        await this.structured.update(API_KEYS_COLLECTION, record.id, updatedData);
+        return { ...record, lastUsedAt: updatedData.lastUsedAt };
+      }
+    }
+    return null;
+  }
+  async listAll() {
+    const results = await this.structured.query(API_KEYS_COLLECTION);
+    return results.map((r) => {
+      const { tokenHash, ...rest } = r.data;
+      return rest;
+    });
+  }
+  async revoke(id) {
+    await this.structured.delete(API_KEYS_COLLECTION, id);
+  }
+  async findById(id) {
+    const results = await this.structured.query(API_KEYS_COLLECTION, {
+      where: { id }
+    });
+    if (results.length === 0) {
+      return null;
+    }
+    return results[0].data;
+  }
+};
+
+// src/auth/user-manager.ts
+import * as crypto3 from "crypto";
+var USERS_COLLECTION = "users";
+var UserManager = class {
+  constructor(storageAccess, auth, config) {
+    this.storageAccess = storageAccess;
+    this.auth = auth;
+    this.config = config;
+  }
+  get structured() {
+    return this.storageAccess.getStructuredStorage();
+  }
+  async create(input) {
+    const existing = await this.findByUsername(input.username);
+    if (existing) {
+      throw new Error(`User with username "${input.username}" already exists`);
+    }
+    const passwordHash = await this.auth.hashPassword(input.password);
+    const now = Date.now();
+    const record = {
+      id: crypto3.randomUUID(),
+      username: input.username,
+      passwordHash,
+      role: input.role,
+      allowedProviders: input.allowedProviders ?? "*",
+      allowedDevices: input.allowedDevices ?? {},
+      createdAt: now,
+      updatedAt: now
+    };
+    await this.structured.insert({
+      collection: USERS_COLLECTION,
+      id: record.id,
+      data: record
+    });
+    return record;
+  }
+  async findByUsername(username) {
+    const results = await this.structured.query(USERS_COLLECTION, {
+      where: { username }
+    });
+    if (results.length === 0) {
+      return null;
+    }
+    return results[0].data;
+  }
+  async findById(id) {
+    const results = await this.structured.query(USERS_COLLECTION, {
+      where: { id }
+    });
+    if (results.length === 0) {
+      return null;
+    }
+    return results[0].data;
+  }
+  async validateCredentials(username, password) {
+    const user = await this.findByUsername(username);
+    if (!user) {
+      return null;
+    }
+    const valid = await this.auth.comparePassword(password, user.passwordHash);
+    return valid ? user : null;
+  }
+  async listAll() {
+    const results = await this.structured.query(USERS_COLLECTION);
+    return results.map((r) => {
+      const { passwordHash, ...rest } = r.data;
+      return rest;
+    });
+  }
+  async update(id, data) {
+    const existing = await this.findById(id);
+    if (!existing) {
+      throw new Error(`User with id "${id}" not found`);
+    }
+    const updatedData = {
+      ...existing,
+      ...data,
+      updatedAt: Date.now()
+    };
+    await this.structured.update(USERS_COLLECTION, id, updatedData);
+  }
+  async delete(id) {
+    await this.structured.delete(USERS_COLLECTION, id);
+  }
+  async resetPassword(id, newPassword) {
+    const existing = await this.findById(id);
+    if (!existing) {
+      throw new Error(`User with id "${id}" not found`);
+    }
+    const passwordHash = await this.auth.hashPassword(newPassword);
+    const updatedData = {
+      ...existing,
+      passwordHash,
+      updatedAt: Date.now()
+    };
+    await this.structured.update(USERS_COLLECTION, id, updatedData);
+  }
+  async ensureAdminExists() {
+    const adminUsername = this.config.get("auth.adminUsername");
+    const adminPassword = this.config.get("auth.adminPassword");
+    if (!adminUsername || !adminPassword) {
+      return;
+    }
+    const existing = await this.findByUsername(adminUsername);
+    if (existing) {
+      return;
+    }
+    await this.create({
+      username: adminUsername,
+      password: adminPassword,
+      role: "super_admin",
+      allowedProviders: "*",
+      allowedDevices: {}
+    });
+  }
+};
+
+// src/auth/scoped-token-manager.ts
+import * as crypto4 from "crypto";
+var TOKENS_COLLECTION = "scoped_tokens";
+var TOKEN_PREFIX = "cst_";
+var ScopedTokenManager = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  /**
+   * Create a new scoped token. Returns the raw token string (shown once)
+   * and the stored record (with hash, not the raw token).
+   */
+  async create(userId, name, scopes, expiresAt) {
+    const rawHex = crypto4.randomBytes(32).toString("hex");
+    const rawToken = `${TOKEN_PREFIX}${rawHex}`;
+    const tokenHash = crypto4.createHash("sha256").update(rawToken).digest("hex");
+    const tokenPrefix = rawToken.slice(0, 12);
+    const record = {
+      id: crypto4.randomUUID(),
+      userId,
+      name,
+      tokenHash,
+      tokenPrefix,
+      scopes: scopes.map((s) => ({ ...s })),
+      expiresAt,
+      lastUsedAt: void 0,
+      createdAt: Date.now()
+    };
+    await this.storage.insert({
+      collection: TOKENS_COLLECTION,
+      id: record.id,
+      data: record
+    });
+    return { token: rawToken, record };
+  }
+  /**
+   * Validate a raw token string. Returns the token record if valid, null otherwise.
+   */
+  async validate(rawToken) {
+    if (!rawToken.startsWith(TOKEN_PREFIX)) {
+      return null;
+    }
+    const tokenHash = crypto4.createHash("sha256").update(rawToken).digest("hex");
+    const results = await this.storage.query(TOKENS_COLLECTION, {
+      where: { tokenHash }
+    });
+    if (results.length === 0) {
+      return null;
+    }
+    const record = results[0].data;
+    if (record.expiresAt !== void 0 && record.expiresAt !== null && Date.now() > record.expiresAt) {
+      return null;
+    }
+    this.updateLastUsed(record.id).catch(() => {
+    });
+    return record;
+  }
+  /**
+   * Check whether a token's scopes grant access to the given addon, route, or capability.
+   */
+  matchesScope(token, addonId, routePath, capability) {
+    for (const scope of token.scopes) {
+      switch (scope.type) {
+        case "addon":
+          if (addonId && scope.target === addonId) return true;
+          break;
+        case "route-prefix":
+          if (routePath && routePath.startsWith(scope.target)) return true;
+          break;
+        case "capability":
+          if (capability && scope.target === capability) return true;
+          break;
+      }
+    }
+    return false;
+  }
+  /**
+   * Revoke a token by ID.
+   */
+  async revoke(tokenId) {
+    await this.storage.delete(TOKENS_COLLECTION, tokenId);
+  }
+  /**
+   * List all tokens for a user (without exposing the raw token).
+   */
+  async listForUser(userId) {
+    const results = await this.storage.query(TOKENS_COLLECTION, {
+      where: { userId }
+    });
+    return results.map((r) => r.data);
+  }
+  /**
+   * Update the lastUsedAt timestamp for a token.
+   */
+  async updateLastUsed(tokenId) {
+    const results = await this.storage.query(TOKENS_COLLECTION, {
+      where: { id: tokenId }
+    });
+    if (results.length === 0) return;
+    const existing = results[0].data;
+    await this.storage.update(TOKENS_COLLECTION, tokenId, {
+      ...existing,
+      lastUsedAt: Date.now()
+    });
+  }
+};
+
+// src/notification/notification-service.ts
+var NotificationService = class {
+  constructor(logger) {
+    this.logger = logger;
+  }
+  localOutputs = /* @__PURE__ */ new Map();
+  routing = /* @__PURE__ */ new Map();
+  rateLimits = /* @__PURE__ */ new Map();
+  lastSent = /* @__PURE__ */ new Map();
+  registry = null;
+  /** Set the registry for live output lookup. Called once during boot. */
+  setRegistry(registry) {
+    this.registry = registry;
+  }
+  /** Resolve all outputs — prefers registry, falls back to local map */
+  get outputs() {
+    if (this.registry) {
+      const collection = this.registry.getCollection("notification-output");
+      const map = /* @__PURE__ */ new Map();
+      for (const output of collection) {
+        map.set(output.id, output);
+      }
+      return map;
+    }
+    return this.localOutputs;
+  }
+  /** @deprecated Use registry-based resolution. Kept for backward compat only. */
+  addOutput(output) {
+    this.localOutputs.set(output.id, output);
+    this.logger.info(`Notification output added: ${output.name} (${output.id})`);
+  }
+  /** @deprecated Use registry-based resolution. Kept for backward compat only. */
+  removeOutput(id) {
+    this.localOutputs.delete(id);
+    this.logger.info(`Notification output removed: ${id}`);
+  }
+  setRouting(category, outputIds) {
+    this.routing.set(category, [...outputIds]);
+  }
+  setRateLimit(category, minIntervalMs) {
+    this.rateLimits.set(category, minIntervalMs);
+  }
+  async notify(notification) {
+    const { category, deviceId } = notification;
+    const rateLimitKey = deviceId ? `${category}:${deviceId}` : category;
+    const minInterval = this.rateLimits.get(category) ?? 0;
+    if (minInterval > 0) {
+      const last = this.lastSent.get(rateLimitKey) ?? 0;
+      if (notification.timestamp - last < minInterval) {
+        this.logger.debug(`Rate limited: ${rateLimitKey}`);
+        return;
+      }
+    }
+    const targetIds = this.routing.get(category) ?? this.routing.get("*") ?? [];
+    if (targetIds.length === 0) {
+      this.logger.debug(`No routing configured for category "${category}"`);
+      return;
+    }
+    const currentOutputs = this.outputs;
+    this.lastSent.set(rateLimitKey, notification.timestamp);
+    await Promise.allSettled(
+      targetIds.map((id) => currentOutputs.get(id)).filter((output) => output !== void 0).map(async (output) => {
+        try {
+          await output.send(notification);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          this.logger.error(`Notification output "${output.id}" failed: ${msg}`);
+        }
+      })
+    );
+    return void 0;
+  }
+  getOutputs() {
+    return Array.from(this.outputs.values()).map(({ id, name, icon }) => ({ id, name, icon }));
+  }
+  getRouting() {
+    return this.routing;
+  }
+  getOutput(id) {
+    return this.outputs.get(id);
+  }
+};
+
+// src/notification/toast-service.ts
+var ToastService = class {
+  listeners = /* @__PURE__ */ new Map();
+  /**
+   * Subscribe to toast events for a specific user.
+   * Returns an unsubscribe function.
+   */
+  subscribe(connectionId, userId, callback) {
+    this.listeners.set(connectionId, { userId, callback });
+    return () => {
+      this.listeners.delete(connectionId);
+    };
+  }
+  /**
+   * Broadcast a toast to all connected clients.
+   */
+  broadcast(toast) {
+    for (const entry of this.listeners.values()) {
+      entry.callback(toast);
+    }
+  }
+  /**
+   * Send a toast to a specific user's connections only.
+   */
+  sendToUser(userId, toast) {
+    for (const entry of this.listeners.values()) {
+      if (entry.userId === userId) {
+        entry.callback(toast);
+      }
+    }
+  }
+};
+
+// src/addon-routes/addon-route-registry.ts
+var AddonRouteRegistry = class {
+  routes = /* @__PURE__ */ new Map();
+  /**
+   * Register all routes from an addon's route provider.
+   */
+  registerRoutes(addonId, provider) {
+    const addonRoutes = provider.getRoutes();
+    const registered = addonRoutes.map((route) => {
+      const normalizedPath = route.path.startsWith("/") ? route.path : `/${route.path}`;
+      return {
+        addonId,
+        route,
+        fullPath: `/addon/${addonId}${normalizedPath}`
+      };
+    });
+    this.routes.set(addonId, registered);
+  }
+  /**
+   * Unregister all routes for an addon.
+   */
+  unregisterRoutes(addonId) {
+    this.routes.delete(addonId);
+  }
+  /**
+   * Match an incoming request method + path to a registered route.
+   * Supports simple path parameters (e.g., /items/:id).
+   */
+  matchRoute(method, path9) {
+    const normalizedMethod = method.toUpperCase();
+    for (const registeredRoutes of this.routes.values()) {
+      for (const entry of registeredRoutes) {
+        if (entry.route.method !== normalizedMethod) continue;
+        const params = matchPath(entry.fullPath, path9);
+        if (params !== null) {
+          return {
+            route: entry.route,
+            addonId: entry.addonId,
+            params
+          };
+        }
+      }
+    }
+    return null;
+  }
+  /**
+   * List all registered routes across all addons.
+   */
+  listRoutes() {
+    const result = [];
+    for (const registeredRoutes of this.routes.values()) {
+      for (const entry of registeredRoutes) {
+        result.push({
+          addonId: entry.addonId,
+          method: entry.route.method,
+          path: entry.fullPath,
+          access: entry.route.access,
+          description: entry.route.description
+        });
+      }
+    }
+    return result;
+  }
+};
+function matchPath(pattern, path9) {
+  const patternParts = pattern.split("/").filter(Boolean);
+  const pathParts = path9.split("/").filter(Boolean);
+  if (patternParts.length !== pathParts.length) {
+    return null;
+  }
+  const params = {};
+  for (let i = 0; i < patternParts.length; i++) {
+    const patternPart = patternParts[i];
+    const pathPart = pathParts[i];
+    if (patternPart.startsWith(":")) {
+      params[patternPart.slice(1)] = pathPart;
+    } else if (patternPart !== pathPart) {
+      return null;
+    }
+  }
+  return params;
+}
+
+// src/device/device-registry.ts
+import { randomUUID as randomUUID8 } from "crypto";
+var DeviceRegistry = class {
+  constructor(eventBus, loggingService) {
+    this.eventBus = eventBus;
+    this.logger = loggingService.createLogger("device-registry");
+  }
+  devices = /* @__PURE__ */ new Map();
+  logger;
+  registerDevice(device) {
+    this.devices.set(device.id, device);
+    this.logger.info(`Device registered: ${device.id} (${device.name})`);
+    this.eventBus.emit({
+      id: randomUUID8(),
+      timestamp: /* @__PURE__ */ new Date(),
+      source: { type: "core", id: "device-registry" },
+      category: "device.registered",
+      data: { deviceId: device.id, name: device.name, providerId: device.providerId }
+    });
+  }
+  unregisterDevice(id) {
+    const device = this.devices.get(id);
+    if (!device) {
+      return;
+    }
+    this.devices.delete(id);
+    this.logger.info(`Device unregistered: ${id}`);
+    this.eventBus.emit({
+      id: randomUUID8(),
+      timestamp: /* @__PURE__ */ new Date(),
+      source: { type: "core", id: "device-registry" },
+      category: "device.unregistered",
+      data: { deviceId: id }
+    });
+  }
+  getDevice(id) {
+    return this.devices.get(id) ?? null;
+  }
+  listDevices() {
+    return Array.from(this.devices.values());
+  }
+  getDevicesByProvider(providerId) {
+    return Array.from(this.devices.values()).filter(
+      (device) => device.providerId === providerId
+    );
+  }
+  getDevicesWithCapability(cap) {
+    return Array.from(this.devices.values()).filter(
+      (device) => device.capabilities.includes(cap)
+    );
+  }
+  registerProviderDevices(providerId, devices) {
+    for (const device of devices) {
+      this.registerDevice(device);
+    }
+    this.logger.info(`Bulk registered ${devices.length} devices for provider ${providerId}`);
+  }
+  unregisterProviderDevices(providerId) {
+    const providerDevices = this.getDevicesByProvider(providerId);
+    for (const device of providerDevices) {
+      this.unregisterDevice(device.id);
+    }
+    this.logger.info(`Bulk unregistered ${providerDevices.length} devices for provider ${providerId}`);
+  }
+};
+
+// src/device/capability-resolver.ts
+var CapabilityResolver = class {
+  constructor(addonRegistry) {
+    this.addonRegistry = addonRegistry;
+  }
+  bindings = /* @__PURE__ */ new Map();
+  resolve(device, cap) {
+    const deviceBindings = this.bindings.get(device.id);
+    const binding = deviceBindings?.[cap];
+    if (binding) {
+      if (binding.source === "disabled") {
+        return null;
+      }
+      if (binding.source === "addon" && binding.addonId) {
+        const addon = this.addonRegistry.getAddon(binding.addonId);
+        if (addon && typeof addon.getCapabilityForDevice === "function") {
+          return addon.getCapabilityForDevice(device, cap, binding.config) ?? null;
+        }
+        return null;
+      }
+    }
+    return device.getCapability(cap);
+  }
+  setBinding(deviceId, cap, binding) {
+    const existing = this.bindings.get(deviceId) ?? {};
+    this.bindings.set(deviceId, { ...existing, [cap]: binding });
+  }
+  removeBinding(deviceId, cap) {
+    const existing = this.bindings.get(deviceId);
+    if (!existing) {
+      return;
+    }
+    const updated = { ...existing };
+    delete updated[cap];
+    this.bindings.set(deviceId, updated);
+  }
+  getBindings(deviceId) {
+    return this.bindings.get(deviceId) ?? {};
+  }
+  getEffectiveCapabilities(device) {
+    const deviceBindings = this.bindings.get(device.id) ?? {};
+    const result = [];
+    for (const cap of device.capabilities) {
+      const binding = deviceBindings[cap];
+      if (!binding || binding.source !== "disabled") {
+        result.push(cap);
+      }
+    }
+    for (const [cap, binding] of Object.entries(deviceBindings)) {
+      if (binding && binding.source === "addon" && !device.capabilities.includes(cap)) {
+        result.push(cap);
+      }
+    }
+    return result;
+  }
+};
+
+// src/provider/provider-manager.ts
+import { randomUUID as randomUUID9 } from "crypto";
+var ProviderManager = class {
+  constructor(deviceRegistry, eventBus, loggingService) {
+    this.deviceRegistry = deviceRegistry;
+    this.eventBus = eventBus;
+    this.loggingService = loggingService;
+    this.logger = loggingService.createLogger("provider-manager");
+  }
+  providers = /* @__PURE__ */ new Map();
+  logger;
+  registerProvider(provider) {
+    const providerLogger = this.loggingService.createLogger(`provider:${provider.id}`);
+    const lifecycle = new LifecycleStateMachine(
+      provider.id,
+      "provider",
+      this.eventBus,
+      providerLogger
+    );
+    this.providers.set(provider.id, { provider, lifecycle, started: false });
+    this.logger.info(`Provider registered: ${provider.id} (${provider.name})`);
+  }
+  async startProvider(id) {
+    const entry = this.providers.get(id);
+    if (!entry) {
+      throw new Error(`Provider "${id}" is not registered`);
+    }
+    if (entry.lifecycle.state === "disabled") {
+      throw new Error(`Provider "${id}" is disabled`);
+    }
+    entry.lifecycle.transition("starting");
+    try {
+      await entry.provider.start();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      entry.lifecycle.transition("error", message);
+      throw err;
+    }
+    entry.lifecycle.transition("running");
+    const devices = entry.provider.getDevices();
+    this.deviceRegistry.registerProviderDevices(id, devices);
+    const unsubscribe = entry.provider.subscribeLiveEvents((event) => {
+      this.eventBus.emit({
+        id: randomUUID9(),
+        timestamp: /* @__PURE__ */ new Date(),
+        source: { type: "provider", id },
+        category: `provider.${event.type}`,
+        data: event.data
+      });
+    });
+    entry.started = true;
+    entry.unsubscribe = unsubscribe;
+    this.eventBus.emit({
+      id: randomUUID9(),
+      timestamp: /* @__PURE__ */ new Date(),
+      source: { type: "core", id: "provider-manager" },
+      category: "provider.started",
+      data: { providerId: id }
+    });
+    this.logger.info(`Provider started: ${id}`);
+  }
+  async stopProvider(id) {
+    const entry = this.providers.get(id);
+    if (!entry) {
+      throw new Error(`Provider "${id}" is not registered`);
+    }
+    entry.lifecycle.transition("stopping");
+    if (entry.unsubscribe) {
+      entry.unsubscribe();
+      entry.unsubscribe = void 0;
+    }
+    this.deviceRegistry.unregisterProviderDevices(id);
+    await entry.provider.stop();
+    entry.started = false;
+    entry.lifecycle.transition("stopped");
+    this.eventBus.emit({
+      id: randomUUID9(),
+      timestamp: /* @__PURE__ */ new Date(),
+      source: { type: "core", id: "provider-manager" },
+      category: "provider.stopped",
+      data: { providerId: id }
+    });
+    this.logger.info(`Provider stopped: ${id}`);
+  }
+  async disableProvider(id) {
+    const entry = this.providers.get(id);
+    if (!entry) {
+      throw new Error(`Provider "${id}" is not registered`);
+    }
+    if (entry.lifecycle.state === "running" || entry.started) {
+      await this.stopProvider(id);
+    }
+    entry.lifecycle.transition("disabled");
+    this.logger.info(`Provider disabled: ${id}`);
+  }
+  async enableProvider(id) {
+    const entry = this.providers.get(id);
+    if (!entry) {
+      throw new Error(`Provider "${id}" is not registered`);
+    }
+    if (entry.lifecycle.state !== "disabled") {
+      throw new Error(`Provider "${id}" is not disabled`);
+    }
+    entry.lifecycle.transition("stopped");
+    this.logger.info(`Provider enabled: ${id}`);
+  }
+  async restartProvider(id) {
+    await this.stopProvider(id);
+    await this.startProvider(id);
+  }
+  getProvider(id) {
+    const entry = this.providers.get(id);
+    return entry?.provider ?? null;
+  }
+  getProviderStatus(id) {
+    const entry = this.providers.get(id);
+    return entry?.lifecycle.getStatus() ?? null;
+  }
+  listProviders() {
+    return Array.from(this.providers.values()).map((entry) => ({
+      id: entry.provider.id,
+      type: entry.provider.type,
+      name: entry.provider.name,
+      status: entry.provider.getStatus(),
+      started: entry.started,
+      lifecycle: entry.lifecycle.getStatus()
+    }));
+  }
+  async shutdownAll() {
+    const startedIds = Array.from(this.providers.entries()).filter(([, entry]) => entry.started).map(([id]) => id);
+    for (const id of startedIds) {
+      await this.stopProvider(id);
+    }
+    this.logger.info(`All providers shut down (${startedIds.length} stopped)`);
   }
 };
 export {
   AddonEngineManager,
   AddonInstaller,
   AddonLoader,
+  AddonRouteRegistry,
+  AdminUIAddon,
+  AgentClient,
+  AgentRegistry,
+  AgentTaskRunner,
+  ApiKeyManager,
+  AuthManager,
   BUILTIN_PACKAGES,
+  CORE_TABLE_DDL,
+  CapabilityRegistry,
+  CapabilityResolver,
+  ConfigManager,
+  DecodeTaskHandler,
+  DetectTaskHandler,
+  DeviceRegistry,
   EventBus,
+  FeatureManager,
+  FileSystemStorage,
+  FsStorageBackend,
+  INFRA_CAPABILITIES,
+  LifecycleStateMachine,
+  LocalBackupAddon,
+  LocalBackupService,
+  LogManager,
+  LogRingBuffer,
+  ManagedProcess,
+  NetworkQualityTracker,
+  NotificationService,
   PipelineRunner,
   PipelineValidator,
+  ProcessManager,
+  ProviderManager,
   PythonEnvManager,
-  downloadModel
+  RUNTIME_DEFAULTS,
+  RecordTaskHandler,
+  ReplEngine,
+  ScopedLogger,
+  ScopedTokenManager,
+  SettingsStore,
+  SqliteStorageAddon,
+  SqliteStorageProvider,
+  StorageLocationManager,
+  StorageManager,
+  SystemEventBus,
+  TaskDispatcher,
+  ToastService,
+  UserManager,
+  WinstonDestination,
+  WinstonLoggingAddon,
+  addonTableToDdl,
+  bootstrapSchema,
+  downloadModel,
+  isInfraCapability
 };
 //# sourceMappingURL=index.mjs.map