refactor: split monolith into 3 microservices (frontend, backend, discord-gateway)

- Extract services into services/{frontend,backend,discord-gateway}
- Create packages/shared/ for shared logger, errors, utils, types
- Setup Modular MVC pattern in backend (controller→service→repository)
- Setup event-driven architecture in discord-gateway with Redis pub/sub
- Move Docker files to infra/docker/ with per-service Dockerfiles
- Update docker-compose.yml to use Traefik-only routing (no port exposes)
- Update GitHub Actions deploy workflow for multi-service matrix build
- Fix all import paths and resolve type errors across all services
- All 3 services pass tsc --noEmit clean

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

services/discord-gateway/src/app/bootstrap.ts

@@ -0,0 +1,121 @@
+import { Client } from "discord.js-selfbot-v13";
+import { startPendingAIAnalysisWorker } from "../modules/ai-moderation/aiAnalyzer.js";
+import {
+  EventBroadcaster,
+  RedisEventPublisher,
+} from "../modules/event-broadcaster/index.js";
+import {
+  registerMessageCapture,
+  setEventBroadcaster,
+} from "../modules/message-capture/messageCapture.js";
+import { VoiceController } from "../modules/voice-recording/voiceController.js";
+import { config } from "../shared/config/config.js";
+import {
+  closeDatabase,
+  initializeDatabase,
+} from "../shared/database/drizzle.js";
+import { runMigrations } from "../shared/database/migrate.js";
+import { createDiscordClientOptions } from "../shared/discord/clientOptions.js";
+import { createChildLogger } from "../shared/logger/logger.js";
+import { createGracefulShutdown } from "./shutdown.js";
+
+const logger = createChildLogger("discord-gateway");
+
+export async function initializeDiscordGateway() {
+  if (!config.AI_LLM_API_KEY) {
+    logger.error(
+      "AI_LLM_API_KEY is missing from environment. Force closing application as AI environment is required.",
+    );
+    process.exit(1);
+  }
+
+  const token = config.DISCORD_TOKEN;
+  logger.info(
+    { hasToken: token.length > 0, tokenLength: token.length },
+    "Config loaded",
+  );
+
+  logger.info("Creating Discord client");
+  const client = new Client(createDiscordClientOptions());
+  const voiceController = new VoiceController(client);
+
+  // Initialize Redis event broadcaster
+  const redisPublisher = new RedisEventPublisher(config.REDIS_URL, logger);
+  const eventBroadcaster = new EventBroadcaster(redisPublisher, logger);
+
+  const gracefulShutdown = createGracefulShutdown({
+    logger,
+    closeDatabase,
+    voiceController,
+    client,
+    eventBroadcaster,
+  });
+
+  try {
+    if (config.AUTO_MIGRATE_ON_STARTUP) {
+      logger.info(
+        "AUTO_MIGRATE_ON_STARTUP enabled; running database migrations",
+      );
+      await runMigrations();
+    }
+
+    logger.info("Initializing database");
+    await initializeDatabase();
+    logger.info("PostgreSQL database initialized");
+  } catch (err) {
+    logger.error({ error: err }, "Failed to initialize database");
+    process.exit(1);
+  }
+
+  client.on("debug", (msg) => {
+    if (
+      msg.includes("[VOICE") ||
+      msg.includes("[ffmpeg") ||
+      msg.toLowerCase().includes("error") ||
+      msg.toLowerCase().includes("stream")
+    ) {
+      logger.info({ debugMsg: msg }, "Discord Client Debug");
+    } else if (config.VERBOSE) {
+      logger.debug({ debugMsg: msg }, "Discord Client Debug");
+    }
+  });
+
+  client.on("ready", async () => {
+    logger.info({ user: client.user?.tag }, "Bot logged in");
+    setEventBroadcaster(eventBroadcaster);
+    registerMessageCapture(client);
+    startPendingAIAnalysisWorker(client);
+  });
+
+  client.on("error", (err) => {
+    logger.error({ error: err }, "Client error");
+  });
+
+  process.on("SIGINT", () => {
+    gracefulShutdown("SIGINT");
+  });
+
+  process.on("SIGTERM", () => {
+    gracefulShutdown("SIGTERM");
+  });
+
+  process.on("uncaughtException", (err) => {
+    logger.error({ error: err }, "Uncaught exception");
+    gracefulShutdown("uncaughtException");
+  });
+
+  process.on("unhandledRejection", (reason, promise) => {
+    logger.error({ reason, promise }, "Unhandled rejection");
+    gracefulShutdown("unhandledRejection");
+  });
+
+  logger.info("Calling Discord client.login");
+  client
+    .login(token)
+    .then(() => {
+      logger.info("Discord client.login resolved");
+    })
+    .catch((error: unknown) => {
+      logger.error({ error }, "Discord client.login failed");
+    });
+}

services/discord-gateway/src/app/shutdown.ts

@@ -0,0 +1,55 @@
+import type { Client } from "discord.js-selfbot-v13";
+import type { EventBroadcaster } from "../modules/event-broadcaster/index.js";
+import type { VoiceController } from "../modules/voice-recording/voiceController.js";
+import type { closeDatabase } from "../shared/database/drizzle.js";
+import type { createChildLogger } from "../shared/logger/logger.js";
+
+type Logger = ReturnType<typeof createChildLogger>;
+type CloseDatabase = typeof closeDatabase;
+
+export interface GracefulShutdownOptions {
+  logger: Logger;
+  closeDatabase: CloseDatabase;
+  voiceController: VoiceController;
+  client: Client;
+  eventBroadcaster: EventBroadcaster;
+}
+
+export function createGracefulShutdown(options: GracefulShutdownOptions) {
+  let isShuttingDown = false;
+
+  return async function gracefulShutdown(signal: string) {
+    if (isShuttingDown) {
+      options.logger.warn(`Already shutting down, ignoring ${signal}`);
+      return;
+    }
+
+    isShuttingDown = true;
+    options.logger.info({ signal }, "Graceful shutdown initiated");
+
+    try {
+      options.logger.info("Closing database...");
+      await options.closeDatabase();
+      options.logger.info("Database closed");
+
+      options.logger.info("Stopping voice connection...");
+      await options.voiceController.disconnect();
+
+      options.logger.info("Closing event broadcaster...");
+      await options.eventBroadcaster.close();
+
+      options.logger.info("Destroying Discord client...");
+      try {
+        options.client.destroy();
+      } catch (err) {
+        options.logger.warn({ error: err }, "Error destroying client");
+      }
+
+      options.logger.info("Graceful shutdown completed");
+      process.exit(0);
+    } catch (err) {
+      options.logger.error({ error: err }, "Error during graceful shutdown");
+      process.exit(1);
+    }
+  };
+}