@camstack/server 0.1.3

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

@@ -0,0 +1,103 @@
+import { randomUUID } from 'node:crypto'
+import { readPendingRestart } from '@camstack/kernel'
+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: 'system.boot',
+      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: 'system.restart-completed',
+      data: payload,
+    })
+  }
+}

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

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