@camstack/server 0.2.2 → 1.0.1

package/src/boot/boot-config.ts

@@ -1,259 +0,0 @@
-/**
- * Phase 1: Bootstrap config loading and infrastructure setup.
- *
- * 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'
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-export type { BootstrapConfig }
-
-export interface InfraContext {
-  readonly bootstrapConfig: BootstrapConfig
-  readonly dataPath: string
-  readonly locationManager: StorageLocationManager
-  readonly tlsOptions: { key: Buffer; cert: Buffer } | undefined
-}
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-const CONFIG_DEFAULTS: Record<string, unknown> = {
-  server: { port: 4443, host: '0.0.0.0', dataPath: 'camstack-data' },
-  auth: {
-    jwtSecret: null,
-    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',
-}
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function setNested(
-  obj: Record<string, unknown>,
-  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) }
-}
-
-// ---------------------------------------------------------------------------
-// loadBootstrapConfig
-// ---------------------------------------------------------------------------
-
-/**
- * Load bootstrap config from a YAML file, apply env-var overrides, and
- * validate via the bootstrap Zod schema.
- */
-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>
-
-  if (fs.existsSync(configPath)) {
-    const content = fs.readFileSync(configPath, 'utf-8')
-    raw = asJsonObject(yaml.load(content)) ?? {}
-    // Merge in any missing bootstrap sections (server, auth only)
-    let updated = false
-    for (const [key, defaults] of Object.entries(CONFIG_DEFAULTS)) {
-      if (!(key in raw)) {
-        raw[key] = defaults
-        updated = true
-      }
-    }
-    if (updated) {
-      try {
-        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`)
-      } catch (err) {
-        console.warn(`[Phase1] Could not update config.yaml:`, err)
-      }
-    }
-    console.log(`[Phase1] Loaded bootstrap config from: ${configPath}`)
-  } else {
-    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.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}`)
-    } catch (err) {
-      console.warn(`[Phase1] Could not write default config.yaml:`, err)
-    }
-    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 coerced: unknown =
-      configPath_ === 'server.port'
-        ? Number(envValue)
-        : configPath_ === 'tls.enabled'
-          ? envValue === 'true'
-          : envValue
-    raw = setNested(raw, configPath_, coerced)
-    console.log(`[Phase1] Env override: ${envKey} → ${configPath_}`)
-  }
-
-  return bootstrapSchema.parse(raw)
-}
-
-// ---------------------------------------------------------------------------
-// autoGenerateJwtSecret
-// ---------------------------------------------------------------------------
-
-/**
- * If `jwtSecret` is null in the parsed config, generate a random secret,
- * persist it to the YAML file, and return an updated config.
- */
-export function autoGenerateJwtSecret(
-  configPath: string,
-  bootstrapConfig: BootstrapConfig,
-): BootstrapConfig {
-  if (bootstrapConfig.auth.jwtSecret !== null) {
-    return bootstrapConfig
-  }
-
-  const secret = randomBytes(32).toString('hex')
-  console.log('[Phase1] jwtSecret is null — auto-generating and writing to config.yaml')
-
-  let raw: Record<string, unknown> = {}
-  if (fs.existsSync(configPath)) {
-    raw = asJsonObject(yaml.load(fs.readFileSync(configPath, 'utf-8'))) ?? {}
-  }
-
-  const authSection = asJsonObject(raw.auth) ?? {}
-  raw.auth = { ...authSection, jwtSecret: secret }
-
-  const tmpPath = `${configPath}.tmp`
-  try {
-    fs.mkdirSync(path.dirname(configPath), { recursive: true })
-    fs.writeFileSync(
-      tmpPath,
-      yaml.dump(raw, { lineWidth: 120, indent: 2, quotingType: '"' }),
-      'utf-8',
-    )
-    fs.renameSync(tmpPath, configPath)
-  } catch (err) {
-    console.warn('[Phase1] Could not write auto-generated jwtSecret to config.yaml:', err)
-  }
-
-  return {
-    ...bootstrapConfig,
-    auth: { ...bootstrapConfig.auth, jwtSecret: secret },
-  }
-}
-
-// ---------------------------------------------------------------------------
-// setupInfra
-// ---------------------------------------------------------------------------
-
-/**
- * Phase 2: Create StorageLocationManager, ensure directories, configure TLS.
- * Returns the full InfraContext needed by subsequent boot phases.
- */
-export async function setupInfra(
-  configPath: string,
-  bootstrapConfig: BootstrapConfig,
-): Promise<InfraContext> {
-  // Auto-generate jwtSecret if not set
-  const config = autoGenerateJwtSecret(configPath, bootstrapConfig)
-
-  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}`)
-
-  // --- Phase 2: Init StorageLocationManager → ensure all dirs exist ---
-  console.log('[Phase2] Initializing storage locations…')
-  const locationManager = new StorageLocationManager(dataPath)
-  await locationManager.initializeDefaults()
-
-  const locationStatus = locationManager.getStatus()
-  for (const { name, available, path: locPath } of locationStatus) {
-    console.log(`[Phase2] Location "${name}": ${available ? 'OK' : 'UNAVAILABLE'} → ${locPath}`)
-  }
-
-  // --- Phase 2c: TLS certificate setup ---
-  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
-    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 }
-    } else {
-      // Auto-generate self-signed
-      const tlsResult = await ensureTlsCert(dataPath)
-      if (tlsResult.generated) {
-        console.log(`[Phase2c] Generated self-signed TLS cert at ${tlsResult.certPath}`)
-      } else {
-        console.log(`[Phase2c] Using existing TLS cert at ${tlsResult.certPath}`)
-      }
-      const pair = loadTlsCert(tlsResult.certPath, tlsResult.keyPath)
-      tlsOptions = { key: pair.key, cert: pair.cert }
-    }
-  }
-
-  return {
-    bootstrapConfig: config,
-    dataPath,
-    locationManager,
-    tlsOptions,
-  }
-}

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

@@ -1,109 +0,0 @@
-/**
- * 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,105 +0,0 @@
-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'
-import { LoggingService } from '../core/logging/logging.service'
-
-export interface PostBootContext {
-  readonly port: number
-  readonly host: string
-  readonly dataPath: string
-  readonly trpcRegistered: boolean
-}
-
-export class PostBootService {
-  private readonly logger: IScopedLogger
-
-  /**
-   * Holds the marker that fired `system.restart-completed` on this boot
-   * for `LAST_RESTART_RETENTION_MS`. Lets clients query the marker
-   * 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
-
-  /** How long the last-restart marker stays queryable after boot (5 min). */
-  static readonly LAST_RESTART_RETENTION_MS = 5 * 60_000
-
-  constructor(
-    _addonRegistry: AddonRegistryService,
-    private readonly eventBus: EventBusService,
-    loggingService: LoggingService,
-  ) {
-    this.logger = loggingService.createLogger('PostBoot')
-  }
-
-  /**
-   * Snapshot of the most-recent restart marker, or `null` after the
-   * retention window. The hub's `addons.getLastRestart` cap method
-   * delegates here.
-   */
-  static getLastRestart(): PendingRestartMarkerPayload | null {
-    const entry = PostBootService.lastRestart
-    if (entry === null) return null
-    if (entry.expiresAt <= Date.now()) {
-      PostBootService.lastRestart = null
-      return null
-    }
-    return entry.payload
-  }
-
-  async run(context: PostBootContext): Promise<void> {
-    const { port, host, dataPath, trpcRegistered } = context
-
-    // Device stream wiring moved into `addon-stream-broker` — the addon
-    // does its own initial sync against `ctx.deviceRegistry` plus listens
-    // to `DeviceRegistered` events for future registrations. No kernel
-    // orchestration shim needed here anymore.
-
-    // Emit system.boot event
-    this.eventBus.emit({
-      id: randomUUID(),
-      timestamp: new Date(),
-      source: { type: 'core', id: 'system' },
-      category: EventCategory.SystemBoot,
-      data: { port, host, trpcRegistered, dataPath },
-    })
-
-    // If the previous shutdown was driven by RestartCoordinator, emit a
-    // `system.restart-completed` event so the admin UI can surface a
-    // success toast describing what changed (framework update, manual
-    // restart, …). `readPendingRestart` clears the marker atomically so
-    // we never re-fire on a crash-loop boot.
-    this.emitRestartCompletedIfPending(dataPath)
-  }
-
-  private emitRestartCompletedIfPending(dataDir: string): void {
-    const marker = readPendingRestart(dataDir)
-    if (marker === null) return
-
-    const payload: PendingRestartMarkerPayload = {
-      kind: marker.kind,
-      requestedAt: marker.requestedAt,
-      ...(marker.packageName !== undefined ? { packageName: marker.packageName } : {}),
-      ...(marker.fromVersion !== undefined ? { fromVersion: marker.fromVersion } : {}),
-      ...(marker.toVersion !== undefined ? { toVersion: marker.toVersion } : {}),
-      ...(marker.requestedBy !== undefined ? { requestedBy: marker.requestedBy } : {}),
-    }
-
-    this.logger.info('Restart completed', { meta: payload })
-    PostBootService.lastRestart = {
-      payload,
-      expiresAt: Date.now() + PostBootService.LAST_RESTART_RETENTION_MS,
-    }
-    this.eventBus.emit({
-      id: randomUUID(),
-      timestamp: new Date(),
-      source: { type: 'core', id: 'system' },
-      category: EventCategory.SystemRestartCompleted,
-      data: payload,
-    })
-  }
-}

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

@@ -1,62 +0,0 @@
-// server/backend/src/core/addon/__tests__/addon-registry-capability.test.ts
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { CapabilityRegistry } from '@camstack/kernel'
-import type { IScopedLogger } from '@camstack/types'
-
-function createMockLogger(): IScopedLogger {
-  return {
-    error: vi.fn(),
-    warn: vi.fn(),
-    info: vi.fn(),
-    debug: vi.fn(),
-    child: vi.fn().mockReturnThis(),
-  }
-}
-
-describe('AddonRegistryService -- CapabilityRegistry integration', () => {
-  let registry: CapabilityRegistry
-
-  beforeEach(() => {
-    registry = new CapabilityRegistry(createMockLogger())
-    registry.ready()
-  })
-
-  it('singleton provider is available after registerProvider', () => {
-    registry.declareCapability({ name: 'storage', scope: 'system', mode: 'singleton', methods: {} })
-
-    const mockStorageProvider = { getLocation: vi.fn() }
-    registry.registerProvider('storage', 'sqlite-storage', mockStorageProvider)
-
-    expect(registry.getSingleton('storage')).toBe(mockStorageProvider)
-  })
-
-  it('streaming-engine singleton wired after provider registers', () => {
-    registry.declareCapability({
-      name: 'streaming-engine',
-      scope: 'system',
-      mode: 'singleton',
-      methods: {},
-    })
-
-    const mockEngine = { initialize: vi.fn() }
-    registry.registerProvider('streaming-engine', 'go2rtc', mockEngine)
-
-    expect(registry.getSingleton('streaming-engine')).toBe(mockEngine)
-  })
-
-  it('log-destination collection receives all providers', () => {
-    registry.declareCapability({
-      name: 'log-destination',
-      scope: 'system',
-      mode: 'collection',
-      methods: {},
-    })
-
-    const dest1 = { id: 'winston' }
-    const dest2 = { id: 'loki' }
-    registry.registerProvider('log-destination', 'winston-logging', dest1)
-    registry.registerProvider('log-destination', 'loki-logging', dest2)
-
-    expect(registry.getCollection('log-destination')).toEqual([dest1, dest2])
-  })
-})

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

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