Clean up Elysia routes: deduplicate MCP handler, remove redundant validation

- Extract MCP handler to shared function instead of copy-pasting for 3 HTTP methods - Remove redundant manual workspaceId/body validation (Elysia schema already validates) - Simplify getBaseToolCount() to use baseTools.size - Fix .gitignore wildcard patterns (_.log -> *.log)

Rhys Sullivan committed 9 months ago

Commit 85da31c1 parent 3a401ab3 files · +29 −80Browse files

Unified · Split

3 files

.gitignore +2 −2
executor/apps/server/src/database.ts +10 −0
executor/apps/server/src/index.ts +17 −78

.gitignore+2−2

@@ -12,8 +12,8 @@ coverage · 11 unmodified lines
12		12
13	# logs	13	# logs
14	logs	14	logs
15	_.log	15	*.log
16	report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json	16	report.[0-9].[0-9].[0-9].[0-9].json
17		17
18	# dotenv environment variable files	18	# dotenv environment variable files
19	.env	19	.env

executor/apps/server/src/database.ts+10−0

@@ -56,6 +56,16 @@ export class ExecutorDatabase { · 55 unmodified lines
56	this.client = new ConvexHttpClient(convexUrl);	56	this.client = new ConvexHttpClient(convexUrl);
57	}	57	}
58		58
		59	// The `as never` casts below are intentional. ConvexHttpClient.mutation() and
		60	// .query() expect the exact generated function reference type and its
		61	// corresponding args type. Because we call them dynamically with string
		62	// function names (e.g. "database:createTask") and generic arg objects,
		63	// TypeScript cannot verify the relationship between name and args at the
		64	// call site. Properly typing this would require a discriminated-union
		65	// overload map for every Convex function, which adds significant
		66	// complexity for little safety gain — the real type safety lives in the
		67	// public method signatures of this class and the Convex handler
		68	// definitions themselves.
59	private async mutation<TArgs extends Record<string, unknown>, TResult>(	69	private async mutation<TArgs extends Record<string, unknown>, TResult>(
60	name: MutationName,	70	name: MutationName,
61	args: TArgs,	71	args: TArgs,

executor/apps/server/src/index.ts+17−78

   return { workspaceId, actorId, clientId };
 }
+// ── MCP handler ──
+const handleMcp = async ({ request }: { request: Request }) => {
+  const url = new URL(request.url);
+  const context = parseMcpContext(url);
+  return await handleMcpRequest(service, request, context);
+};
 // ── Elysia app ──
 const app = new Elysia()
   // ── MCP (raw protocol passthrough) ──
   // Optional query params: ?workspaceId=...&actorId=... to bind workspace context.
   // When bound, run_code description includes sandbox tool inventory and input is simplified.
-  .post("/mcp", async ({ request }) => {
+  .post("/mcp", handleMcp)
-    const url = new URL(request.url);
+  .get("/mcp", handleMcp)
-    const context = parseMcpContext(url);
+  .delete("/mcp", handleMcp)
-    return await handleMcpRequest(service, request, context);
-  })
-  .get("/mcp", async ({ request }) => {
-    const url = new URL(request.url);
-    const context = parseMcpContext(url);
-    return await handleMcpRequest(service, request, context);
-  })
-  .delete("/mcp", async ({ request }) => {
-    const url = new URL(request.url);
-    const context = parseMcpContext(url);
-    return await handleMcpRequest(service, request, context);
-  })
   // ── Health ──
   .get("/api/health", () => ({
   .get("/api/runtime-targets", () => service.listRuntimes())
   // ── Tools ──
-  .get("/api/tools", async ({ query, set }) => {
+  .get("/api/tools", async ({ query }) => {
-    if (!query.workspaceId) {
-      set.status = 400;
-      return { error: "workspaceId is required" };
-    }
     return await service.listTools({
       workspaceId: query.workspaceId,
       actorId: query.actorId,
   })
   // ── Tool Sources ──
-  .get("/api/tool-sources", async ({ query, set }) => {
+  .get("/api/tool-sources", async ({ query }) => {
-    if (!query.workspaceId) {
-      set.status = 400;
-      return { error: "workspaceId is required" };
-    }
     return await service.listToolSources(query.workspaceId);
   }, {
     query: t.Object({
   })
   .post("/api/tool-sources", async ({ body, set }) => {
-    if (!body.workspaceId || !body.name || !body.type || !body.config) {
-      set.status = 400;
-      return { error: "workspaceId, name, type, and config are required" };
-    }
     try {
       return await service.upsertToolSource({
         id: body.id,
   })
   .delete("/api/tool-sources/:sourceId", async ({ params, query, set }) => {
-    if (!query.workspaceId) {
-      set.status = 400;
-      return { error: "workspaceId is required" };
-    }
     const deleted = await service.deleteToolSource(query.workspaceId, params.sourceId);
     if (!deleted) {
       set.status = 404;
   })
   // ── Tasks ──
-  .get("/api/tasks", async ({ query, set }) => {
+  .get("/api/tasks", async ({ query }) => {
-    if (!query.workspaceId) {
-      set.status = 400;
-      return { error: "workspaceId is required" };
-    }
     return await service.listTasks(query.workspaceId);
   }, {
     query: t.Object({ workspaceId: t.String() }),
   })
   .get("/api/tasks/:taskId", async ({ params, query, set }) => {
-    if (!query.workspaceId) {
-      set.status = 400;
-      return { error: "workspaceId is required" };
-    }
     const task = await service.getTask(params.taskId, query.workspaceId);
     if (!task) {
       set.status = 404;
   })
   .get("/api/tasks/:taskId/events", async ({ params, query, set }) => {
-    if (!query.workspaceId) {
-      set.status = 400;
-      return { error: "workspaceId is required" };
-    }
     const task = await service.getTask(params.taskId, query.workspaceId);
     if (!task) {
       set.status = 404;
   // ── Approvals ──
   .get("/api/approvals", async ({ query, set }) => {
-    if (!query.workspaceId) {
-      set.status = 400;
-      return { error: "workspaceId is required" };
-    }
     const status = query.status as ApprovalStatus | undefined;
     if (status === "pending") {
   })
   .post("/api/approvals/:approvalId", async ({ params, body, set }) => {
-    if (!body.workspaceId || (body.decision !== "approved" && body.decision !== "denied")) {
-      set.status = 400;
-      return { error: "workspaceId and decision are required" };
-    }
     const resolved = await service.resolveApproval(
       body.workspaceId,
       params.approvalId,
   })
   // ── Policies ──
-  .get("/api/policies", async ({ query, set }) => {
+  .get("/api/policies", async ({ query }) => {
-    if (!query.workspaceId) {
-      set.status = 400;
-      return { error: "workspaceId is required" };
-    }
     return await service.listAccessPolicies(query.workspaceId);
   }, {
     query: t.Object({ workspaceId: t.String() }),
   })
-  .post("/api/policies", async ({ body, set }) => {
+  .post("/api/policies", async ({ body }) => {
-    if (!body.workspaceId || !body.toolPathPattern || !body.decision) {
-      set.status = 400;
-      return { error: "workspaceId, toolPathPattern, and decision are required" };
-    }
     return await service.upsertAccessPolicy({
       id: body.id,
       workspaceId: body.workspaceId,
   })
   // ── Credentials ──
-  .get("/api/credentials", async ({ query, set }) => {
+  .get("/api/credentials", async ({ query }) => {
-    if (!query.workspaceId) {
-      set.status = 400;
-      return { error: "workspaceId is required" };
-    }
     return await service.listCredentials(query.workspaceId);
   }, {
     query: t.Object({ workspaceId: t.String() }),
   })
   .post("/api/credentials", async ({ body, set }) => {
-    if (!body.workspaceId || !body.sourceKey || !body.scope || !body.secretJson) {
-      set.status = 400;
-      return { error: "workspaceId, sourceKey, scope, and secretJson are required" };
-    }
     if (body.scope === "actor" && (!body.actorId || body.actorId.trim().length === 0)) {
       set.status = 400;
       return { error: "actorId is required for actor-scoped credential" };
       set.status = 401;
       return { error: "Unauthorized internal call" };
     }
-    if (!body.callId || !body.toolPath) {
-      set.status = 400;
-      return { error: "callId and toolPath are required" };
-    }
     const call: ToolCallRequest = {
       runId: params.runId,