@camstack/server 1.0.0 → 1.0.1

package/src/__tests__/framework-allowlist.spec.ts

@@ -1,96 +0,0 @@
-/**
- * Framework package allow-list coherence.
- *
- * Spec: docs/superpowers/specs/2026-05-14-framework-live-update-design.md
- *
- * Invariants:
- *   - Every entry in `FRAMEWORK_PACKAGE_ALLOWLIST` resolves to a workspace
- *     package whose `package.json` declares `camstack.system: true`.
- *   - Every workspace package with `camstack.system: true` appears in the
- *     allow-list — drift in either direction breaks live-update.
- *   - `isFrameworkPackage` accepts framework names and rejects everything
- *     else (sanity check on the gate the cap method uses).
- */
-import { describe, it, expect } from 'vitest'
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-import {
-  FRAMEWORK_PACKAGE_ALLOWLIST,
-  isFrameworkPackage,
-} from '../core/addon/addon-package.service.js'
-
-function repoRoot(): string {
-  return path.resolve(__dirname, '..', '..', '..', '..')
-}
-
-interface PackageJsonView {
-  readonly name: string
-  readonly system: boolean
-  readonly path: string
-}
-
-function readPackageJson(pkgJsonPath: string): PackageJsonView | null {
-  try {
-    const raw: unknown = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'))
-    if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) return null
-    const obj = raw as Record<string, unknown>
-    const name = obj['name']
-    if (typeof name !== 'string') return null
-    const camstack = obj['camstack']
-    const isSystem =
-      camstack !== null &&
-      typeof camstack === 'object' &&
-      !Array.isArray(camstack) &&
-      (camstack as Record<string, unknown>)['system'] === true
-    return { name, system: isSystem, path: pkgJsonPath }
-  } catch {
-    return null
-  }
-}
-
-function discoverWorkspacePackages(): readonly PackageJsonView[] {
-  const packagesDir = path.join(repoRoot(), 'packages')
-  if (!fs.existsSync(packagesDir)) return []
-  const results: PackageJsonView[] = []
-  for (const entry of fs.readdirSync(packagesDir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue
-    const pkgJson = path.join(packagesDir, entry.name, 'package.json')
-    if (!fs.existsSync(pkgJson)) continue
-    const view = readPackageJson(pkgJson)
-    if (view !== null) results.push(view)
-  }
-  return results
-}
-
-describe('framework package allow-list — manifest parity', () => {
-  it('every allow-listed package exists in `packages/` with camstack.system: true', () => {
-    const pkgs = discoverWorkspacePackages()
-    for (const name of FRAMEWORK_PACKAGE_ALLOWLIST) {
-      const match = pkgs.find((p) => p.name === name)
-      expect(match, `expected ${name} in packages/`).toBeDefined()
-      expect(match?.system, `${name} must declare camstack.system: true`).toBe(true)
-    }
-  })
-
-  it('every workspace package with camstack.system: true is in the allow-list', () => {
-    const systemPkgs = discoverWorkspacePackages().filter((p) => p.system)
-    const allowSet = new Set(FRAMEWORK_PACKAGE_ALLOWLIST)
-    const orphans = systemPkgs.filter((p) => !allowSet.has(p.name))
-    expect(orphans.map((p) => p.name)).toEqual([])
-  })
-})
-
-describe('isFrameworkPackage', () => {
-  it('returns true for every allow-listed package', () => {
-    for (const name of FRAMEWORK_PACKAGE_ALLOWLIST) {
-      expect(isFrameworkPackage(name)).toBe(true)
-    }
-  })
-
-  it('returns false for addons and unknown packages', () => {
-    expect(isFrameworkPackage('@camstack/addon-stream-broker')).toBe(false)
-    expect(isFrameworkPackage('left-pad')).toBe(false)
-    expect(isFrameworkPackage('')).toBe(false)
-    expect(isFrameworkPackage('@camstack')).toBe(false)
-  })
-})

package/src/__tests__/framework-installer-defer-restart.spec.ts

@@ -1,165 +0,0 @@
-/**
- * deferRestart flag on AddonPackageService.updateFrameworkPackage
- *
- * Spec: docs/superpowers/specs/2026-05-21-addons-bulk-update-progress-design.md
- *
- * Invariants:
- *   - deferRestart: true  → npm install runs normally; marker write AND
- *     scheduleSelfRestart are SKIPPED; restartingAt is 0 (sentinel).
- *   - deferRestart omitted (default) → marker write AND scheduleSelfRestart
- *     both fire; restartingAt > 0.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import * as os from 'node:os'
-import * as path from 'node:path'
-import * as fs from 'node:fs'
-import type { IScopedLogger } from '@camstack/types'
-
-// ── Module-level mocks ──────────────────────────────────────────────────────
-// Must be hoisted before any import that loads the module under test.
-// vi.mock is statically hoisted by vitest's transform, so the factories
-// run before the module graph is resolved.
-
-vi.mock('@camstack/kernel', async (importOriginal) => {
-  const real = await importOriginal<typeof import('@camstack/kernel')>()
-  return {
-    ...real,
-    scheduleSelfRestart: vi.fn(),
-    writePendingRestart: vi.fn(),
-    // resolveNpmVersion and resolveFrameworkPackageAppRoot are private module
-    // functions inside addon-package.service.ts — they are NOT exported from
-    // @camstack/kernel, so we don't need to stub them here.
-  }
-})
-
-// Mock node:child_process so no actual `npm install` / `npm view` is executed.
-vi.mock('node:child_process', async (importOriginal) => {
-  const real = await importOriginal<typeof import('node:child_process')>()
-  return {
-    ...real,
-    execFile: vi.fn(
-      (
-        _cmd: string,
-        _args: string[],
-        _opts: unknown,
-        callback: (err: null, result: { stdout: string; stderr: string }) => void,
-      ) => {
-        // Simulate `npm view @camstack/types@0.1.40 version` → '0.1.40'
-        callback(null, { stdout: '0.1.40\n', stderr: '' })
-        return { kill: () => undefined }
-      },
-    ),
-  }
-})
-
-// ── Imports that depend on the mocked modules ───────────────────────────────
-import { scheduleSelfRestart, writePendingRestart } from '@camstack/kernel'
-import { AddonPackageService } from '../core/addon/addon-package.service.js'
-import { EventCategory } from '@camstack/types'
-
-// ── Helpers ──────────────────────────────────────────────────────────────────
-
-function makeLogger(): IScopedLogger {
-  const logger: IScopedLogger = {
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    debug: vi.fn(),
-    trace: vi.fn(),
-    fatal: vi.fn(),
-    child: (() => logger) as IScopedLogger['child'],
-  } as unknown as IScopedLogger
-  return logger
-}
-
-interface ServiceEnv {
-  readonly service: AddonPackageService
-  readonly tmpDir: string
-  readonly scheduleSelfRestartMock: ReturnType<typeof vi.fn>
-  readonly writePendingRestartMock: ReturnType<typeof vi.fn>
-}
-
-function createEnv(): ServiceEnv {
-  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'defer-restart-spec-'))
-
-  const logger = makeLogger()
-
-  const loggingService = {
-    createLogger: () => logger,
-  }
-
-  const eventBusService = {
-    emit: vi.fn(),
-  }
-
-  const configService = {}
-  const addonRegistry = {}
-  const notificationService = {}
-  const toastService = {}
-
-  const service = new AddonPackageService(
-    loggingService as never,
-    eventBusService as never,
-    configService as never,
-    addonRegistry as never,
-    notificationService as never,
-    toastService as never,
-  )
-
-  // Point the framework-package app-root resolver at our tmp dir so
-  // `npm install --prefix <appRoot>` (which is mocked anyway) has a
-  // valid-looking path without requiring the real workspace layout.
-  process.env['CAMSTACK_FRAMEWORK_APP_ROOT_OVERRIDE'] = tmpDir
-
-  return {
-    service,
-    tmpDir,
-    scheduleSelfRestartMock: scheduleSelfRestart as ReturnType<typeof vi.fn>,
-    writePendingRestartMock: writePendingRestart as ReturnType<typeof vi.fn>,
-  }
-}
-
-// ── Tests ────────────────────────────────────────────────────────────────────
-
-describe('AddonPackageService.updateFrameworkPackage — deferRestart flag', () => {
-  let env: ServiceEnv
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-    env = createEnv()
-  })
-
-  afterEach(() => {
-    fs.rmSync(env.tmpDir, { recursive: true, force: true })
-    delete process.env['CAMSTACK_FRAMEWORK_APP_ROOT_OVERRIDE']
-    vi.restoreAllMocks()
-  })
-
-  it('skips restart seam (writePendingRestart + scheduleSelfRestart) when deferRestart is true', async () => {
-    const result = await env.service.updateFrameworkPackage({
-      packageName: '@camstack/types',
-      version: '0.1.40',
-      deferRestart: true,
-    })
-
-    expect(env.writePendingRestartMock).not.toHaveBeenCalled()
-    expect(env.scheduleSelfRestartMock).not.toHaveBeenCalled()
-    expect(result.packageName).toBe('@camstack/types')
-    expect(result.toVersion).toBe('0.1.40')
-    // Sentinel: 0 signals "no restart scheduled"
-    expect(result.restartingAt).toBe(0)
-  })
-
-  it('fires writePendingRestart + scheduleSelfRestart when deferRestart is omitted', async () => {
-    const result = await env.service.updateFrameworkPackage({
-      packageName: '@camstack/types',
-      version: '0.1.40',
-    })
-
-    expect(env.writePendingRestartMock).toHaveBeenCalledOnce()
-    expect(env.scheduleSelfRestartMock).toHaveBeenCalledOnce()
-    expect(result.packageName).toBe('@camstack/types')
-    expect(result.toVersion).toBe('0.1.40')
-    expect(result.restartingAt).toBeGreaterThan(0)
-  })
-})

package/src/__tests__/https-e2e.test.ts

@@ -1,124 +0,0 @@
-/**
- * HTTPS E2E tests — verify self-signed cert generation, HTTPS serving, and WSS agent connection.
- */
-import { describe, it, expect, beforeAll, afterAll } from 'vitest'
-import * as fs from 'node:fs'
-import * as path from 'node:path'
-import * as os from 'node:os'
-import * as https from 'node:https'
-import { X509Certificate } from 'node:crypto'
-// Import directly from source submodule because vitest+swc doesn't resolve
-// `export * from './tls/index.js'` barrel re-exports in the @camstack/core index.
-import { ensureTlsCert, loadTlsCert } from '../../../../packages/core/src/tls/cert-manager'
-
-describe('HTTPS E2E', () => {
-  let tmpDir: string
-
-  beforeAll(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'camstack-https-e2e-'))
-  })
-
-  afterAll(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true })
-  })
-
-  it('generates a valid self-signed cert on first call', async () => {
-    const result = await ensureTlsCert(tmpDir)
-    expect(result.generated).toBe(true)
-
-    // Verify cert file is valid PEM
-    const certPem = fs.readFileSync(result.certPath, 'utf-8')
-    expect(certPem).toContain('-----BEGIN CERTIFICATE-----')
-
-    // Parse and validate
-    const x509 = new X509Certificate(certPem)
-    expect(x509.subject).toContain('CN=camstack.local')
-
-    // Check SAN includes localhost
-    const san = x509.subjectAltName ?? ''
-    expect(san).toContain('DNS:localhost')
-    expect(san).toContain('IP Address:127.0.0.1')
-
-    // Check validity (at least 1 year)
-    const validTo = new Date(x509.validTo)
-    const oneYear = new Date()
-    oneYear.setFullYear(oneYear.getFullYear() + 1)
-    expect(validTo.getTime()).toBeGreaterThan(oneYear.getTime() - 86400000)
-  })
-
-  it('reuses existing cert on subsequent calls', async () => {
-    const first = await ensureTlsCert(tmpDir)
-    const second = await ensureTlsCert(tmpDir)
-    expect(second.generated).toBe(false)
-
-    const cert1 = fs.readFileSync(first.certPath, 'utf-8')
-    const cert2 = fs.readFileSync(second.certPath, 'utf-8')
-    expect(cert1).toBe(cert2)
-  })
-
-  it('serves HTTPS with the generated cert', async () => {
-    const { certPath, keyPath } = await ensureTlsCert(tmpDir)
-    const { cert, key } = loadTlsCert(certPath, keyPath)
-
-    const server = https.createServer({ cert, key }, (_req, res) => {
-      res.writeHead(200, { 'Content-Type': 'text/plain' })
-      res.end('camstack-ok')
-    })
-
-    const port = 10000 + Math.floor(Math.random() * 50000)
-    await new Promise<void>((resolve) => server.listen(port, '127.0.0.1', resolve))
-
-    try {
-      const body = await new Promise<string>((resolve, reject) => {
-        const req = https.request(
-          { hostname: '127.0.0.1', port, path: '/', method: 'GET', rejectUnauthorized: false },
-          (res) => {
-            let data = ''
-            res.on('data', (c) => {
-              data += c
-            })
-            res.on('end', () => resolve(data))
-          },
-        )
-        req.on('error', reject)
-        req.end()
-      })
-
-      expect(body).toBe('camstack-ok')
-    } finally {
-      server.close()
-    }
-  })
-
-  it('TLS disabled falls back to HTTP', async () => {
-    // When tls.enabled = false, server should work over plain HTTP
-    // This is a config-level test, verified by checking that FastifyAdapter
-    // receives no https options when tls is disabled
-    const http = await import('node:http')
-    const server = http.createServer((_req, res) => {
-      res.writeHead(200)
-      res.end('http-ok')
-    })
-
-    const port = 10000 + Math.floor(Math.random() * 50000)
-    await new Promise<void>((resolve) => server.listen(port, '127.0.0.1', resolve))
-
-    try {
-      const body = await new Promise<string>((resolve, reject) => {
-        http
-          .get(`http://127.0.0.1:${port}/`, (res) => {
-            let data = ''
-            res.on('data', (c) => {
-              data += c
-            })
-            res.on('end', () => resolve(data))
-          })
-          .on('error', reject)
-      })
-
-      expect(body).toBe('http-ok')
-    } finally {
-      server.close()
-    }
-  })
-})

package/src/__tests__/lifecycle-e2e.test.ts

@@ -1,189 +0,0 @@
-import { describe, it, expect, vi } from 'vitest'
-import { CapabilityRegistry, isInfraCapability } from '@camstack/kernel'
-import type { IScopedLogger } from '@camstack/types'
-
-// ─── Mock helpers ────────────────────────────────────────────────────
-//
-// PipelineOrchestrator phase-transition + result-flow tests used to live
-// in this file (importing from the now-deleted server/backend/src/core/
-// orchestrator/ directory). They have been migrated into the runner package
-// (`packages/addon-pipeline-runner/src/__tests__/runner.spec.ts`) which
-// is the canonical home of the scheduler core.
-
-function createMockLogger(): IScopedLogger {
-  return {
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    debug: vi.fn(),
-  } as unknown as IScopedLogger
-}
-
-function createRegistry(configReader?: (cap: string) => string | undefined): CapabilityRegistry {
-  const registry = new CapabilityRegistry(createMockLogger())
-  if (configReader) {
-    registry.setConfigReader(configReader)
-  }
-  registry.ready()
-  return registry
-}
-
-// ─── Tests ────────────────────────────────────────────────────────────
-
-describe('Full Lifecycle E2E (mock, no external services)', () => {
-  describe('CapabilityRegistry boot sequence', () => {
-    it('registers singleton and collection capabilities correctly', () => {
-      const registry = createRegistry()
-
-      registry.declareCapability({
-        name: 'storage',
-        scope: 'system',
-        mode: 'singleton',
-        methods: {},
-      })
-      registry.declareCapability({
-        name: 'log-destination',
-        scope: 'system',
-        mode: 'collection',
-        methods: {},
-      })
-      registry.declareCapability({
-        name: 'streaming-engine',
-        scope: 'system',
-        mode: 'singleton',
-        methods: {},
-      })
-      registry.declareCapability({
-        name: 'analysis-pipeline',
-        scope: 'system',
-        mode: 'singleton',
-        methods: {},
-      })
-      registry.declareCapability({
-        name: 'device-provider',
-        scope: 'system',
-        mode: 'collection',
-        methods: {},
-      })
-      registry.declareCapability({
-        name: 'admin-ui',
-        scope: 'system',
-        mode: 'singleton',
-        methods: {},
-      })
-
-      const mockStorage = { id: 'sqlite' }
-      const mockLogger = { id: 'winston' }
-      const mockStreaming = { id: 'go2rtc' }
-      const mockAnalysis = { id: 'pipeline-analysis' }
-      const mockProvider = { id: 'frigate' }
-
-      registry.registerProvider('storage', 'sqlite-storage', mockStorage)
-      registry.registerProvider('log-destination', 'winston-logging', mockLogger)
-      registry.registerProvider('streaming-engine', 'go2rtc', mockStreaming)
-      registry.registerProvider('analysis-pipeline', 'pipeline-analysis', mockAnalysis)
-      registry.registerProvider('device-provider', 'provider-frigate', mockProvider)
-
-      expect(registry.getSingleton('storage')).toBe(mockStorage)
-      expect(registry.getCollection('log-destination')).toEqual([mockLogger])
-      expect(registry.getSingleton('streaming-engine')).toBe(mockStreaming)
-      expect(registry.getSingleton('analysis-pipeline')).toBe(mockAnalysis)
-      expect(registry.getCollection('device-provider')).toEqual([mockProvider])
-
-      const caps = registry.listCapabilities()
-      expect(caps.length).toBeGreaterThanOrEqual(5)
-    })
-
-    it('infra capabilities are identified correctly', () => {
-      expect(isInfraCapability('storage')).toBe(true)
-      expect(isInfraCapability('log-destination')).toBe(true)
-      expect(isInfraCapability('streaming-engine')).toBe(false)
-    })
-  })
-
-  // Note: PipelineOrchestrator phase transition + detection result flow tests
-  // moved to packages/addon-pipeline-runner/src/__tests__/runner.spec.ts
-  // when the scheduler was extracted into the addon-pipeline-runner package.
-
-  describe('Singleton swap', () => {
-    it('swapping analysis provider changes getSingleton result', async () => {
-      const registry = createRegistry()
-      registry.declareCapability({
-        name: 'analysis-pipeline',
-        scope: 'system',
-        mode: 'singleton',
-        methods: {},
-      })
-
-      const analysisA = { id: 'analysis-a', processFrame: vi.fn() }
-      const analysisB = { id: 'analysis-b', processFrame: vi.fn() }
-
-      registry.registerProvider('analysis-pipeline', 'addon-a', analysisA)
-      expect(registry.getSingleton('analysis-pipeline')).toBe(analysisA)
-
-      registry.registerProvider('analysis-pipeline', 'addon-b', analysisB)
-
-      await registry.setActiveSingleton('analysis-pipeline', 'addon-b', true)
-      expect(registry.getSingleton('analysis-pipeline')).toBe(analysisB)
-    })
-  })
-
-  describe('Collection capability add/remove', () => {
-    it('adding and removing device providers', () => {
-      const registry = createRegistry()
-      registry.declareCapability({
-        name: 'device-provider',
-        scope: 'system',
-        mode: 'collection',
-        methods: {},
-      })
-
-      const frigate = { id: 'frigate', type: 'frigate' }
-      const onvif = { id: 'onvif', type: 'onvif' }
-
-      registry.registerProvider('device-provider', 'addon-frigate', frigate)
-      expect(registry.getCollection('device-provider')).toHaveLength(1)
-
-      registry.registerProvider('device-provider', 'addon-onvif', onvif)
-      expect(registry.getCollection('device-provider')).toHaveLength(2)
-
-      registry.unregisterProvider('device-provider', 'addon-frigate')
-      expect(registry.getCollection('device-provider')).toHaveLength(1)
-    })
-  })
-
-  describe('Capability introspection', () => {
-    it('listCapabilities returns full info', () => {
-      const registry = createRegistry()
-      registry.declareCapability({
-        name: 'storage',
-        scope: 'system',
-        mode: 'singleton',
-        methods: {},
-      })
-      registry.declareCapability({
-        name: 'device-provider',
-        scope: 'system',
-        mode: 'collection',
-        methods: {},
-      })
-
-      registry.registerProvider('storage', 'sqlite', { id: 'sqlite' })
-      registry.registerProvider('device-provider', 'frigate', { id: 'frigate' })
-      registry.registerProvider('device-provider', 'onvif', { id: 'onvif' })
-
-      const caps = registry.listCapabilities()
-
-      const storage = caps.find((c) => c.name === 'storage')
-      expect(storage).toBeDefined()
-      expect(storage!.mode).toBe('singleton')
-      expect(storage!.providers).toContain('sqlite')
-      expect(storage!.activeProvider).toBe('sqlite')
-
-      const providers = caps.find((c) => c.name === 'device-provider')
-      expect(providers).toBeDefined()
-      expect(providers!.mode).toBe('collection')
-      expect(providers!.providers).toHaveLength(2)
-    })
-  })
-})