@camstack/server 0.1.7 → 0.2.0

package/src/boot/boot-config.ts

@@ -4,26 +4,26 @@
  * Extracted from main.ts — pure extraction, no behavior change.
  */
 
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as yaml from "js-yaml";
-import { randomBytes } from "node:crypto";
-import { asJsonObject } from "@camstack/types";
-import { bootstrapSchema } from "../core/config/config.schema";
-import type { BootstrapConfig } from "../core/config/config.schema";
-import { StorageLocationManager } from "../core/storage/storage-location-manager";
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+import * as yaml from 'js-yaml'
+import { randomBytes } from 'node:crypto'
+import { asJsonObject } from '@camstack/types'
+import { bootstrapSchema } from '../core/config/config.schema'
+import type { BootstrapConfig } from '../core/config/config.schema'
+import { StorageLocationManager } from '../core/storage/storage-location-manager'
 
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
 
-export type { BootstrapConfig };
+export type { BootstrapConfig }
 
 export interface InfraContext {
-  readonly bootstrapConfig: BootstrapConfig;
-  readonly dataPath: string;
-  readonly locationManager: StorageLocationManager;
-  readonly tlsOptions: { key: Buffer; cert: Buffer } | undefined;
+  readonly bootstrapConfig: BootstrapConfig
+  readonly dataPath: string
+  readonly locationManager: StorageLocationManager
+  readonly tlsOptions: { key: Buffer; cert: Buffer } | undefined
 }
 
 // ---------------------------------------------------------------------------
@@ -31,28 +31,28 @@ export interface InfraContext {
 // ---------------------------------------------------------------------------
 
 const CONFIG_DEFAULTS: Record<string, unknown> = {
-  server: { port: 4443, host: "0.0.0.0", dataPath: "camstack-data" },
+  server: { port: 4443, host: '0.0.0.0', dataPath: 'camstack-data' },
   auth: {
     jwtSecret: null,
-    adminUsername: "admin",
-    adminPassword: "changeme",
+    adminUsername: 'admin',
+    adminPassword: 'changeme',
   },
-};
+}
 
 const ENV_VAR_MAP: Record<string, string> = {
-  CAMSTACK_PORT: "server.port",
-  CAMSTACK_HOST: "server.host",
-  CAMSTACK_DATA: "server.dataPath",
-  CAMSTACK_JWT_SECRET: "auth.jwtSecret",
-  CAMSTACK_ADMIN_USER: "auth.adminUsername",
-  CAMSTACK_ADMIN_PASS: "auth.adminPassword",
-  CAMSTACK_HUB_URL: "hub.url",
-  CAMSTACK_HUB_TOKEN: "hub.token",
-  CAMSTACK_AGENT_NAME: "agent.name",
-  CAMSTACK_TLS_ENABLED: "tls.enabled",
-  CAMSTACK_TLS_CERT: "tls.certPath",
-  CAMSTACK_TLS_KEY: "tls.keyPath",
-};
+  CAMSTACK_PORT: 'server.port',
+  CAMSTACK_HOST: 'server.host',
+  CAMSTACK_DATA: 'server.dataPath',
+  CAMSTACK_JWT_SECRET: 'auth.jwtSecret',
+  CAMSTACK_ADMIN_USER: 'auth.adminUsername',
+  CAMSTACK_ADMIN_PASS: 'auth.adminPassword',
+  CAMSTACK_HUB_URL: 'hub.url',
+  CAMSTACK_HUB_TOKEN: 'hub.token',
+  CAMSTACK_AGENT_NAME: 'agent.name',
+  CAMSTACK_TLS_ENABLED: 'tls.enabled',
+  CAMSTACK_TLS_CERT: 'tls.certPath',
+  CAMSTACK_TLS_KEY: 'tls.keyPath',
+}
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -63,11 +63,11 @@ function setNested(
   p: string,
   value: unknown,
 ): Record<string, unknown> {
-  const [head, ...rest] = p.split(".");
-  if (!head) return obj;
-  if (rest.length === 0) return { ...obj, [head]: value };
-  const child = asJsonObject(obj[head]) ?? {};
-  return { ...obj, [head]: setNested(child, rest.join("."), value) };
+  const [head, ...rest] = p.split('.')
+  if (!head) return obj
+  if (rest.length === 0) return { ...obj, [head]: value }
+  const child = asJsonObject(obj[head]) ?? {}
+  return { ...obj, [head]: setNested(child, rest.join('.'), value) }
 }
 
 // ---------------------------------------------------------------------------
@@ -82,72 +82,68 @@ export function loadBootstrapConfig(configPath: string): BootstrapConfig {
   // Only bootstrap sections live in config.yaml.
   // All runtime settings are stored in the SQL system_settings table.
 
-  let raw: Record<string, unknown>;
+  let raw: Record<string, unknown>
 
   if (fs.existsSync(configPath)) {
-    const content = fs.readFileSync(configPath, "utf-8");
-    raw = asJsonObject(yaml.load(content)) ?? {};
+    const content = fs.readFileSync(configPath, 'utf-8')
+    raw = asJsonObject(yaml.load(content)) ?? {}
     // Merge in any missing bootstrap sections (server, auth only)
-    let updated = false;
+    let updated = false
     for (const [key, defaults] of Object.entries(CONFIG_DEFAULTS)) {
       if (!(key in raw)) {
-        raw[key] = defaults;
-        updated = true;
+        raw[key] = defaults
+        updated = true
       }
     }
     if (updated) {
       try {
-        const tmpPath = `${configPath}.tmp`;
+        const tmpPath = `${configPath}.tmp`
         fs.writeFileSync(
           tmpPath,
           yaml.dump(raw, { lineWidth: 120, indent: 2, quotingType: '"' }),
-          "utf-8",
-        );
-        fs.renameSync(tmpPath, configPath);
-        console.log(
-          `[Phase1] Updated config.yaml with missing bootstrap defaults`,
-        );
+          'utf-8',
+        )
+        fs.renameSync(tmpPath, configPath)
+        console.log(`[Phase1] Updated config.yaml with missing bootstrap defaults`)
       } catch (err) {
-        console.warn(`[Phase1] Could not update config.yaml:`, err);
+        console.warn(`[Phase1] Could not update config.yaml:`, err)
       }
     }
-    console.log(`[Phase1] Loaded bootstrap config from: ${configPath}`);
+    console.log(`[Phase1] Loaded bootstrap config from: ${configPath}`)
   } else {
-    console.log(
-      `[Phase1] Config file not found at: ${configPath} — writing defaults`,
-    );
-    const defaults = { ...CONFIG_DEFAULTS };
+    console.log(`[Phase1] Config file not found at: ${configPath} — writing defaults`)
+    const defaults = { ...CONFIG_DEFAULTS }
     try {
-      fs.mkdirSync(path.dirname(configPath), { recursive: true });
-      const tmpPath = `${configPath}.tmp`;
+      fs.mkdirSync(path.dirname(configPath), { recursive: true })
+      const tmpPath = `${configPath}.tmp`
       fs.writeFileSync(
         tmpPath,
         yaml.dump(defaults, { lineWidth: 120, indent: 2, quotingType: '"' }),
-        "utf-8",
-      );
-      fs.renameSync(tmpPath, configPath);
-      console.log(`[Phase1] Default config.yaml written to: ${configPath}`);
+        'utf-8',
+      )
+      fs.renameSync(tmpPath, configPath)
+      console.log(`[Phase1] Default config.yaml written to: ${configPath}`)
     } catch (err) {
-      console.warn(`[Phase1] Could not write default config.yaml:`, err);
+      console.warn(`[Phase1] Could not write default config.yaml:`, err)
     }
-    raw = defaults;
+    raw = defaults
   }
 
   // Apply env var overrides for bootstrap keys
   for (const [envKey, configPath_] of Object.entries(ENV_VAR_MAP)) {
-    const envValue = process.env[envKey];
-    if (envValue === undefined || envValue === "") continue;
+    const envValue = process.env[envKey]
+    if (envValue === undefined || envValue === '') continue
     const coerced: unknown =
-      configPath_ === "server.port"
+      configPath_ === 'server.port'
         ? Number(envValue)
-        : configPath_ === "tls.enabled"
-          ? envValue === "true"
-          : envValue;
-    raw = setNested(raw, configPath_, coerced);
-    console.log(`[Phase1] Env override: ${envKey} → ${configPath_}`);
+        : configPath_ === 'tls.enabled'
+          ? envValue === 'true'
+          : envValue
+    raw = setNested(raw, configPath_, coerced)
+    console.log(`[Phase1] Env override: ${envKey} → ${configPath_}`)
   }
 
-  return bootstrapSchema.parse(raw);
+  return bootstrapSchema.parse(raw)
 }
 
 // ---------------------------------------------------------------------------
@@ -163,42 +159,37 @@ export function autoGenerateJwtSecret(
   bootstrapConfig: BootstrapConfig,
 ): BootstrapConfig {
   if (bootstrapConfig.auth.jwtSecret !== null) {
-    return bootstrapConfig;
+    return bootstrapConfig
   }
 
-  const secret = randomBytes(32).toString("hex");
-  console.log(
-    "[Phase1] jwtSecret is null — auto-generating and writing to config.yaml",
-  );
+  const secret = randomBytes(32).toString('hex')
+  console.log('[Phase1] jwtSecret is null — auto-generating and writing to config.yaml')
 
-  let raw: Record<string, unknown> = {};
+  let raw: Record<string, unknown> = {}
   if (fs.existsSync(configPath)) {
-    raw = asJsonObject(yaml.load(fs.readFileSync(configPath, "utf-8"))) ?? {};
+    raw = asJsonObject(yaml.load(fs.readFileSync(configPath, 'utf-8'))) ?? {}
   }
 
-  const authSection = asJsonObject(raw.auth) ?? {};
-  raw.auth = { ...authSection, jwtSecret: secret };
+  const authSection = asJsonObject(raw.auth) ?? {}
+  raw.auth = { ...authSection, jwtSecret: secret }
 
-  const tmpPath = `${configPath}.tmp`;
+  const tmpPath = `${configPath}.tmp`
   try {
-    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.mkdirSync(path.dirname(configPath), { recursive: true })
     fs.writeFileSync(
       tmpPath,
       yaml.dump(raw, { lineWidth: 120, indent: 2, quotingType: '"' }),
-      "utf-8",
-    );
-    fs.renameSync(tmpPath, configPath);
+      'utf-8',
+    )
+    fs.renameSync(tmpPath, configPath)
   } catch (err) {
-    console.warn(
-      "[Phase1] Could not write auto-generated jwtSecret to config.yaml:",
-      err,
-    );
+    console.warn('[Phase1] Could not write auto-generated jwtSecret to config.yaml:', err)
   }
 
   return {
     ...bootstrapConfig,
     auth: { ...bootstrapConfig.auth, jwtSecret: secret },
-  };
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -214,58 +205,48 @@ export async function setupInfra(
   bootstrapConfig: BootstrapConfig,
 ): Promise<InfraContext> {
   // Auto-generate jwtSecret if not set
-  const config = autoGenerateJwtSecret(configPath, bootstrapConfig);
+  const config = autoGenerateJwtSecret(configPath, bootstrapConfig)
 
-  const dataPath = path.resolve(config.server.dataPath);
-  const port = config.server.port;
-  const host = config.server.host;
+  const dataPath = path.resolve(config.server.dataPath)
+  const port = config.server.port
+  const host = config.server.host
 
-  console.log(
-    `[Phase1] Bootstrap: port=${port}, host=${host}, dataPath=${dataPath}`,
-  );
+  console.log(`[Phase1] Bootstrap: port=${port}, host=${host}, dataPath=${dataPath}`)
 
   // --- Phase 2: Init StorageLocationManager → ensure all dirs exist ---
-  console.log("[Phase2] Initializing storage locations…");
-  const locationManager = new StorageLocationManager(dataPath);
-  await locationManager.initializeDefaults();
+  console.log('[Phase2] Initializing storage locations…')
+  const locationManager = new StorageLocationManager(dataPath)
+  await locationManager.initializeDefaults()
 
-  const locationStatus = locationManager.getStatus();
+  const locationStatus = locationManager.getStatus()
   for (const { name, available, path: locPath } of locationStatus) {
-    console.log(
-      `[Phase2] Location "${name}": ${available ? "OK" : "UNAVAILABLE"} → ${locPath}`,
-    );
+    console.log(`[Phase2] Location "${name}": ${available ? 'OK' : 'UNAVAILABLE'} → ${locPath}`)
   }
 
   // --- Phase 2c: TLS certificate setup ---
-  let tlsOptions: { key: Buffer; cert: Buffer } | undefined;
+  let tlsOptions: { key: Buffer; cert: Buffer } | undefined
 
   if (config.tls.enabled) {
     // Use require() instead of import() — the ESM build of @camstack/core has
     // broken chunks with require("fs") when leaked .js files exist in core/src/.
     // CJS build works correctly and tsx supports require().
-    const core = require("@camstack/core") as typeof import("@camstack/core");
-    const { ensureTlsCert, loadTlsCert } = core;
+    const core = require('@camstack/core') as typeof import('@camstack/core')
+    const { ensureTlsCert, loadTlsCert } = core
     if (config.tls.certPath && config.tls.keyPath) {
       // User-provided cert
-      console.log(
-        `[Phase2c] Loading custom TLS cert from ${config.tls.certPath}`,
-      );
-      const pair = loadTlsCert(config.tls.certPath, config.tls.keyPath);
-      tlsOptions = { key: pair.key, cert: pair.cert };
+      console.log(`[Phase2c] Loading custom TLS cert from ${config.tls.certPath}`)
+      const pair = loadTlsCert(config.tls.certPath, config.tls.keyPath)
+      tlsOptions = { key: pair.key, cert: pair.cert }
     } else {
       // Auto-generate self-signed
-      const tlsResult = await ensureTlsCert(dataPath);
+      const tlsResult = await ensureTlsCert(dataPath)
       if (tlsResult.generated) {
-        console.log(
-          `[Phase2c] Generated self-signed TLS cert at ${tlsResult.certPath}`,
-        );
+        console.log(`[Phase2c] Generated self-signed TLS cert at ${tlsResult.certPath}`)
       } else {
-        console.log(
-          `[Phase2c] Using existing TLS cert at ${tlsResult.certPath}`,
-        );
+        console.log(`[Phase2c] Using existing TLS cert at ${tlsResult.certPath}`)
       }
-      const pair = loadTlsCert(tlsResult.certPath, tlsResult.keyPath);
-      tlsOptions = { key: pair.key, cert: pair.cert };
+      const pair = loadTlsCert(tlsResult.certPath, tlsResult.keyPath)
+      tlsOptions = { key: pair.key, cert: pair.cert }
     }
   }
 
@@ -274,5 +255,5 @@ export async function setupInfra(
     dataPath,
     locationManager,
     tlsOptions,
-  };
+  }
 }

package/src/boot/integration-id-backfill.ts

@@ -0,0 +1,109 @@
+/**
+ * One-time integration-id backfill for devices created before the
+ * device-manager forwarder started stamping `integrationId` (camera
+ * providers). Maps each addon that hosts EXACTLY ONE integration to that
+ * integration id, then stamps top-level untagged devices of those addons.
+ * Multi-instance addons (e.g. Home Assistant with several brokers) are
+ * ambiguous on `addonId` alone and are skipped — they stamp going forward.
+ */
+
+export interface BackfillIntegration {
+  readonly id: string
+  readonly addonId: string
+}
+
+export interface BackfillDevice {
+  readonly id: number
+  readonly addonId: string
+  readonly parentDeviceId: number | null
+  readonly integrationId?: string
+}
+
+export interface BackfillStamp {
+  readonly deviceId: number
+  readonly integrationId: string
+}
+
+export function planIntegrationIdBackfill(
+  integrations: readonly BackfillIntegration[],
+  devices: readonly BackfillDevice[],
+): readonly BackfillStamp[] {
+  const singleByAddon = new Map<string, string>()
+  const ambiguous = new Set<string>()
+  for (const integration of integrations) {
+    if (ambiguous.has(integration.addonId)) continue
+    if (singleByAddon.has(integration.addonId)) {
+      singleByAddon.delete(integration.addonId)
+      ambiguous.add(integration.addonId)
+      continue
+    }
+    singleByAddon.set(integration.addonId, integration.id)
+  }
+
+  const stamps: BackfillStamp[] = []
+  for (const device of devices) {
+    if (device.parentDeviceId !== null) continue
+    if (device.integrationId !== undefined && device.integrationId !== '') continue
+    const integrationId = singleByAddon.get(device.addonId)
+    if (integrationId === undefined) continue
+    stamps.push({ deviceId: device.id, integrationId })
+  }
+  return stamps
+}
+
+/**
+ * Stamps to apply at integration-DELETE time so a cascade removes legacy
+ * un-tagged devices too. The boot backfill only runs on startup; a device
+ * created before stamping (or whose provider never stamps, e.g. `provider-rtsp`)
+ * keeps no `integrationId`, so once its integration is deleted it would orphan
+ * forever — `removeByIntegration` matches on `integrationId` and finds nothing.
+ *
+ * Run this in the delete handler BEFORE deleting the integration record (while
+ * it is still present in `integrations`), then stamp the returned devices and
+ * let `removeByIntegration` cascade them. Reuses the boot backfill's safety
+ * rule (only addons hosting exactly ONE integration are unambiguous) and
+ * filters to the integration being deleted so siblings are never touched.
+ */
+export function planDeleteTimeStamps(
+  integrationId: string,
+  integrations: readonly BackfillIntegration[],
+  devices: readonly BackfillDevice[],
+): readonly BackfillStamp[] {
+  return planIntegrationIdBackfill(integrations, devices).filter(
+    (stamp) => stamp.integrationId === integrationId,
+  )
+}
+
+export interface BackfillLogger {
+  readonly info: (message: string, meta?: Record<string, unknown>) => void
+  readonly warn: (message: string, meta?: Record<string, unknown>) => void
+}
+
+export interface IntegrationIdBackfillDeps {
+  readonly listIntegrations: () => Promise<readonly BackfillIntegration[]>
+  readonly listDevices: () => Promise<readonly BackfillDevice[]>
+  readonly setIntegrationId: (deviceId: number, integrationId: string) => Promise<void>
+  readonly logger: BackfillLogger
+}
+
+export async function runIntegrationIdBackfill(
+  deps: IntegrationIdBackfillDeps,
+): Promise<{ stamped: number }> {
+  const [integrations, devices] = await Promise.all([deps.listIntegrations(), deps.listDevices()])
+  const stamps = planIntegrationIdBackfill(integrations, devices)
+  let stamped = 0
+  for (const stamp of stamps) {
+    try {
+      await deps.setIntegrationId(stamp.deviceId, stamp.integrationId)
+      stamped++
+    } catch (err) {
+      deps.logger.warn('integrationId backfill: stamp failed', {
+        deviceId: stamp.deviceId,
+        integrationId: stamp.integrationId,
+        error: err instanceof Error ? err.message : String(err),
+      })
+    }
+  }
+  if (stamped > 0) deps.logger.info('integrationId backfill complete', { stamped })
+  return { stamped }
+}

package/src/boot/post-boot.service.ts

@@ -1,5 +1,6 @@
 import { randomUUID } from 'node:crypto'
 import { readPendingRestart } from '@camstack/kernel'
+import { EventCategory } from '@camstack/types'
 import type { IScopedLogger, PendingRestartMarkerPayload } from '@camstack/types'
 import { AddonRegistryService } from '../core/addon/addon-registry.service'
 import { EventBusService } from '../core/events/event-bus.service'
@@ -21,7 +22,8 @@ export class PostBootService {
    * after they reconnect — the live event itself is emitted before the
    * WS resubscribe has a chance to land.
    */
-  private static lastRestart: { payload: PendingRestartMarkerPayload; expiresAt: number } | null = null
+  private static lastRestart: { payload: PendingRestartMarkerPayload; expiresAt: number } | null =
+    null
 
   /** How long the last-restart marker stays queryable after boot (5 min). */
   static readonly LAST_RESTART_RETENTION_MS = 5 * 60_000
@@ -62,7 +64,7 @@ export class PostBootService {
       id: randomUUID(),
       timestamp: new Date(),
       source: { type: 'core', id: 'system' },
-      category: 'system.boot',
+      category: EventCategory.SystemBoot,
       data: { port, host, trpcRegistered, dataPath },
     })
 
@@ -96,7 +98,7 @@ export class PostBootService {
       id: randomUUID(),
       timestamp: new Date(),
       source: { type: 'core', id: 'system' },
-      category: 'system.restart-completed',
+      category: EventCategory.SystemRestartCompleted,
       data: payload,
     })
   }

package/src/core/addon/__tests__/addon-registry-capability.test.ts

@@ -1,4 +1,3 @@
- 
 // server/backend/src/core/addon/__tests__/addon-registry-capability.test.ts
 import { describe, it, expect, vi, beforeEach } from 'vitest'
 import { CapabilityRegistry } from '@camstack/kernel'
@@ -32,7 +31,12 @@ describe('AddonRegistryService -- CapabilityRegistry integration', () => {
   })
 
   it('streaming-engine singleton wired after provider registers', () => {
-    registry.declareCapability({ name: 'streaming-engine', scope: 'system', mode: 'singleton', methods: {} })
+    registry.declareCapability({
+      name: 'streaming-engine',
+      scope: 'system',
+      mode: 'singleton',
+      methods: {},
+    })
 
     const mockEngine = { initialize: vi.fn() }
     registry.registerProvider('streaming-engine', 'go2rtc', mockEngine)
@@ -41,7 +45,12 @@ describe('AddonRegistryService -- CapabilityRegistry integration', () => {
   })
 
   it('log-destination collection receives all providers', () => {
-    registry.declareCapability({ name: 'log-destination', scope: 'system', mode: 'collection', methods: {} })
+    registry.declareCapability({
+      name: 'log-destination',
+      scope: 'system',
+      mode: 'collection',
+      methods: {},
+    })
 
     const dest1 = { id: 'winston' }
     const dest2 = { id: 'loki' }

package/src/core/addon/__tests__/addon-row-manifest.spec.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from 'vitest'
+
+import { overlayDeclaration } from '../addon-row-manifest.js'
+
+/**
+ * Regression: after the HA broker rework, redeploying provider-homeassistant
+ * (broker + device-adoption) left the integration picker without Home
+ * Assistant. `loadNewAddons` refreshed `entry.declaration` to the new caps but
+ * `listAddons` built its row manifest from the STALE `entry.addon.manifest`
+ * (still [broker, ha-discovery]), so `getAvailableTypes` filtered HA out.
+ */
+interface TestManifest {
+  id: string
+  name: string
+  icon?: string
+  brokerKind?: string
+  capabilities?: ReadonlyArray<{ name: string }>
+}
+
+describe('overlayDeclaration — listAddons row manifest freshness', () => {
+  const base = { id: 'provider-homeassistant', name: 'Home Assistant' }
+
+  it('prefers the fresh declaration capabilities over the stale instance manifest', () => {
+    const instanceManifest: TestManifest = {
+      ...base,
+      capabilities: [{ name: 'broker' }, { name: 'ha-discovery' }],
+    }
+    const declaration: Partial<TestManifest> = {
+      capabilities: [{ name: 'broker' }, { name: 'device-adoption' }],
+      brokerKind: 'home-assistant',
+    }
+
+    const merged = overlayDeclaration(instanceManifest, declaration)
+
+    expect(merged.capabilities).toEqual([{ name: 'broker' }, { name: 'device-adoption' }])
+    expect(merged.brokerKind).toBe('home-assistant')
+  })
+
+  it('keeps the instance manifest when no fresh declaration exists', () => {
+    const instanceManifest: TestManifest = { ...base, capabilities: [{ name: 'broker' }] }
+
+    const merged = overlayDeclaration(instanceManifest, undefined)
+
+    expect(merged.capabilities).toEqual([{ name: 'broker' }])
+  })
+
+  it('fills gaps from the instance manifest for keys the declaration omits', () => {
+    const instanceManifest: TestManifest = {
+      ...base,
+      icon: 'assets/icon.svg',
+      capabilities: [{ name: 'broker' }],
+    }
+    const declaration: Partial<TestManifest> = {
+      capabilities: [{ name: 'broker' }, { name: 'device-adoption' }],
+    }
+
+    const merged = overlayDeclaration(instanceManifest, declaration)
+
+    expect(merged.icon).toBe('assets/icon.svg')
+    expect(merged.capabilities).toContainEqual({ name: 'device-adoption' })
+  })
+})

package/src/core/addon/addon-call-gateway.ts

@@ -92,7 +92,11 @@ export class AddonCallGateway {
    * must invoke the in-process instance directly (the invocation is
    * surface-specific; only the ROUTING is centralised here).
    */
-  async callForked(addonId: string, input: AddonCallSurface, explicitNodeId?: string): Promise<unknown> {
+  async callForked(
+    addonId: string,
+    input: AddonCallSurface,
+    explicitNodeId?: string,
+  ): Promise<unknown> {
     const dest = this.classify(addonId, explicitNodeId)
     const fullInput: AddonCallInput = { ...input, addonId }
     switch (dest.kind) {
@@ -115,7 +119,11 @@ export class AddonCallGateway {
   }
 
   /** Map an addon-level call to the remote agent's Moleculer action. */
-  private async callRemoteAgent(addonId: string, baseNodeId: string, input: AddonCallInput): Promise<unknown> {
+  private async callRemoteAgent(
+    addonId: string,
+    baseNodeId: string,
+    input: AddonCallInput,
+  ): Promise<unknown> {
     const workerNodeId = this.resolveWorkerNodeId(addonId, baseNodeId)
     const opts = workerNodeId
       ? { nodeID: workerNodeId, timeout: REMOTE_TIMEOUT_MS }
@@ -132,7 +140,9 @@ export class AddonCallGateway {
     }
     // routes/custom are hub-local-child surfaces (mounted / invoked on the
     // owning node); they are not proxied to a remote agent through this gateway.
-    throw new Error(`AddonCallGateway: target "${input.target}" not supported for remote agent "${baseNodeId}"`)
+    throw new Error(
+      `AddonCallGateway: target "${input.target}" not supported for remote agent "${baseNodeId}"`,
+    )
   }
 
   /**
@@ -143,9 +153,13 @@ export class AddonCallGateway {
    */
   private resolveWorkerNodeId(addonId: string, baseNodeId: string): string | null {
     const registry = this.deps.broker.registry
-    const services = (registry as unknown as {
-      getServiceList: (opts: { onlyAvailable: boolean }) => readonly { name: string; nodeID: string }[]
-    }).getServiceList({ onlyAvailable: true })
+    const services = (
+      registry as unknown as {
+        getServiceList: (opts: {
+          onlyAvailable: boolean
+        }) => readonly { name: string; nodeID: string }[]
+      }
+    ).getServiceList({ onlyAvailable: true })
     const exactNode = `${baseNodeId}/${addonId}`
     const preferred = services.find((s) => s.name === addonId && s.nodeID === exactNode)
     if (preferred) return preferred.nodeID