refactoring the api endpoints to be separate files to reduce context usage

apps/server/src/routes/agent/common.ts

@@ -0,0 +1,21 @@
+/**
+ * Common utilities for agent routes
+ */
+
+import { createLogger } from "../../lib/logger.js";
+
+const logger = createLogger("Agent");
+
+/**
+ * Get error message from error object
+ */
+export function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : "Unknown error";
+}
+
+/**
+ * Log error details consistently
+ */
+export function logError(error: unknown, context: string): void {
+  logger.error(`❌ ${context}:`, error);
+}

apps/server/src/routes/agent/index.ts

@@ -0,0 +1,29 @@
+/**
+ * Agent routes - HTTP API for Claude agent interactions
+ */
+
+import { Router } from "express";
+import { AgentService } from "../../services/agent-service.js";
+import type { EventEmitter } from "../../lib/events.js";
+import { createStartHandler } from "./routes/start.js";
+import { createSendHandler } from "./routes/send.js";
+import { createHistoryHandler } from "./routes/history.js";
+import { createStopHandler } from "./routes/stop.js";
+import { createClearHandler } from "./routes/clear.js";
+import { createModelHandler } from "./routes/model.js";
+
+export function createAgentRoutes(
+  agentService: AgentService,
+  _events: EventEmitter
+): Router {
+  const router = Router();
+
+  router.post("/start", createStartHandler(agentService));
+  router.post("/send", createSendHandler(agentService));
+  router.post("/history", createHistoryHandler(agentService));
+  router.post("/stop", createStopHandler(agentService));
+  router.post("/clear", createClearHandler(agentService));
+  router.post("/model", createModelHandler(agentService));
+
+  return router;
+}

apps/server/src/routes/agent/routes/clear.ts

@@ -0,0 +1,28 @@
+/**
+ * POST /clear endpoint - Clear conversation
+ */
+
+import type { Request, Response } from "express";
+import { AgentService } from "../../../services/agent-service.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createClearHandler(agentService: AgentService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { sessionId } = req.body as { sessionId: string };
+
+      if (!sessionId) {
+        res
+          .status(400)
+          .json({ success: false, error: "sessionId is required" });
+        return;
+      }
+
+      const result = await agentService.clearSession(sessionId);
+      res.json(result);
+    } catch (error) {
+      logError(error, "Clear session failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/agent/routes/history.ts

@@ -0,0 +1,28 @@
+/**
+ * POST /history endpoint - Get conversation history
+ */
+
+import type { Request, Response } from "express";
+import { AgentService } from "../../../services/agent-service.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createHistoryHandler(agentService: AgentService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { sessionId } = req.body as { sessionId: string };
+
+      if (!sessionId) {
+        res
+          .status(400)
+          .json({ success: false, error: "sessionId is required" });
+        return;
+      }
+
+      const result = agentService.getHistory(sessionId);
+      res.json(result);
+    } catch (error) {
+      logError(error, "Get history failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/agent/routes/model.ts

@@ -0,0 +1,31 @@
+/**
+ * POST /model endpoint - Set session model
+ */
+
+import type { Request, Response } from "express";
+import { AgentService } from "../../../services/agent-service.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createModelHandler(agentService: AgentService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { sessionId, model } = req.body as {
+        sessionId: string;
+        model: string;
+      };
+
+      if (!sessionId || !model) {
+        res
+          .status(400)
+          .json({ success: false, error: "sessionId and model are required" });
+        return;
+      }
+
+      const result = await agentService.setSessionModel(sessionId, model);
+      res.json({ success: result });
+    } catch (error) {
+      logError(error, "Set session model failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/agent/routes/send.ts

@@ -0,0 +1,54 @@
+/**
+ * POST /send endpoint - Send a message
+ */
+
+import type { Request, Response } from "express";
+import { AgentService } from "../../../services/agent-service.js";
+import { createLogger } from "../../../lib/logger.js";
+import { getErrorMessage, logError } from "../common.js";
+
+const logger = createLogger("Agent");
+
+export function createSendHandler(agentService: AgentService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { sessionId, message, workingDirectory, imagePaths, model } =
+        req.body as {
+          sessionId: string;
+          message: string;
+          workingDirectory?: string;
+          imagePaths?: string[];
+          model?: string;
+        };
+
+      if (!sessionId || !message) {
+        res
+          .status(400)
+          .json({
+            success: false,
+            error: "sessionId and message are required",
+          });
+        return;
+      }
+
+      // Start the message processing (don't await - it streams via WebSocket)
+      agentService
+        .sendMessage({
+          sessionId,
+          message,
+          workingDirectory,
+          imagePaths,
+          model,
+        })
+        .catch((error) => {
+          logger.error("[Agent Route] Error sending message:", error);
+        });
+
+      // Return immediately - responses come via WebSocket
+      res.json({ success: true, message: "Message sent" });
+    } catch (error) {
+      logError(error, "Send message failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/agent/routes/start.ts

@@ -0,0 +1,38 @@
+/**
+ * POST /start endpoint - Start a conversation
+ */
+
+import type { Request, Response } from "express";
+import { AgentService } from "../../../services/agent-service.js";
+import { createLogger } from "../../../lib/logger.js";
+import { getErrorMessage, logError } from "../common.js";
+
+const logger = createLogger("Agent");
+
+export function createStartHandler(agentService: AgentService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { sessionId, workingDirectory } = req.body as {
+        sessionId: string;
+        workingDirectory?: string;
+      };
+
+      if (!sessionId) {
+        res
+          .status(400)
+          .json({ success: false, error: "sessionId is required" });
+        return;
+      }
+
+      const result = await agentService.startConversation({
+        sessionId,
+        workingDirectory,
+      });
+
+      res.json(result);
+    } catch (error) {
+      logError(error, "Start conversation failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/agent/routes/stop.ts

@@ -0,0 +1,28 @@
+/**
+ * POST /stop endpoint - Stop execution
+ */
+
+import type { Request, Response } from "express";
+import { AgentService } from "../../../services/agent-service.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createStopHandler(agentService: AgentService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { sessionId } = req.body as { sessionId: string };
+
+      if (!sessionId) {
+        res
+          .status(400)
+          .json({ success: false, error: "sessionId is required" });
+        return;
+      }
+
+      const result = await agentService.stopExecution(sessionId);
+      res.json(result);
+    } catch (error) {
+      logError(error, "Stop execution failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}