sync

Author: thdxr

bun.lock

@@ -11,11 +11,16 @@
   },
   "exports": {
     ".": "./dist/index.js",
-    "./*": "./dist/*"
+    "./*": "./dist/*.js"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.6.1",
     "@tsconfig/bun": "1.0.7",
-    "hono": "4.7.4"
+    "hono": "4.7.4",
+    "zod": "3.24.2",
+    "zod-to-json-schema": "3.24.3"
+  },
+  "devDependencies": {
+    "@standard-schema/spec": "1.0.0"
   }
 }

packages/opencontrol/package.json

@@ -1,49 +1,28 @@
-import { type Transport } from "@modelcontextprotocol/sdk/shared/transport.js"
-import { type JSONRPCMessage } from "@modelcontextprotocol/sdk/types.js"
 import { Hono } from "hono"
 import { HTTPException } from "hono/http-exception"
-
-class OpenControlTransport implements Transport {
-  constructor(private cb: (response: JSONRPCMessage) => void) {}
-  async start(): Promise<void> {}
-  async send(message: JSONRPCMessage): Promise<void> {
-    this.cb(message)
-  }
-  async close(): Promise<void> {}
-  onclose?: (() => void) | undefined
-  onerror?: ((error: Error) => void) | undefined
-  onmessage?: ((message: JSONRPCMessage) => void) | undefined
-}
+import { Tool } from "./tool.js"
+import { createMcp } from "./mcp.js"
 
 export interface OpenControlOptions {
   key?: string
 }
 
-export function create(
-  server: { connect: (transport: Transport) => Promise<void> },
-  options?: OpenControlOptions,
-) {
+export function create(input: { tools: Tool[]; key?: string }) {
+  const mcp = createMcp({ tools: input.tools })
+
   return new Hono()
     .use((c, next) => {
-      if (options?.key) {
+      if (input?.key) {
         const authorization = c.req.header("Authorization")
-        if (authorization !== `Bearer ${options?.key}`) {
+        if (authorization !== `Bearer ${input?.key}`) {
           throw new HTTPException(401)
         }
       }
       return next()
     })
     .post("/mcp", async (c) => {
       const body = await c.req.json()
-      console.log("<-", body)
-      const response = await new Promise<any>(async (resolve) => {
-        const transport = new OpenControlTransport(resolve)
-        console.log("connecting to transport")
-        await server.connect(transport)
-        console.log("connected to transport")
-        transport.onmessage?.(body)
-      })
-      console.log("->", JSON.stringify(response, null, 2))
-      return c.json(response)
+      const result = await mcp.process(body)
+      return c.json(result)
     })
 }

packages/opencontrol/src/index.ts

@@ -0,0 +1,114 @@
+import {
+  CallToolRequestSchema,
+  CallToolResult,
+  InitializeRequestSchema,
+  InitializeResult,
+  JSONRPCRequest,
+  JSONRPCResponse,
+  ListToolsRequestSchema,
+  ListToolsResult,
+} from "@modelcontextprotocol/sdk/types.js"
+import { z } from "zod"
+import { Tool } from "./tool.js"
+import { zodToJsonSchema } from "zod-to-json-schema"
+
+const RequestSchema = z.union([
+  InitializeRequestSchema,
+  ListToolsRequestSchema,
+  CallToolRequestSchema,
+])
+type RequestSchema = z.infer<typeof RequestSchema>
+
+export function createMcp(input: { tools: Tool[] }) {
+  return {
+    async process(message: JSONRPCRequest) {
+      const parsed = RequestSchema.parse(message)
+
+      const result = await (async () => {
+        if (parsed.method === "initialize")
+          return {
+            protocolVersion: "2024-11-05",
+            capabilities: {
+              tools: {},
+            },
+            serverInfo: {
+              name: "opencontrol",
+              version: "0.0.1",
+            },
+          } satisfies InitializeResult
+
+        if (parsed.method === "tools/list") {
+          return {
+            tools: input.tools.map((tool) => ({
+              name: tool.name,
+              inputSchema: tool.args
+                ? (zodToJsonSchema(tool.args as any, "args").definitions![
+                    "args"
+                  ] as any)
+                : { type: "object" },
+              description: tool.description,
+            })),
+          } satisfies ListToolsResult
+        }
+
+        if (parsed.method === "tools/call") {
+          const tool = input.tools.find(
+            (tool) => tool.name === parsed.params.name,
+          )
+          if (!tool) throw new Error("tool not found")
+
+          let args = parsed.params.arguments
+          if (tool.args) {
+            const validated = await tool.args["~standard"].validate(args)
+            if (validated.issues) {
+              return {
+                isError: true,
+                content: [
+                  {
+                    type: "text",
+                    text: JSON.stringify(validated.issues),
+                  },
+                ],
+              } satisfies CallToolResult
+            }
+            args = validated.value as any
+          }
+
+          return tool
+            .run(args)
+            .catch(
+              (error) =>
+                ({
+                  isError: true,
+                  content: [
+                    {
+                      type: "text",
+                      text: error.message,
+                    },
+                  ],
+                }) satisfies CallToolResult,
+            )
+            .then(
+              (result) =>
+                ({
+                  content: [
+                    {
+                      type: "text",
+                      text: JSON.stringify(result, null, 2),
+                    },
+                  ],
+                }) satisfies CallToolResult,
+            )
+        }
+
+        throw new Error("not implemented")
+      })()
+
+      return {
+        jsonrpc: "2.0",
+        id: message.id,
+        result,
+      } satisfies JSONRPCResponse
+    },
+  }
+}

packages/opencontrol/src/library/mysql.ts

@@ -0,0 +1,28 @@
+import { StandardSchemaV1 } from "@standard-schema/spec"
+import { z } from "zod"
+
+export interface Tool<
+  Args extends undefined | StandardSchemaV1 = undefined | StandardSchemaV1,
+> {
+  name: string
+  description: string
+  args?: Args
+  run: Args extends StandardSchemaV1
+    ? (args: StandardSchemaV1.InferOutput<Args>) => Promise<any>
+    : () => Promise<any>
+}
+
+export function tool<Args extends undefined | StandardSchemaV1>(
+  input: Tool<Args>,
+) {
+  return input
+}
+
+tool({
+  name: "foo",
+  description: "bar",
+  args: z.object({
+    foo: z.string(),
+  }),
+  async run(args) {},
+})