OmniRoute/src/server-init.ts

// Server startup script
import initializeCloudSync from "./shared/services/initializeCloudSync";
import { enforceWebRuntimeEnv } from "./lib/env/runtimeEnv";
import { enforceSecrets } from "./shared/utils/secretsValidator";
import { initAuditLog, cleanupExpiredLogs, logAuditEvent } from "./lib/compliance/index";
import { initConsoleInterceptor } from "./lib/consoleInterceptor";
import { registerBudgetResetJob } from "./lib/jobs/budgetResetJob";
import { registerTokenHealthCheck } from "./lib/jobs/tokenHealthCheckJob";
import { startReasoningCacheCleanupJob } from "./lib/jobs/reasoningCacheCleanupJob";
import { startCleanupScheduler } from "./lib/db/cleanup";
import { getSettings } from "./lib/db/settings";
import { applyRuntimeSettings } from "./lib/config/runtimeSettings";
import { setSystemPromptConfig } from "@omniroute/open-sse/services/systemPrompt.ts";
import { hydrateThinkingBudgetConfig } from "@omniroute/open-sse/services/thinkingBudget.ts";
import { startRuntimeConfigHotReload } from "./lib/config/hotReload";
import { startSpendBatchWriter } from "./lib/spend/batchWriter";
import { registerDefaultGuardrails } from "./lib/guardrails";
import { ensurePersistentManagementPasswordHash } from "./lib/auth/managementPassword";
import { skillExecutor } from "./lib/skills/executor";
import { registerBuiltinSkills } from "./lib/skills/builtins";
import { createLogger } from "./shared/utils/logger";

const startupLog = createLogger("server-init");

function getErrorMessage(error: unknown) {
  return error instanceof Error ? error.message : String(error);
}

async function startServer() {
  // Trigger request-log layout migration during startup, before serving requests.
  await import("./lib/usage/migrations");

  // Console interceptor: capture all console output to log file (must be first)
  initConsoleInterceptor();

  // FASE-01: Validate required secrets before anything else (fail-fast)
  enforceSecrets();
  enforceWebRuntimeEnv();

  // Compliance: Initialize audit_log table
  try {
    initAuditLog();
    startupLog.info("Audit log table initialized");
  } catch (err) {
    startupLog.warn({ err }, "Could not initialize audit log");
  }

  // Compliance: One-time cleanup of expired logs
  try {
    const cleanup = await cleanupExpiredLogs();
    if (
      cleanup.deletedUsage ||
      cleanup.deletedCallLogs ||
      cleanup.deletedProxyLogs ||
      cleanup.deletedRequestDetailLogs ||
      cleanup.deletedAuditLogs ||
      cleanup.deletedMcpAuditLogs
    ) {
      startupLog.info({ cleanup }, "Expired log cleanup completed");
    }
  } catch (err) {
    startupLog.warn({ err }, "Log cleanup failed");
  }

  startupLog.info("Starting server with cloud sync");

  try {
    let settings = await getSettings();
    const passwordState = await ensurePersistentManagementPasswordHash({
      logger: { log: (message: string) => startupLog.info(message) },
      settings,
      source: "startup",
    });
    settings = passwordState.settings;
    const runtimeChanges = await applyRuntimeSettings(settings, { force: true, source: "startup" });
    if (runtimeChanges.length > 0) {
      startupLog.info(
        { sections: runtimeChanges.map((entry) => entry.section) },
        "Runtime settings hydrated"
      );
    }

    // Restore the Global System Prompt into the in-memory config. It lives in the
    // `settings.systemPrompt` key but is NOT covered by applyRuntimeSettings, so without
    // this the toggle/prompt revert to defaults on every restart (#2470).
    if (settings.systemPrompt) {
      setSystemPromptConfig(settings.systemPrompt);
      startupLog.info("Global System Prompt restored from settings");
    }

    // Restore the proxy-level Thinking-Budget config (#5312). It lives in
    // `settings.thinkingBudget` and is NOT covered by applyRuntimeSettings, so
    // without this the dashboard mode (auto/custom/adaptive) silently reverts to
    // the passthrough default on every restart.
    if (hydrateThinkingBudgetConfig(settings)) {
      startupLog.info("Thinking-Budget config restored from settings");
    }

    // Initialize cloud sync
    startSpendBatchWriter();
    registerDefaultGuardrails();
    registerBuiltinSkills(skillExecutor);
    startupLog.info("Spend batch writer started");
    startupLog.info("Guardrail registry initialized");
    startupLog.info("Builtin skill handlers registered");

    // Load active plugins on startup so they survive restarts
    try {
      const { pluginManager } = await import("./lib/plugins/manager");
      await pluginManager.loadAll();
      startupLog.info("Plugin manager loaded active plugins");
    } catch (err) {
      startupLog.warn({ err }, "Plugin manager loadAll failed (non-fatal)");
    }

    await initializeCloudSync();
    // register() only persists the definition; startAll() is what arms the timers.
    // This path does not call ensureCloudSyncInitialized(), so nothing else here
    // would start the jobs on our behalf. It registers the same set as that path:
    // starting one job and not the other is how a background job goes missing
    // without anything failing.
    const { getJobRegistry } = await import("./lib/jobRegistry");
    const jobRegistry = getJobRegistry();
    registerBudgetResetJob(jobRegistry);
    registerTokenHealthCheck(jobRegistry);
    await jobRegistry.startAll();
    startReasoningCacheCleanupJob();
    startCleanupScheduler();
    startRuntimeConfigHotReload();
    startupLog.info("Server started with cloud sync initialized");

    // Log server start event to audit log
    logAuditEvent({
      action: "server.start",
      actor: "system",
      target: "server-runtime",
      resourceType: "maintenance",
      status: "success",
      details: { timestamp: new Date().toISOString() },
    });
  } catch (error) {
    startupLog.error({ err: error }, "Error initializing cloud sync");
    process.exit(1);
  }

  // Pricing sync: opt-in external pricing data (non-blocking, never fatal)
  if (process.env.PRICING_SYNC_ENABLED === "true") {
    try {
      const { initPricingSync } = await import("./lib/pricingSync");
      await initPricingSync();
    } catch (err) {
      startupLog.warn({ error: getErrorMessage(err) }, "Pricing sync could not initialize");
    }
  }

  // Arena ELO sync: model intelligence from leaderboard data (non-blocking, never fatal).
  // On by default; opt out with Dashboard Feature Flags or ARENA_ELO_SYNC_ENABLED=false.
  try {
    const { initArenaEloSync } = await import("./lib/arenaEloSync");
    await initArenaEloSync();
  } catch (err) {
    startupLog.warn({ error: getErrorMessage(err) }, "Arena ELO sync could not initialize");
  }

  // Radar daily feed sync: only arms itself when RADAR_ENABLED AND the user
  // opt-in are already on (a flag-off boot stays timer-free — Radar inertia
  // contract). Non-blocking, never fatal.
  try {
    const { initRadarSyncScheduler } = await import("./lib/radar/scheduler");
    initRadarSyncScheduler();
  } catch (err) {
    startupLog.warn({ error: getErrorMessage(err) }, "Radar sync scheduler could not initialize");
  }
}

// Start the server initialization
startServer().catch((err) => {
  startupLog.error({ err }, "Server initialization failed");
  process.exit(1);
});

// Export for use as module if needed
export default startServer;