@camstack/server 0.1.3

package/src/manual-boot.ts

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

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

package/tsconfig.json

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

package/vitest.config.ts

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