refactor endpoints into routes for better organization

smutyala1at · smutyala1at · commit f9b74b7e84a4 · 2025-11-30T10:20:08.000+01:00
diff --git a/mimir-rag/src/github/utils.ts b/mimir-rag/src/github/utils.ts
@@ -113,3 +113,40 @@ export function buildSourceUrl(owner: string, repo: string, branch: string, file
     const encodedPath = encodeRepoPath(filePath);
     return `https://github.com/${owner}/${repo}/blob/${encodeURIComponent(branch)}/${encodedPath}`;
 }
+
+// Webhook utilities
+import { createHmac, timingSafeEqual } from "node:crypto";
+
+export function getHeaderValue(header: string | string[] | undefined): string | undefined {
+    if (Array.isArray(header)) {
+        return header[0];
+    }
+    return header;
+}
+
+export function verifyGithubWebhookSignature(
+    secret: string,
+    signature: string | undefined,
+    rawBody?: Buffer
+): boolean {
+    if (!secret || !signature || !rawBody) {
+        return false;
+    }
+
+    const hmac = createHmac("sha256", secret);
+    hmac.update(rawBody);
+    const expected = `sha256=${hmac.digest("hex")}`;
+
+    const expectedBuffer = Buffer.from(expected);
+    const signatureBuffer = Buffer.from(signature);
+
+    if (expectedBuffer.length !== signatureBuffer.length) {
+        return false;
+    }
+
+    try {
+        return timingSafeEqual(expectedBuffer, signatureBuffer);
+    } catch {
+        return false;
+    }
+}
diff --git a/mimir-rag/src/server/routes/ask.ts b/mimir-rag/src/server/routes/ask.ts
@@ -1,23 +1,17 @@
+import type { Request, Response } from "express";
 import type { Logger } from "pino";
-import { askAi } from "../query/askAi";
-import type { AppConfig } from "../config/types";
-import type { LLMClientBundle } from "../llm/types";
-import type { SupabaseVectorStore } from "../supabase/client";
-
-export interface StreamAskOptions {
-    question: string;
-    matchCount?: number;
-    similarityThreshold?: number;
-    systemPrompt?: string;
-}
+import { askAi } from "../../query/askAi";
+import type { AppConfig } from "../../config/types";
+import type { LLMClientBundle } from "../../llm/types";
+import type { SupabaseVectorStore } from "../../supabase/client";
 
-export interface StreamAskContext {
+export interface AskRouteContext {
     config: AppConfig;
     llm: LLMClientBundle;
     store: SupabaseVectorStore;
 }
 
-export function isStreamingRequest(req: any): boolean {
+function isStreamingRequest(req: Request): boolean {
     const acceptHeader = typeof req?.headers?.accept === "string" ? req.headers.accept.toLowerCase() : "";
     if (acceptHeader.includes("text/event-stream")) {
         return true;
@@ -39,12 +33,35 @@ export function isStreamingRequest(req: any): boolean {
     return normalize(req?.query?.stream) || normalize(req?.body?.stream);
 }
 
-export async function streamAskResponse(
-    req: any,
-    res: any,
-    context: StreamAskContext,
+function initializeEventStream(res: Response): void {
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache, no-transform");
+    res.setHeader("Connection", "keep-alive");
+    if (typeof res.flushHeaders === "function") {
+        res.flushHeaders();
+    }
+}
+
+function pushStreamEvent(res: Response, event: string, payload: unknown): void {
+    if (res.writableEnded) {
+        return;
+    }
+
+    res.write(`event: ${event}\n`);
+    res.write(`data: ${JSON.stringify(payload)}\n\n`);
+}
+
+async function handleStreamingAsk(
+    req: Request,
+    res: Response,
+    context: AskRouteContext,
     logger: Logger,
-    options: StreamAskOptions
+    options: {
+        question: string;
+        matchCount?: number;
+        similarityThreshold?: number;
+        systemPrompt?: string;
+    }
 ): Promise<void> {
     initializeEventStream(res);
     const abortController = new AbortController();
@@ -104,20 +121,55 @@ export async function streamAskResponse(
     }
 }
 
-function initializeEventStream(res: any): void {
-    res.setHeader("Content-Type", "text/event-stream");
-    res.setHeader("Cache-Control", "no-cache, no-transform");
-    res.setHeader("Connection", "keep-alive");
-    if (typeof res.flushHeaders === "function") {
-        res.flushHeaders();
+export async function handleAskRequest(
+    req: Request,
+    res: Response,
+    context: AskRouteContext,
+    logger: Logger
+): Promise<void> {
+    const { question, matchCount, similarityThreshold, systemPrompt } = req.body ?? {};
+
+    if (typeof question !== "string" || question.trim().length === 0) {
+        res.status(400).json({
+            status: "error",
+            message: "Request body must include a non-empty 'question' field.",
+        });
+        return;
     }
-}
 
-function pushStreamEvent(res: any, event: string, payload: unknown): void {
-    if (res.writableEnded) {
+    if (isStreamingRequest(req)) {
+        await handleStreamingAsk(req, res, context, logger, {
+            question,
+            matchCount,
+            similarityThreshold,
+            systemPrompt,
+        });
         return;
     }
 
-    res.write(`event: ${event}\n`);
-    res.write(`data: ${JSON.stringify(payload)}\n\n`);
+    try {
+        const response = await askAi(
+            context.llm,
+            context.store,
+            {
+                question,
+                matchCount,
+                similarityThreshold,
+                systemPrompt,
+            },
+            {
+                logger,
+                config: context.config,
+            }
+        );
+
+        res.json({
+            status: "ok",
+            answer: response.answer,
+            sources: response.sources,
+        });
+    } catch (error) {
+        logger.error({ err: error }, "Ask endpoint failed.");
+        res.status(500).json({ status: "error", message: (error as Error).message });
+    }
 }
diff --git a/mimir-rag/src/server/routes/githubWebhook.ts b/mimir-rag/src/server/routes/githubWebhook.ts
@@ -0,0 +1,51 @@
+import type { Request, Response } from "express";
+import type { Logger } from "pino";
+import type { IngestRouteContext } from "./ingest";
+import { triggerIngestion } from "./ingest";
+import { getHeaderValue, verifyGithubWebhookSignature } from "../../github/utils";
+
+export type RequestWithRawBody = Request & { rawBody?: Buffer };
+
+export interface GithubWebhookRouteContext extends IngestRouteContext {
+    githubWebhookSecret?: string;
+}
+
+export async function handleGithubWebhookRequest(
+    req: RequestWithRawBody,
+    res: Response,
+    context: GithubWebhookRouteContext,
+    logger: Logger
+): Promise<void> {
+    const secret = context.githubWebhookSecret;
+
+    if (!secret) {
+        res.status(501).json({
+            status: "error",
+            message: "GitHub webhook secret is not configured on the server.",
+        });
+        return;
+    }
+
+    const signatureHeader = getHeaderValue(req.headers["x-hub-signature-256"]);
+    const rawBody = req.rawBody;
+
+    if (!verifyGithubWebhookSignature(secret, signatureHeader, rawBody)) {
+        res.status(401).json({ status: "error", message: "Invalid GitHub signature." });
+        return;
+    }
+
+    const eventType = getHeaderValue(req.headers["x-github-event"]) ?? "unknown";
+
+    if (eventType === "ping") {
+        res.json({ status: "ok", message: "pong" });
+        return;
+    }
+
+    const repoName = req.body?.repository?.full_name ?? "unknown-repo";
+
+    await triggerIngestion(res, context, logger, `github-webhook:${repoName}:${eventType}`, {
+        busyStatus: 202,
+        busyState: "pending",
+        busyMessage: "Ingestion already running. Webhook acknowledged.",
+    });
+}
diff --git a/mimir-rag/src/server/routes/health.ts b/mimir-rag/src/server/routes/health.ts
@@ -0,0 +1,9 @@
+import type { Request, Response } from "express";
+
+export interface HealthRouteContext {
+    ingestionBusy: boolean;
+}
+
+export function handleHealthRequest(_req: Request, res: Response, context: HealthRouteContext): void {
+    res.json({ status: "ok", ingestionBusy: context.ingestionBusy });
+}
diff --git a/mimir-rag/src/server/routes/ingest.ts b/mimir-rag/src/server/routes/ingest.ts
@@ -0,0 +1,66 @@
+import type { Request, Response } from "express";
+import type { Logger } from "pino";
+import type { AppConfig } from "../../config/types";
+import type { LLMClientBundle } from "../../llm/types";
+import type { SupabaseVectorStore } from "../../supabase/client";
+import { runIngestionPipeline } from "../../ingest/pipeline";
+
+export interface IngestRouteContext {
+    config: AppConfig;
+    llm: LLMClientBundle;
+    store: SupabaseVectorStore;
+    ingestionBusy: boolean;
+    setIngestionBusy: (busy: boolean) => void;
+}
+
+interface TriggerIngestionOptions {
+    busyStatus?: number;
+    busyMessage?: string;
+    busyState?: "error" | "pending";
+}
+
+async function triggerIngestion(
+    res: Response,
+    context: IngestRouteContext,
+    logger: Logger,
+    trigger: string,
+    options?: TriggerIngestionOptions
+): Promise<void> {
+    if (context.ingestionBusy) {
+        res.status(options?.busyStatus ?? 409).json({
+            status: options?.busyState ?? "error",
+            message: options?.busyMessage ?? "Ingestion already running.",
+        });
+        return;
+    }
+
+    context.setIngestionBusy(true);
+    const startedAt = Date.now();
+
+    try {
+        logger.info({ trigger }, "Starting ingestion.");
+        const result = await runIngestionPipeline(context.config, context.llm, context.store, logger);
+        res.json({
+            status: "ok",
+            trigger,
+            durationMs: Date.now() - startedAt,
+            stats: result.stats,
+        });
+    } catch (error) {
+        logger.error({ err: error, trigger }, "Ingestion failed.");
+        res.status(500).json({ status: "error", message: (error as Error).message });
+    } finally {
+        context.setIngestionBusy(false);
+    }
+}
+
+export async function handleIngestRequest(
+    _req: Request,
+    res: Response,
+    context: IngestRouteContext,
+    logger: Logger
+): Promise<void> {
+    await triggerIngestion(res, context, logger, "manual-request");
+}
+
+export { triggerIngestion };
diff --git a/mimir-rag/src/server/routes/mcpAsk.ts b/mimir-rag/src/server/routes/mcpAsk.ts
@@ -0,0 +1,78 @@
+import type { Request, Response } from "express";
+import type { Logger } from "pino";
+import { askAi } from "../../query/askAi";
+import { createLLMClient } from "../../llm/factory";
+import type { AppConfig } from "../../config/types";
+import type { SupabaseVectorStore } from "../../supabase/client";
+
+export interface McpAskRouteContext {
+    config: AppConfig;
+    store: SupabaseVectorStore;
+}
+
+export async function handleMcpAskRequest(
+    req: Request,
+    res: Response,
+    context: McpAskRouteContext,
+    logger: Logger
+): Promise<void> {
+    const { question, matchCount, similarityThreshold, systemPrompt, provider, model, apiKey } = req.body ?? {};
+
+    if (typeof question !== "string" || question.trim().length === 0) {
+        res.status(400).json({
+            status: "error",
+            message: "Request body must include a non-empty 'question' field.",
+        });
+        return;
+    }
+
+    // Validate MCP parameters
+    if (!provider || !model || !apiKey) {
+        res.status(400).json({
+            status: "error",
+            message: "Request body must include 'provider', 'model', and 'apiKey' fields.",
+        });
+        return;
+    }
+
+    try {
+        // Create a temporary LLM client with the provided credentials
+        const mcpLlm = createLLMClient(
+            {
+                embedding: context.config.llm.embedding, // Use default embedding
+                chat: {
+                    provider: provider as any,
+                    model: model,
+                    apiKey: apiKey,
+                    temperature: context.config.llm.chat.temperature,
+                    maxOutputTokens: context.config.llm.chat.maxOutputTokens,
+                },
+            },
+            logger
+        );
+
+        const response = await askAi(
+            mcpLlm,
+            context.store,
+            {
+                question,
+                matchCount,
+                similarityThreshold,
+                systemPrompt,
+            },
+            {
+                logger,
+                config: context.config,
+            }
+        );
+
+        res.json({
+            status: "ok",
+            answer: response.answer,
+            sources: response.sources,
+        });
+    } catch (error) {
+        logger.error({ err: error }, "MCP Ask endpoint failed.");
+        res.status(500).json({ status: "error", message: (error as Error).message });
+    }
+}
diff --git a/mimir-rag/src/server/server.ts b/mimir-rag/src/server/server.ts
