@camstack/server 1.0.0 → 1.0.1

package/src/manual-boot.ts

@@ -1,301 +0,0 @@
-/**
- * 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.
- */
-
-import Fastify from 'fastify'
-import type { FastifyInstance } from 'fastify'
-import type { InfraContext } from './boot/boot-config'
-
-import { ConfigService } from './core/config/config.service'
-import { LoggingService } from './core/logging/logging.service'
-import { EventBusService } from './core/events/event-bus.service'
-import { StorageService } from './core/storage/storage.service'
-import { CapabilityService } from './core/capability/capability.service'
-import { FeatureService } from './core/feature/feature.service'
-import { AuthService } from './core/auth/auth.service'
-import { StreamProbeService } from './core/streaming/stream-probe.service'
-import { NetworkQualityService } from './core/network/network-quality.service'
-import { ToastServiceWrapper } from './core/notification/toast-wrapper.service'
-import { NotificationServiceWrapper } from './core/notification/notification-wrapper.service'
-import { AddonPagesService } from './core/addon-pages/addon-pages.service'
-import { AddonWidgetsService } from './core/addon-widgets/addon-widgets.service'
-import { AddonBridgeService } from './core/addon-bridge/addon-bridge.service'
-import { MoleculerService } from './core/moleculer/moleculer.service'
-import { AgentRegistryService } from './core/agent/agent-registry.service'
-import { AddonRegistryService } from './core/addon/addon-registry.service'
-import { AddonSearchService } from './core/addon/addon-search.service'
-import { AddonPackageService } from './core/addon/addon-package.service'
-import { ReplEngineService } from './core/repl/repl-engine.service'
-import { TopologyEmitterService } from './core/topology/topology-emitter.service'
-import { PostBootService } from './boot/post-boot.service'
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-type AnyCtor<T> = abstract new (...args: never[]) => T
-
-export interface BootedApp {
-  /** Resolve a service by its constructor. Throws if unregistered. */
-  get<T>(ctor: AnyCtor<T>): T
-  /** Returns the Fastify instance for plugin registration. */
-  getHttpAdapter(): { getInstance(): FastifyInstance }
-  /** Register a permissive CORS hook (allow all origins). */
-  enableCors(): void
-  /** Register SIGTERM/SIGINT → close() for graceful shutdown. */
-  enableShutdownHooks(): void
-  /** Run OnModuleInit hooks in the order Nest's dependency graph produces. */
-  init(): Promise<void>
-  /** Start the Fastify HTTP server. */
-  listen(port: number, host: string): Promise<void>
-  /** Run OnModuleDestroy hooks in reverse init order, then close Fastify. */
-  close(): Promise<void>
-}
-
-interface BootOptions {
-  infra: InfraContext
-  fastifyOpts: Record<string, unknown>
-}
-
-// ---------------------------------------------------------------------------
-// Service container — narrowing via `instanceof`, no casts.
-// ---------------------------------------------------------------------------
-
-class ServiceContainer {
-  private readonly services = new Map<unknown, unknown>()
-
-  register<T extends object>(ctor: AnyCtor<T>, instance: T): void {
-    this.services.set(ctor, instance)
-  }
-
-  get<T>(ctor: AnyCtor<T>): T {
-    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
-// ---------------------------------------------------------------------------
-
-export async function bootManual(opts: BootOptions): Promise<BootedApp> {
-  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 ConfigService(configPath)
-  const storageService = new StorageService()
-  const capabilityService = new CapabilityService()
-  const networkQualityService = new NetworkQualityService()
-  const toastWrapper = new ToastServiceWrapper()
-
-  // ---- Layer 1: need ConfigService / LoggingService -----------------------
-  const loggingService = new LoggingService(configService)
-  const eventBusService = new 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 FeatureService(configService)
-  const authService = new AuthService(configService)
-  const streamProbeService = new StreamProbeService(loggingService)
-  const addonBridgeService = new AddonBridgeService(loggingService)
-  const addonSearchService = new AddonSearchService(loggingService)
-
-  // ---- Layer 2: need Layer 0/1 -------------------------------------------
-  const notificationWrapper = new NotificationServiceWrapper(capabilityService, loggingService)
-  const addonPagesService = new AddonPagesService(loggingService, configService, capabilityService)
-  const moleculerService = new MoleculerService(
-    eventBusService,
-    configService,
-    loggingService,
-    capabilityService,
-    streamProbeService,
-  )
-
-  // ---- Layer 3: need Moleculer / AddonRegistry ---------------------------
-  const agentRegistryService = new AgentRegistryService(
-    eventBusService,
-    moleculerService,
-    capabilityService,
-  )
-  const addonRegistryService = new 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 AddonWidgetsService(
-    loggingService,
-    capabilityService,
-    addonRegistryService,
-  )
-  const addonPackageService = new AddonPackageService(
-    loggingService,
-    eventBusService,
-    configService,
-    addonRegistryService,
-    notificationWrapper,
-    toastWrapper,
-  )
-  const replEngineService = new ReplEngineService(
-    addonRegistryService,
-    eventBusService,
-    loggingService,
-  )
-  const topologyEmitterService = new TopologyEmitterService(
-    eventBusService,
-    agentRegistryService,
-    addonRegistryService,
-  )
-  const postBootService = new PostBootService(addonRegistryService, eventBusService, loggingService)
-
-  // ---- Container ---------------------------------------------------------
-  const container = new ServiceContainer()
-  container.register(ConfigService, configService)
-  container.register(LoggingService, loggingService)
-  container.register(EventBusService, eventBusService)
-  container.register(StorageService, storageService)
-  container.register(CapabilityService, capabilityService)
-  container.register(FeatureService, featureService)
-  container.register(AuthService, authService)
-  container.register(StreamProbeService, streamProbeService)
-  container.register(NetworkQualityService, networkQualityService)
-  container.register(ToastServiceWrapper, toastWrapper)
-  container.register(NotificationServiceWrapper, notificationWrapper)
-  container.register(AddonPagesService, addonPagesService)
-  container.register(AddonWidgetsService, addonWidgetsService)
-  container.register(AddonBridgeService, addonBridgeService)
-  container.register(MoleculerService, moleculerService)
-  container.register(AgentRegistryService, agentRegistryService)
-  container.register(AddonRegistryService, addonRegistryService)
-  container.register(AddonSearchService, addonSearchService)
-  container.register(AddonPackageService, addonPackageService)
-  container.register(ReplEngineService, replEngineService)
-  container.register(TopologyEmitterService, topologyEmitterService)
-  container.register(PostBootService, postBootService)
-
-  // ---- Fastify instance --------------------------------------------------
-  const fastify = Fastify(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 (): Promise<void> => {
-    if (closed) return
-    closed = true
-    const logErr = (label: string, err: unknown): void => {
-      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<T>(ctor: AnyCtor<T>): T {
-      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 = (): void => {
-        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/tsconfig.build.json

@@ -1,8 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "src"
-  },
-  "include": ["src"],
-  "exclude": ["src/scripts", "src/__tests__", "src/**/__tests__", "src/**/*.spec.ts", "src/**/*.test.ts"]
-}

package/tsconfig.json

@@ -1,33 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "target": "ES2023",
-    "module": "CommonJS",
-    "moduleResolution": "node",
-    "lib": [
-      "ES2023"
-    ],
-    "strict": true,
-    "esModuleInterop": true,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
-    "declaration": false,
-    "resolveJsonModule": true,
-    "skipLibCheck": true,
-    "types": [
-      "node"
-    ],
-    "baseUrl": "../..",
-    "ignoreDeprecations": "6.0",
-    "noEmit": true
-  },
-  "include": [
-    "src"
-  ],
-  "exclude": [
-    "src/scripts",
-    "src/**/__tests__",
-    "src/**/*.spec.ts",
-    "src/**/*.test.ts"
-  ]
-}

package/vitest.config.ts

@@ -1,26 +0,0 @@
-import { defineConfig } from 'vitest/config'
-import swc from 'unplugin-swc'
-
-export default defineConfig({
-  test: {
-    globals: true,
-    root: './src',
-    // Use threads pool (default) - inherits env vars
-    fileParallelism: false,
-    // Exclude e2e/smoke tests — they boot the full server and hang in CI
-    exclude: [
-      '**/*.e2e.test.ts',
-      '**/*e2e*.test.ts',
-      '**/*smoke*.test.ts',
-      '**/*diagnostic*.test.ts',
-      '**/*scale*.test.ts',
-      '**/node_modules/**',
-    ],
-    testTimeout: 30_000,
-    teardownTimeout: 5_000,
-    hookTimeout: 10_000,
-    // Use forks pool to isolate tests in separate processes (prevents hanging from open handles)
-    pool: 'forks',
-  },
-  plugins: [swc.vite({ module: { type: 'es6' } })],
-})