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

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

@@ -0,0 +1,21 @@
+/**
+ * Common utilities for sessions routes
+ */
+
+import { createLogger } from "../../lib/logger.js";
+
+const logger = createLogger("Sessions");
+
+/**
+ * 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/sessions/index.ts

@@ -0,0 +1,25 @@
+/**
+ * Sessions routes - HTTP API for session management
+ */
+
+import { Router } from "express";
+import { AgentService } from "../../services/agent-service.js";
+import { createIndexHandler } from "./routes/index.js";
+import { createCreateHandler } from "./routes/create.js";
+import { createUpdateHandler } from "./routes/update.js";
+import { createArchiveHandler } from "./routes/archive.js";
+import { createUnarchiveHandler } from "./routes/unarchive.js";
+import { createDeleteHandler } from "./routes/delete.js";
+
+export function createSessionsRoutes(agentService: AgentService): Router {
+  const router = Router();
+
+  router.get("/", createIndexHandler(agentService));
+  router.post("/", createCreateHandler(agentService));
+  router.put("/:sessionId", createUpdateHandler(agentService));
+  router.post("/:sessionId/archive", createArchiveHandler(agentService));
+  router.post("/:sessionId/unarchive", createUnarchiveHandler(agentService));
+  router.delete("/:sessionId", createDeleteHandler(agentService));
+
+  return router;
+}

apps/server/src/routes/sessions/routes/archive.ts

@@ -0,0 +1,26 @@
+/**
+ * POST /:sessionId/archive endpoint - Archive a session
+ */
+
+import type { Request, Response } from "express";
+import { AgentService } from "../../../services/agent-service.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createArchiveHandler(agentService: AgentService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { sessionId } = req.params;
+      const success = await agentService.archiveSession(sessionId);
+
+      if (!success) {
+        res.status(404).json({ success: false, error: "Session not found" });
+        return;
+      }
+
+      res.json({ success: true });
+    } catch (error) {
+      logError(error, "Archive session failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/sessions/routes/create.ts

@@ -0,0 +1,36 @@
+/**
+ * POST / endpoint - Create a new session
+ */
+
+import type { Request, Response } from "express";
+import { AgentService } from "../../../services/agent-service.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createCreateHandler(agentService: AgentService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { name, projectPath, workingDirectory, model } = req.body as {
+        name: string;
+        projectPath?: string;
+        workingDirectory?: string;
+        model?: string;
+      };
+
+      if (!name) {
+        res.status(400).json({ success: false, error: "name is required" });
+        return;
+      }
+
+      const session = await agentService.createSession(
+        name,
+        projectPath,
+        workingDirectory,
+        model
+      );
+      res.json({ success: true, session });
+    } catch (error) {
+      logError(error, "Create session failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/sessions/routes/delete.ts

@@ -0,0 +1,26 @@
+/**
+ * DELETE /:sessionId endpoint - Delete a session
+ */
+
+import type { Request, Response } from "express";
+import { AgentService } from "../../../services/agent-service.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createDeleteHandler(agentService: AgentService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { sessionId } = req.params;
+      const success = await agentService.deleteSession(sessionId);
+
+      if (!success) {
+        res.status(404).json({ success: false, error: "Session not found" });
+        return;
+      }
+
+      res.json({ success: true });
+    } catch (error) {
+      logError(error, "Delete session failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

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

@@ -0,0 +1,43 @@
+/**
+ * GET / endpoint - List all sessions
+ */
+
+import type { Request, Response } from "express";
+import { AgentService } from "../../../services/agent-service.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createIndexHandler(agentService: AgentService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const includeArchived = req.query.includeArchived === "true";
+      const sessionsRaw = await agentService.listSessions(includeArchived);
+
+      // Transform to match frontend SessionListItem interface
+      const sessions = await Promise.all(
+        sessionsRaw.map(async (s) => {
+          const messages = await agentService.loadSession(s.id);
+          const lastMessage = messages[messages.length - 1];
+          const preview = lastMessage?.content?.slice(0, 100) || "";
+
+          return {
+            id: s.id,
+            name: s.name,
+            projectPath: s.projectPath || s.workingDirectory,
+            workingDirectory: s.workingDirectory,
+            createdAt: s.createdAt,
+            updatedAt: s.updatedAt,
+            isArchived: s.archived || false,
+            tags: s.tags || [],
+            messageCount: messages.length,
+            preview,
+          };
+        })
+      );
+
+      res.json({ success: true, sessions });
+    } catch (error) {
+      logError(error, "List sessions failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/sessions/routes/unarchive.ts

@@ -0,0 +1,26 @@
+/**
+ * POST /:sessionId/unarchive endpoint - Unarchive a session
+ */
+
+import type { Request, Response } from "express";
+import { AgentService } from "../../../services/agent-service.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createUnarchiveHandler(agentService: AgentService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { sessionId } = req.params;
+      const success = await agentService.unarchiveSession(sessionId);
+
+      if (!success) {
+        res.status(404).json({ success: false, error: "Session not found" });
+        return;
+      }
+
+      res.json({ success: true });
+    } catch (error) {
+      logError(error, "Unarchive session failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/sessions/routes/update.ts

@@ -0,0 +1,35 @@
+/**
+ * PUT /:sessionId endpoint - Update a session
+ */
+
+import type { Request, Response } from "express";
+import { AgentService } from "../../../services/agent-service.js";
+import { getErrorMessage, logError } from "../common.js";
+
+export function createUpdateHandler(agentService: AgentService) {
+  return async (req: Request, res: Response): Promise<void> => {
+    try {
+      const { sessionId } = req.params;
+      const { name, tags, model } = req.body as {
+        name?: string;
+        tags?: string[];
+        model?: string;
+      };
+
+      const session = await agentService.updateSession(sessionId, {
+        name,
+        tags,
+        model,
+      });
+      if (!session) {
+        res.status(404).json({ success: false, error: "Session not found" });
+        return;
+      }
+
+      res.json({ success: true, session });
+    } catch (error) {
+      logError(error, "Update session failed");
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}