@camstack/server 0.2.2 → 1.0.1

package/dist/manual-boot.js

@@ -0,0 +1,227 @@
+"use strict";
+/**
+ * Boot — constructs every service by hand in dependency order, runs
+ * `onModuleInit` hooks in sequence, and exposes a `BootedApp` facade
+ * around the Fastify instance. This is the only boot path; NestJS was
+ * removed to drop the accidental DI layer on top of an already-explicit
+ * dependency graph.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bootManual = bootManual;
+const fastify_1 = __importDefault(require("fastify"));
+const config_service_1 = require("./core/config/config.service");
+const logging_service_1 = require("./core/logging/logging.service");
+const event_bus_service_1 = require("./core/events/event-bus.service");
+const storage_service_1 = require("./core/storage/storage.service");
+const capability_service_1 = require("./core/capability/capability.service");
+const feature_service_1 = require("./core/feature/feature.service");
+const auth_service_1 = require("./core/auth/auth.service");
+const stream_probe_service_1 = require("./core/streaming/stream-probe.service");
+const network_quality_service_1 = require("./core/network/network-quality.service");
+const toast_wrapper_service_1 = require("./core/notification/toast-wrapper.service");
+const notification_wrapper_service_1 = require("./core/notification/notification-wrapper.service");
+const addon_pages_service_1 = require("./core/addon-pages/addon-pages.service");
+const addon_widgets_service_1 = require("./core/addon-widgets/addon-widgets.service");
+const addon_bridge_service_1 = require("./core/addon-bridge/addon-bridge.service");
+const moleculer_service_1 = require("./core/moleculer/moleculer.service");
+const agent_registry_service_1 = require("./core/agent/agent-registry.service");
+const addon_registry_service_1 = require("./core/addon/addon-registry.service");
+const addon_search_service_1 = require("./core/addon/addon-search.service");
+const addon_package_service_1 = require("./core/addon/addon-package.service");
+const repl_engine_service_1 = require("./core/repl/repl-engine.service");
+const topology_emitter_service_1 = require("./core/topology/topology-emitter.service");
+const post_boot_service_1 = require("./boot/post-boot.service");
+// ---------------------------------------------------------------------------
+// Service container — narrowing via `instanceof`, no casts.
+// ---------------------------------------------------------------------------
+class ServiceContainer {
+    services = new Map();
+    register(ctor, instance) {
+        this.services.set(ctor, instance);
+    }
+    get(ctor) {
+        const inst = this.services.get(ctor);
+        if (inst === undefined) {
+            throw new Error(`ServiceContainer: ${ctor.name} is not registered`);
+        }
+        if (!(inst instanceof ctor)) {
+            throw new Error(`ServiceContainer: ${ctor.name} instance type mismatch at resolve time`);
+        }
+        return inst;
+    }
+}
+// ---------------------------------------------------------------------------
+// Manual boot
+// ---------------------------------------------------------------------------
+async function bootManual(opts) {
+    const { infra, fastifyOpts } = opts;
+    void infra; // infraContext is consumed by main.ts directly (locationManager, etc.)
+    const configPath = process.env.CONFIG_PATH ?? 'camstack-data/config.yaml';
+    // ---- Layer 0: services with no service deps -----------------------------
+    const configService = new config_service_1.ConfigService(configPath);
+    const storageService = new storage_service_1.StorageService();
+    const capabilityService = new capability_service_1.CapabilityService();
+    const networkQualityService = new network_quality_service_1.NetworkQualityService();
+    const toastWrapper = new toast_wrapper_service_1.ToastServiceWrapper();
+    // ---- Layer 1: need ConfigService / LoggingService -----------------------
+    const loggingService = new logging_service_1.LoggingService(configService);
+    const eventBusService = new event_bus_service_1.EventBusService(configService);
+    // Wire device-name cache for log formatter — subscribes here so the
+    // very first DeviceRegistered event populates the cache before any
+    // log line needing `deviceName` is emitted.
+    loggingService.attachDeviceNameStream(eventBusService);
+    const featureService = new feature_service_1.FeatureService(configService);
+    const authService = new auth_service_1.AuthService(configService);
+    const streamProbeService = new stream_probe_service_1.StreamProbeService(loggingService);
+    const addonBridgeService = new addon_bridge_service_1.AddonBridgeService(loggingService);
+    const addonSearchService = new addon_search_service_1.AddonSearchService(loggingService);
+    // ---- Layer 2: need Layer 0/1 -------------------------------------------
+    const notificationWrapper = new notification_wrapper_service_1.NotificationServiceWrapper(capabilityService, loggingService);
+    const addonPagesService = new addon_pages_service_1.AddonPagesService(loggingService, configService, capabilityService);
+    const moleculerService = new moleculer_service_1.MoleculerService(eventBusService, configService, loggingService, capabilityService, streamProbeService);
+    // ---- Layer 3: need Moleculer / AddonRegistry ---------------------------
+    const agentRegistryService = new agent_registry_service_1.AgentRegistryService(eventBusService, moleculerService, capabilityService);
+    const addonRegistryService = new addon_registry_service_1.AddonRegistryService(loggingService, eventBusService, configService, storageService, capabilityService, moleculerService, streamProbeService);
+    // AgentRegistryService needs the hub addon registry for placement-based
+    // reconciliation, but is constructed first (it has no other dependency
+    // on AddonRegistryService) — wire it post-construction.
+    agentRegistryService.setAddonRegistry(addonRegistryService);
+    // ---- Layer 4: need AddonRegistry ---------------------------------------
+    // AddonWidgetsService — needs AddonRegistryService for the bundled-addon
+    // dist sub-folder lookup (see service docstring).
+    const addonWidgetsService = new addon_widgets_service_1.AddonWidgetsService(loggingService, capabilityService, addonRegistryService);
+    const addonPackageService = new addon_package_service_1.AddonPackageService(loggingService, eventBusService, configService, addonRegistryService, notificationWrapper, toastWrapper);
+    const replEngineService = new repl_engine_service_1.ReplEngineService(addonRegistryService, eventBusService, loggingService);
+    const topologyEmitterService = new topology_emitter_service_1.TopologyEmitterService(eventBusService, agentRegistryService, addonRegistryService);
+    const postBootService = new post_boot_service_1.PostBootService(addonRegistryService, eventBusService, loggingService);
+    // ---- Container ---------------------------------------------------------
+    const container = new ServiceContainer();
+    container.register(config_service_1.ConfigService, configService);
+    container.register(logging_service_1.LoggingService, loggingService);
+    container.register(event_bus_service_1.EventBusService, eventBusService);
+    container.register(storage_service_1.StorageService, storageService);
+    container.register(capability_service_1.CapabilityService, capabilityService);
+    container.register(feature_service_1.FeatureService, featureService);
+    container.register(auth_service_1.AuthService, authService);
+    container.register(stream_probe_service_1.StreamProbeService, streamProbeService);
+    container.register(network_quality_service_1.NetworkQualityService, networkQualityService);
+    container.register(toast_wrapper_service_1.ToastServiceWrapper, toastWrapper);
+    container.register(notification_wrapper_service_1.NotificationServiceWrapper, notificationWrapper);
+    container.register(addon_pages_service_1.AddonPagesService, addonPagesService);
+    container.register(addon_widgets_service_1.AddonWidgetsService, addonWidgetsService);
+    container.register(addon_bridge_service_1.AddonBridgeService, addonBridgeService);
+    container.register(moleculer_service_1.MoleculerService, moleculerService);
+    container.register(agent_registry_service_1.AgentRegistryService, agentRegistryService);
+    container.register(addon_registry_service_1.AddonRegistryService, addonRegistryService);
+    container.register(addon_search_service_1.AddonSearchService, addonSearchService);
+    container.register(addon_package_service_1.AddonPackageService, addonPackageService);
+    container.register(repl_engine_service_1.ReplEngineService, replEngineService);
+    container.register(topology_emitter_service_1.TopologyEmitterService, topologyEmitterService);
+    container.register(post_boot_service_1.PostBootService, postBootService);
+    // ---- Fastify instance --------------------------------------------------
+    const fastify = (0, fastify_1.default)(fastifyOpts);
+    // /health and /health/* — registered in `main.ts` via
+    // `registerHealthRoutes` once MoleculerService + AgentRegistryService are
+    // available. The detailed shape is shared with each agent's `/health`
+    // (see `packages/agent/src/agent-http.ts`).
+    // ---- Shutdown coordination --------------------------------------------
+    let closed = false;
+    let shutdownHooksRegistered = false;
+    const close = async () => {
+        if (closed)
+            return;
+        closed = true;
+        const logErr = (label, err) => {
+            console.error(`[manual-boot] ${label} destroy failed:`, err);
+        };
+        try {
+            topologyEmitterService.onModuleDestroy();
+        }
+        catch (err) {
+            logErr('TopologyEmitter', err);
+        }
+        try {
+            await addonRegistryService.onModuleDestroy();
+        }
+        catch (err) {
+            logErr('AddonRegistry', err);
+        }
+        try {
+            await addonBridgeService.onModuleDestroy();
+        }
+        catch (err) {
+            logErr('AddonBridge', err);
+        }
+        try {
+            await moleculerService.onModuleDestroy();
+        }
+        catch (err) {
+            logErr('Moleculer', err);
+        }
+        try {
+            await fastify.close();
+        }
+        catch (err) {
+            logErr('Fastify', err);
+        }
+    };
+    return {
+        get(ctor) {
+            return container.get(ctor);
+        },
+        getHttpAdapter() {
+            return { getInstance: () => fastify };
+        },
+        enableCors() {
+            fastify.addHook('onRequest', async (request, reply) => {
+                reply.header('access-control-allow-origin', '*');
+                reply.header('access-control-allow-methods', 'GET,POST,PUT,DELETE,OPTIONS,PATCH');
+                reply.header('access-control-allow-headers', 'content-type,authorization');
+                if (request.method === 'OPTIONS') {
+                    reply.status(204).send();
+                }
+            });
+        },
+        enableShutdownHooks() {
+            if (shutdownHooksRegistered)
+                return;
+            shutdownHooksRegistered = true;
+            const handler = () => {
+                close().catch((err) => {
+                    console.error('[manual-boot] shutdown close failed:', err);
+                });
+            };
+            process.once('SIGTERM', handler);
+            process.once('SIGINT', handler);
+        },
+        async init() {
+            // Init order (dependency-graph-derived):
+            //   1. MoleculerService — starts broker and calls EventBus.attachBroker()
+            //   2. AddonBridgeService — no cross-service deps
+            //   3. AgentRegistryService — subscribes to broker.localBus.on('$node.connected')
+            //   4. AddonRegistryService — boots every addon (needs broker live + config)
+            await moleculerService.onModuleInit();
+            await addonBridgeService.onModuleInit();
+            agentRegistryService.onModuleInit();
+            await addonRegistryService.onModuleInit();
+            // Reconcile already-connected agents now that the hub's installed
+            // addon set is populated. Agents online before the hub started never
+            // fire a fresh `$node.connected` event, so the per-connect trigger
+            // alone would miss them — this catches the boot-time case (e.g. a
+            // long-running dev-agent with a now-stale addon). Fire-and-forget so
+            // an unreachable agent never delays boot.
+            void agentRegistryService.reconcileConnectedAgents();
+            // Topology emitter must boot AFTER AgentRegistry + AddonRegistry —
+            // its initial snapshot reads both. Subscribes to lifecycle events
+            // for incremental snapshots and emits a periodic safety net.
+            topologyEmitterService.onModuleInit();
+        },
+        async listen(port, host) {
+            await fastify.listen({ port, host });
+        },
+        close,
+    };
+}

package/package.json

@@ -1,7 +1,11 @@
 {
   "name": "@camstack/server",
-  "version": "0.2.2",
+  "version": "1.0.1",
   "private": false,
+  "files": [
+    "dist",
+    ".env.example"
+  ],
   "exports": {
     "./package.json": "./package.json",
     "./main.js": "./dist/main.js",

package/src/__tests__/addon-install-e2e.test.ts

@@ -1,74 +0,0 @@
-// server/backend/src/__tests__/addon-install-e2e.test.ts
-//
-// E2E test: simulates addon directory scanning and verifies
-// addon packages with package.json + dist/ can be loaded.
-//
-import { describe, it, expect, beforeAll, afterAll } from 'vitest'
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-
-const TEST_ADDONS_DIR = path.resolve('test-output/fresh-addons')
-
-describe('Addon Directory Loading', () => {
-  beforeAll(() => {
-    // Clean slate — delete the test addons directory
-    fs.rmSync(TEST_ADDONS_DIR, { recursive: true, force: true })
-    fs.mkdirSync(TEST_ADDONS_DIR, { recursive: true })
-  })
-
-  afterAll(() => {
-    // Cleanup
-    fs.rmSync(TEST_ADDONS_DIR, { recursive: true, force: true })
-  })
-
-  it('AddonInstaller initializes the addons directory', async () => {
-    const { AddonInstaller } = await import('@camstack/kernel')
-
-    // Constructor creates the addons directory if it doesn't exist
-    const installer = new AddonInstaller({
-      addonsDir: TEST_ADDONS_DIR,
-    })
-
-    // Verify directory exists and installer was created
-    expect(installer.addonsDir).toBe(TEST_ADDONS_DIR)
-    expect(fs.existsSync(TEST_ADDONS_DIR)).toBe(true)
-  })
-
-  it('AddonInstaller lists installed addon packages', async () => {
-    const { AddonInstaller } = await import('@camstack/kernel')
-
-    // Create a mock addon directory
-    const addonDir = path.join(TEST_ADDONS_DIR, 'addon-test')
-    fs.mkdirSync(addonDir, { recursive: true })
-    fs.writeFileSync(
-      path.join(addonDir, 'package.json'),
-      JSON.stringify({
-        name: '@camstack/addon-test',
-        version: '1.0.0',
-        camstack: { addons: [{ id: 'test', entry: './dist/index.js', slot: 'detector' }] },
-      }),
-    )
-
-    const installer = new AddonInstaller({ addonsDir: TEST_ADDONS_DIR })
-    const installed = installer.listInstalled()
-
-    expect(installed).toHaveLength(1)
-    expect(installed[0]).toMatchObject({
-      name: '@camstack/addon-test',
-      version: '1.0.0',
-    })
-
-    // Cleanup
-    fs.rmSync(addonDir, { recursive: true, force: true })
-  })
-
-  it('AddonLoader scans addons directory and loads packages', async () => {
-    const { AddonLoader } = await import('@camstack/kernel')
-
-    const loader = new AddonLoader()
-
-    // With an empty directory, no addons should be loaded
-    await loader.loadFromDirectory(TEST_ADDONS_DIR)
-    expect(loader.listAddons()).toHaveLength(0)
-  })
-})

package/src/__tests__/addon-pages-e2e.test.ts

@@ -1,200 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access -- test file: mock AddonContext for `addon.initialize` is deliberately loose */
-// server/backend/src/__tests__/addon-pages-e2e.test.ts
-//
-// Integration tests: verify addon-pages capability wiring end-to-end,
-// BenchmarkAddon page registration, and AdminUIAddon capability provider.
-//
-import { describe, it, expect, vi } from 'vitest'
-import { CapabilityRegistry } from '@camstack/kernel'
-import type { AddonContext, IScopedLogger, ProviderRegistration } from '@camstack/types'
-
-// ---------------------------------------------------------------------------
-// Optional-module loader — returns the AdminUIAddon class if the admin-ui
-// addon is built and resolvable, otherwise null. Typed against a narrow
-// structural signature so the test never leaks `any` through the dynamic
-// import (the module exports its own dist path which may not exist when
-// the backend workspace is built in isolation).
-// ---------------------------------------------------------------------------
-
-interface AdminUIAddonInstance {
-  readonly id: string
-  initialize(ctx: AddonContext): Promise<
-    | ProviderRegistration[]
-    | void
-    | undefined
-    | {
-        readonly providers?: readonly ProviderRegistration[]
-      }
-  >
-}
-
-type AdminUIAddonCtor = new () => AdminUIAddonInstance
-
-async function loadAdminUIAddon(): Promise<AdminUIAddonCtor | null> {
-  try {
-    const mod = (await import('@camstack/addon-admin-ui/server/addon')) as {
-      AdminUIAddon?: AdminUIAddonCtor
-    }
-    return mod.AdminUIAddon ?? null
-  } catch {
-    return null
-  }
-}
-
-function createMockLogger(): IScopedLogger {
-  const logger: IScopedLogger = {
-    error: vi.fn(),
-    warn: vi.fn(),
-    info: vi.fn(),
-    debug: vi.fn(),
-    child: vi.fn(() => logger),
-  }
-  return logger
-}
-
-describe('Addon Pages Integration', () => {
-  it('BenchmarkAddon registers addon-pages capability and provides page list', async () => {
-    const { BenchmarkAddon } = await import('@camstack/addon-benchmark')
-    const addon = new BenchmarkAddon()
-
-    // Addon has id directly — manifest is attached by AddonLoader at boot time
-    expect(addon.id).toBe('benchmark')
-
-    // Initialize with a mock context to capture registered providers.
-    // Addons may register providers either via context.registerProvider() or
-    // by returning AddonInitResult / ProviderRegistration[] from initialize().
-    const providers = new Map<string, unknown>()
-    const mockContext = {
-      registerProvider: (capName: string, provider: unknown) => {
-        providers.set(capName, provider)
-      },
-    }
-    const result = await addon.initialize(mockContext as any)
-    // Process return-value registrations (AddonInitResult.providers or ProviderRegistration[])
-    if (result) {
-      const regs = Array.isArray(result) ? result : ((result as any).providers ?? [])
-      for (const reg of regs as ProviderRegistration[]) {
-        const capName =
-          typeof reg.capability === 'string'
-            ? reg.capability
-            : ((reg.capability as any)?.name ?? String(reg.capability))
-        providers.set(capName, reg.provider)
-      }
-    }
-
-    const provider = providers.get('addon-pages') as { getPages(): unknown[] } | undefined
-    expect(provider).toBeDefined()
-
-    const pages = provider!.getPages()
-    expect(pages).toHaveLength(1)
-
-    expect(pages[0]).toMatchObject({
-      id: 'benchmark',
-      label: 'Benchmark',
-      icon: 'gauge',
-      path: '/addon/benchmark',
-    })
-  })
-
-  it('AdminUIAddon provides admin-ui capability with static dir and version', async () => {
-    // Load `@camstack/addon-admin-ui/server/addon` lazily — the package exports
-    // a dist/server path that may not exist when the backend workspace is
-    // built in isolation (admin-ui has its own Vite-based build). Wrapping the
-    // dynamic import in a helper means the test can be typed cleanly without
-    // `@ts-expect-error`: when the module is absent we skip instead of
-    // leaking `any` into the rest of the spec.
-    const AdminUIAddonCtor = await loadAdminUIAddon()
-    if (!AdminUIAddonCtor) {
-      console.warn('[addon-pages-e2e] Skipping AdminUIAddon test — module not built')
-      return
-    }
-
-    const addon = new AdminUIAddonCtor()
-    expect(addon.id).toBe('admin-ui')
-
-    const providers = new Map<string, unknown>()
-    const mockContext = {
-      registerProvider: (capName: string, provider: unknown) => {
-        providers.set(capName, provider)
-      },
-    }
-    const result = await addon.initialize(mockContext as any)
-    // Process return-value registrations (AddonInitResult.providers or ProviderRegistration[])
-    if (result) {
-      const regs = Array.isArray(result) ? result : ((result as any).providers ?? [])
-      for (const reg of regs as ProviderRegistration[]) {
-        const capName =
-          typeof reg.capability === 'string'
-            ? reg.capability
-            : ((reg.capability as any)?.name ?? String(reg.capability))
-        providers.set(capName, reg.provider)
-      }
-    }
-
-    const ui = providers.get('admin-ui') as
-      | {
-          getStaticDir(): Promise<{ readonly staticDir: string }>
-          getVersion(): Promise<{ readonly version: string }>
-        }
-      | undefined
-    expect(ui).toBeDefined()
-    expect(typeof ui!.getStaticDir).toBe('function')
-    expect(typeof ui!.getVersion).toBe('function')
-    const version = await ui!.getVersion()
-    expect(version.version).toBe('0.1.0')
-  })
-
-  it('CapabilityRegistry wires addon-pages collection providers correctly', () => {
-    const registry = new CapabilityRegistry(createMockLogger())
-    registry.ready()
-
-    registry.declareCapability({
-      name: 'addon-pages',
-      scope: 'system',
-      mode: 'collection',
-      methods: {},
-    })
-
-    registry.registerProvider('addon-pages', 'benchmark', {
-      id: 'benchmark',
-      getPages: () => [
-        {
-          id: 'benchmark',
-          label: 'Benchmark',
-          icon: 'gauge',
-          path: '/addon/benchmark',
-          bundle: 'dist/pages/benchmark.js',
-          element: 'camstack-benchmark',
-        },
-      ],
-    })
-
-    const providers = registry.getCollection<{ getPages(): unknown[] }>('addon-pages')
-    expect(providers).toHaveLength(1)
-    expect(providers[0].getPages()).toHaveLength(1)
-  })
-
-  it('CapabilityRegistry wires admin-ui singleton correctly', async () => {
-    const registry = new CapabilityRegistry(createMockLogger())
-    registry.ready()
-
-    registry.declareCapability({
-      name: 'admin-ui',
-      scope: 'system',
-      mode: 'singleton',
-      methods: {},
-    })
-
-    registry.registerProvider('admin-ui', 'admin-ui', {
-      getStaticDir: async () => ({ staticDir: '/some/path/dist' }),
-      getVersion: async () => ({ version: '0.1.0' }),
-    })
-
-    const ui = registry.getSingleton<{ getVersion(): Promise<{ readonly version: string }> }>(
-      'admin-ui',
-    )
-    expect(ui).toBeDefined()
-    const version = await ui!.getVersion()
-    expect(version.version).toBe('0.1.0')
-  })
-})

package/src/__tests__/addon-route-session.test.ts

@@ -1,17 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { shouldRedirectToLogin } from '../auth/session-cookie.js'
-
-describe('shouldRedirectToLogin', () => {
-  it('true for an HTML GET with no credentials', () => {
-    expect(shouldRedirectToLogin('GET', 'text/html,application/xhtml+xml')).toBe(true)
-  })
-  it('false for a non-GET', () => {
-    expect(shouldRedirectToLogin('POST', 'text/html')).toBe(false)
-  })
-  it('false for an API GET (JSON accept)', () => {
-    expect(shouldRedirectToLogin('GET', 'application/json')).toBe(false)
-  })
-  it('false when Accept is absent', () => {
-    expect(shouldRedirectToLogin('GET', undefined)).toBe(false)
-  })
-})

package/src/__tests__/addon-settings-router.spec.ts

@@ -1,67 +0,0 @@
-/* eslint-disable @typescript-eslint/consistent-type-assertions -- test mock typing */
-import { describe, it, expect, beforeEach } from 'vitest'
-import { createAddonSettingsRouter } from '../api/core/addon-settings.router.js'
-import { makeCtx } from './cap-routers/harness.js'
-
-function createMockConfigService() {
-  const addonStore = new Map<string, Record<string, unknown>>()
-  const deviceStore = new Map<string, Record<string, unknown>>()
-
-  return {
-    getAddonConfig: (id: string) => addonStore.get(id) ?? {},
-    setAddonConfig: (id: string, v: Record<string, unknown>) => {
-      addonStore.set(id, v)
-    },
-    getAddonDevice: (id: string, devId: string) => deviceStore.get(`${id}:${devId}`) ?? {},
-    setAddonDevice: (id: string, devId: string, v: Record<string, unknown>) => {
-      deviceStore.set(`${id}:${devId}`, v)
-    },
-    // Cast to satisfy the ConfigService type expected by the router factory.
-    // Only the four methods above are exercised by the router.
-  } as Parameters<typeof createAddonSettingsRouter>[0]
-}
-
-describe('addon-settings router', () => {
-  let caller: ReturnType<ReturnType<typeof createAddonSettingsRouter>['createCaller']>
-
-  beforeEach(() => {
-    const cfg = createMockConfigService()
-    const router = createAddonSettingsRouter(cfg)
-    const ctx = makeCtx('admin')
-    caller = router.createCaller(ctx)
-  })
-
-  it('getGlobal returns empty object when no stored config', async () => {
-    const result = await caller.getGlobal({ addonId: 'my-addon' })
-    expect(result).toEqual({})
-  })
-
-  it('updateGlobal stores a field and getGlobal reflects it', async () => {
-    await caller.updateGlobal({ addonId: 'my-addon', field: 'threshold', value: 42 })
-    const result = await caller.getGlobal({ addonId: 'my-addon' })
-    expect(result).toEqual({ threshold: 42 })
-  })
-
-  it('getDeviceOverrides returns empty object when no stored overrides', async () => {
-    const result = await caller.getDeviceOverrides({ addonId: 'my-addon', deviceId: 'cam-1' })
-    expect(result).toEqual({})
-  })
-
-  it('updateDevice stores a field and getDeviceOverrides reflects it', async () => {
-    await caller.updateDevice({
-      addonId: 'my-addon',
-      deviceId: 'cam-1',
-      field: 'resolution',
-      value: '1080p',
-    })
-    const result = await caller.getDeviceOverrides({ addonId: 'my-addon', deviceId: 'cam-1' })
-    expect(result).toEqual({ resolution: '1080p' })
-  })
-
-  it('updateGlobal merges with existing config without overwriting other fields', async () => {
-    await caller.updateGlobal({ addonId: 'my-addon', field: 'alpha', value: 1 })
-    await caller.updateGlobal({ addonId: 'my-addon', field: 'beta', value: 2 })
-    const result = await caller.getGlobal({ addonId: 'my-addon' })
-    expect(result).toEqual({ alpha: 1, beta: 2 })
-  })
-})