effortless-aws 0.33.1 → 0.35.0

package/dist/runtime/wrap-mcp.js

@@ -0,0 +1,292 @@
+import {
+  createHandlerRuntime
+} from "../chunk-6HFS224S.js";
+
+// src/runtime/wrap-mcp.ts
+var ErrorCode = {
+  InvalidRequest: -32600,
+  MethodNotFound: -32601,
+  InvalidParams: -32602,
+  InternalError: -32603
+};
+var parseBody = (body, isBase64) => {
+  if (!body) return void 0;
+  const decoded = isBase64 ? Buffer.from(body, "base64").toString("utf-8") : body;
+  try {
+    return JSON.parse(decoded);
+  } catch {
+    return void 0;
+  }
+};
+var isTemplate = (uri) => /\{[^}]+\}/.test(uri);
+var matchTemplate = (template, uri) => {
+  const paramNames = [];
+  const regexStr = template.replace(/\{([^}]+)\}/g, (_, name) => {
+    paramNames.push(name);
+    return "([^/]+)";
+  });
+  const match = uri.match(new RegExp(`^${regexStr}$`));
+  if (!match) return null;
+  const params = {};
+  for (let i = 0; i < paramNames.length; i++) {
+    params[paramNames[i]] = decodeURIComponent(match[i + 1]);
+  }
+  return params;
+};
+var jsonResponse = (body, status = 200) => ({
+  statusCode: status,
+  headers: { "Content-Type": "application/json" },
+  body: JSON.stringify(body)
+});
+var RESOURCE_NOT_FOUND = -32002;
+var isStandardSchema = (input) => input != null && typeof input === "object" && "~standard" in input && typeof input["~standard"]?.jsonSchema?.input === "function";
+var validateInput = async (schema, rawArgs, toolName) => {
+  const validate = schema["~standard"].validate;
+  if (typeof validate !== "function") return rawArgs;
+  const result = await validate(rawArgs);
+  if (result.issues) {
+    const messages = result.issues.map((i) => {
+      const path = i.path?.map((p) => typeof p === "object" ? p.key : p).join(".");
+      return path ? `${path}: ${i.message}` : i.message;
+    });
+    throw new Error(`Validation failed for tool "${toolName}": ${messages.join("; ")}`);
+  }
+  return result.value;
+};
+var wrapResourceResult = (raw, uri) => {
+  if (raw == null) return [{ uri, text: "null" }];
+  if (Array.isArray(raw)) {
+    if (raw.length > 0 && typeof raw[0] === "object" && raw[0] !== null && "uri" in raw[0]) return raw;
+    return [{ uri, text: JSON.stringify(raw) }];
+  }
+  if (typeof raw === "object" && "uri" in raw && ("text" in raw || "blob" in raw)) {
+    return [raw];
+  }
+  const text = typeof raw === "string" ? raw : JSON.stringify(raw);
+  return [{ uri, text }];
+};
+var wrapToolResult = (raw) => {
+  if (raw != null && typeof raw === "object" && "content" in raw && Array.isArray(raw.content)) {
+    return raw;
+  }
+  const text = typeof raw === "string" ? raw : JSON.stringify(raw ?? null);
+  return { content: [{ type: "text", text }] };
+};
+var wrapMcp = (handler) => {
+  const rt = createHandlerRuntime(handler, "mcp", handler.__spec.lambda?.logLevel ?? "info");
+  const serverName = handler.__spec.name;
+  const serverVersion = handler.__spec.version ?? "1.0.0";
+  const instructions = handler.__spec.instructions;
+  return async (event) => {
+    const startTime = Date.now();
+    rt.patchConsole();
+    let ctxProps = {};
+    try {
+      const method = event.requestContext?.http?.method ?? "GET";
+      if (method === "GET") {
+        return {
+          statusCode: 200,
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ jsonrpc: "2.0", id: null, result: { name: serverName, version: serverVersion, protocol: "mcp" } })
+        };
+      }
+      if (method !== "POST") {
+        return { statusCode: 405, headers: { "Content-Type": "application/json" }, body: JSON.stringify({ error: "Method not allowed" }) };
+      }
+      const body = parseBody(event.body, event.isBase64Encoded ?? false);
+      if (!body || body.jsonrpc !== "2.0" || !body.method) {
+        return jsonResponse({ jsonrpc: "2.0", error: { code: ErrorCode.InvalidRequest, message: "Invalid JSON-RPC request" } });
+      }
+      const headers = event.headers ?? {};
+      const authHeader = headers["authorization"] ?? headers["Authorization"] ?? void 0;
+      const common = await rt.commonArgs(void 0, authHeader, headers);
+      const ctx = common.ctx;
+      ctxProps = ctx && typeof ctx === "object" ? { ...ctx } : {};
+      if (common.auth) {
+        const auth = common.auth;
+        if (!auth.session) {
+          return { statusCode: 401, headers: { "Content-Type": "application/json" }, body: JSON.stringify({ error: "Unauthorized" }) };
+        }
+      }
+      const tools = handler.tools ? handler.tools(ctxProps) : {};
+      const resourceMap = handler.resources ? handler.resources(ctxProps) : {};
+      const prompts = handler.prompts ? handler.prompts(ctxProps) : {};
+      const response = await handleMethod(body, ctxProps, tools, resourceMap, prompts, serverName, serverVersion, instructions);
+      const logPayload = "result" in response ? response.result : response.error;
+      rt.logExecution(startTime, { method: body.method, id: body.id }, logPayload);
+      return jsonResponse(response);
+    } catch (error) {
+      rt.logError(startTime, { method: "unknown" }, error);
+      if (handler.onError) {
+        try {
+          await handler.onError({ error, toolName: "unknown", ...ctxProps });
+        } catch {
+        }
+      }
+      return jsonResponse({ jsonrpc: "2.0", error: { code: ErrorCode.InternalError, message: "Internal server error" } });
+    } finally {
+      if (handler.onCleanup) {
+        try {
+          await handler.onCleanup(ctxProps);
+        } catch (e) {
+          console.error(`[effortless:${rt.handlerName}] onCleanup error`, e);
+        }
+      }
+      rt.restoreConsole();
+    }
+  };
+};
+async function handleMethod(req, ctx, tools, resourceMap, prompts, serverName, serverVersion, instructions) {
+  switch (req.method) {
+    case "initialize":
+      return {
+        jsonrpc: "2.0",
+        id: req.id,
+        result: {
+          protocolVersion: "2025-03-26",
+          capabilities: {
+            ...Object.keys(tools).length > 0 ? { tools: {} } : {},
+            ...Object.keys(resourceMap).length > 0 ? { resources: {} } : {},
+            ...Object.keys(prompts).length > 0 ? { prompts: {} } : {}
+          },
+          serverInfo: {
+            name: serverName,
+            version: serverVersion
+          },
+          ...instructions ? { instructions } : {}
+        }
+      };
+    case "notifications/initialized":
+      return { jsonrpc: "2.0", id: req.id, result: {} };
+    case "ping":
+      return { jsonrpc: "2.0", id: req.id, result: {} };
+    case "notifications/cancelled":
+      return { jsonrpc: "2.0", id: req.id, result: {} };
+    // ── Tools ──
+    case "tools/list":
+      return {
+        jsonrpc: "2.0",
+        id: req.id,
+        result: {
+          tools: Object.entries(tools).map(([name, def]) => ({
+            name,
+            description: def.description,
+            inputSchema: isStandardSchema(def.input) ? def.input["~standard"].jsonSchema.input({ target: "draft-07" }) : def.input
+          }))
+        }
+      };
+    case "tools/call": {
+      const toolName = req.params?.name;
+      if (!toolName || !tools[toolName]) {
+        return { jsonrpc: "2.0", id: req.id, error: { code: ErrorCode.InvalidParams, message: `Unknown tool: ${toolName}` } };
+      }
+      const tool = tools[toolName];
+      try {
+        const rawArgs = req.params?.arguments ?? {};
+        const input = isStandardSchema(tool.input) ? await validateInput(tool.input, rawArgs, toolName) : rawArgs;
+        const raw = await tool.handler(input, ctx);
+        return { jsonrpc: "2.0", id: req.id, result: wrapToolResult(raw) };
+      } catch (error) {
+        return {
+          jsonrpc: "2.0",
+          id: req.id,
+          result: {
+            content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+            isError: true
+          }
+        };
+      }
+    }
+    // ── Resources ──
+    case "resources/list": {
+      const resources = Object.entries(resourceMap).filter(([uri]) => !isTemplate(uri)).map(([uri, def]) => ({
+        uri,
+        name: def.name,
+        ...def.description ? { description: def.description } : {},
+        ...def.mimeType ? { mimeType: def.mimeType } : {}
+      }));
+      return { jsonrpc: "2.0", id: req.id, result: { resources } };
+    }
+    case "resources/templates/list": {
+      const resourceTemplates = Object.entries(resourceMap).filter(([uri]) => isTemplate(uri)).map(([uriTemplate, def]) => ({
+        uriTemplate,
+        name: def.name,
+        ...def.description ? { description: def.description } : {},
+        ...def.mimeType ? { mimeType: def.mimeType } : {}
+      }));
+      return { jsonrpc: "2.0", id: req.id, result: { resourceTemplates } };
+    }
+    case "resources/read": {
+      const uri = req.params?.uri;
+      if (!uri) {
+        return { jsonrpc: "2.0", id: req.id, error: { code: ErrorCode.InvalidParams, message: "Missing uri parameter" } };
+      }
+      const staticDef = resourceMap[uri];
+      if (staticDef && !isTemplate(uri)) {
+        const raw = await staticDef.handler(ctx);
+        return { jsonrpc: "2.0", id: req.id, result: { contents: wrapResourceResult(raw, uri) } };
+      }
+      for (const [template, def] of Object.entries(resourceMap)) {
+        if (!isTemplate(template)) continue;
+        const rawParams = matchTemplate(template, uri);
+        if (rawParams) {
+          const defAny = def;
+          const params = defAny.params && typeof defAny.params === "object" && "~standard" in defAny.params ? await validateInput(defAny.params, rawParams, `resource ${template}`) : rawParams;
+          const raw = await def.handler(params, ctx);
+          return { jsonrpc: "2.0", id: req.id, result: { contents: wrapResourceResult(raw, uri) } };
+        }
+      }
+      return { jsonrpc: "2.0", id: req.id, error: { code: RESOURCE_NOT_FOUND, message: "Resource not found", data: { uri } } };
+    }
+    // ── Prompts ──
+    case "prompts/list": {
+      const promptList = Object.entries(prompts).map(([name, def]) => {
+        const defAny = def;
+        let args;
+        if (defAny.args && typeof defAny.args === "object" && "~standard" in defAny.args) {
+          const jsonSchema = defAny.args["~standard"].jsonSchema?.input?.({ target: "draft-07" });
+          if (jsonSchema?.properties) {
+            const required = new Set(jsonSchema.required ?? []);
+            args = Object.entries(jsonSchema.properties).map(([key, prop]) => ({
+              name: key,
+              ...prop.description ? { description: prop.description } : {},
+              ...required.has(key) ? { required: true } : {}
+            }));
+          }
+        } else if (Array.isArray(defAny.args)) {
+          args = defAny.args;
+        } else if (defAny.arguments) {
+          args = defAny.arguments;
+        }
+        return {
+          name,
+          ...def.description ? { description: def.description } : {},
+          ...args ? { arguments: args } : {}
+        };
+      });
+      return { jsonrpc: "2.0", id: req.id, result: { prompts: promptList } };
+    }
+    case "prompts/get": {
+      const promptName = req.params?.name;
+      if (!promptName || !prompts[promptName]) {
+        return { jsonrpc: "2.0", id: req.id, error: { code: ErrorCode.InvalidParams, message: `Unknown prompt: ${promptName}` } };
+      }
+      const prompt = prompts[promptName];
+      const rawArgs = req.params?.arguments ?? {};
+      try {
+        const defAny = prompt;
+        const args = defAny.args && typeof defAny.args === "object" && "~standard" in defAny.args ? await validateInput(defAny.args, rawArgs, `prompt ${promptName}`) : rawArgs;
+        const raw = await prompt.handler(args, ctx);
+        const result = typeof raw === "string" ? { messages: [{ role: "user", content: { type: "text", text: raw } }] } : raw;
+        return { jsonrpc: "2.0", id: req.id, result };
+      } catch (error) {
+        return { jsonrpc: "2.0", id: req.id, error: { code: ErrorCode.InternalError, message: error instanceof Error ? error.message : String(error) } };
+      }
+    }
+    default:
+      return { jsonrpc: "2.0", id: req.id, error: { code: ErrorCode.MethodNotFound, message: `Unknown method: ${req.method}` } };
+  }
+}
+export {
+  wrapMcp
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effortless-aws",
-  "version": "0.33.1",
+  "version": "0.35.0",
   "license": "MIT",
   "type": "module",
   "description": "Code-first AWS Lambda framework. Export handlers, deploy with one command.",
@@ -48,6 +48,8 @@
     "type-fest": "^4.22.1",
     "typescript": "^5.9.3",
     "vite-tsconfig-paths": "^6.1.1",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@standard-schema/spec": "^1.1.0",
     "vitest": "^4.0.18"
   },
   "scripts": {