@camstack/server 0.1.3

package/.env.example

@@ -0,0 +1,17 @@
+# CamStack Server Environment
+# Copy to .env and customize. Loaded via Node.js --env-file flag.
+
+# Fixed JWT secret (prevents token invalidation on server restart)
+# Generate with: node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
+CAMSTACK_JWT_SECRET=
+
+# Admin credentials
+CAMSTACK_ADMIN_USER=admin
+CAMSTACK_ADMIN_PASS=changeme
+
+# Data directory (default: camstack-data)
+# CAMSTACK_DATA=camstack-data
+
+# Server port and host
+# CAMSTACK_PORT=4443
+# CAMSTACK_HOST=0.0.0.0

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@camstack/server",
+  "version": "0.1.3",
+  "private": false,
+  "exports": {
+    "./package.json": "./package.json",
+    "./main.js": "./dist/main.js",
+    "./launcher.js": "./dist/launcher.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "npx concurrently -n server,ui -c blue,magenta \"tsx watch --env-file=.env --ignore=./camstack-data src/launcher.ts\" \"cd ../../packages/addon-admin-ui && npx vite --port 3001\"",
+    "serve": "tsx watch --env-file=.env --ignore=./camstack-data src/launcher.ts",
+    "serve:once": "tsx --env-file=.env src/launcher.ts",
+    "start": "node --env-file=.env dist/launcher.js",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --reporter verbose",
+    "test:watch": "vitest"
+  },
+  "dependencies": {
+    "@camstack/addon-admin-ui": "*",
+    "@camstack/addon-advanced-notifier": "*",
+    "@camstack/addon-benchmark": "*",
+    "@camstack/addon-pipeline": "*",
+    "@camstack/addon-pipeline-orchestrator": "*",
+    "@camstack/addon-post-analysis": "*",
+    "@camstack/core": "*",
+    "@camstack/kernel": "*",
+    "@camstack/sdk": "*",
+    "@camstack/shm-ring": "*",
+    "@camstack/types": "*",
+    "@camstack/ui-library": "*",
+    "@fastify/cookie": "^11.0.2",
+    "@fastify/multipart": "^9.0.0",
+    "@fastify/static": "^8.0.0",
+    "@trpc/server": "^11.16.0",
+    "fastify": "^5",
+    "js-yaml": "^4",
+    "moleculer": "^0.15.0",
+    "tar": "^6.2.1",
+    "ws": "^8.20.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@swc/core": "^1.15.18",
+    "@types/js-yaml": "^4",
+    "@types/node": "^22",
+    "@types/tar": "^6.1.13",
+    "@types/ws": "^8.18.1",
+    "tsx": "^4",
+    "typescript": "^5.7",
+    "unplugin-swc": "^1.5.9",
+    "vitest": "*"
+  }
+}

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

@@ -0,0 +1,75 @@
+// 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

@@ -0,0 +1,178 @@
+/* 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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,62 @@
+/* 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 })
+  })
+})