effortless-aws 0.33.0 → 0.34.0

package/dist/runtime/wrap-cron.js

@@ -1,6 +1,6 @@
 import {
   createHandlerRuntime
-} from "../chunk-HGSMOO4A.js";
+} from "../chunk-6HFS224S.js";
 
 // src/runtime/wrap-cron.ts
 var wrapCron = (handler) => {

package/dist/runtime/wrap-fifo-queue.js

@@ -1,6 +1,6 @@
 import {
   createHandlerRuntime
-} from "../chunk-HGSMOO4A.js";
+} from "../chunk-6HFS224S.js";
 
 // src/runtime/wrap-fifo-queue.ts
 var parseMessages = (rawRecords, schema) => {

package/dist/runtime/wrap-mcp.js

@@ -0,0 +1,235 @@
+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 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: 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 result = await tool.handler(req.params?.arguments ?? {}, ctx);
+        return { jsonrpc: "2.0", id: req.id, result };
+      } 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 result = await staticDef.handler(ctx);
+        const contents = Array.isArray(result) ? result : [result];
+        return { jsonrpc: "2.0", id: req.id, result: { contents } };
+      }
+      for (const [template, def] of Object.entries(resourceMap)) {
+        if (!isTemplate(template)) continue;
+        const params = matchTemplate(template, uri);
+        if (params) {
+          const result = await def.handler(params, ctx);
+          const contents = Array.isArray(result) ? result : [result];
+          return { jsonrpc: "2.0", id: req.id, result: { contents } };
+        }
+      }
+      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]) => ({
+        name,
+        ...def.description ? { description: def.description } : {},
+        ...def.arguments ? { arguments: def.arguments } : {}
+      }));
+      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 args = req.params?.arguments ?? {};
+      try {
+        const result = await prompt.handler(args, ctx);
+        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/dist/runtime/wrap-table-stream.js

@@ -1,7 +1,7 @@
 import {
   createHandlerRuntime,
   createTableClient
-} from "../chunk-HGSMOO4A.js";
+} from "../chunk-6HFS224S.js";
 
 // src/runtime/wrap-table-stream.ts
 import { unmarshall } from "@aws-sdk/util-dynamodb";

package/dist/runtime/wrap-worker.js

@@ -1,7 +1,7 @@
 import {
   buildDeps,
   buildParams
-} from "../chunk-HGSMOO4A.js";
+} from "../chunk-6HFS224S.js";
 
 // src/runtime/wrap-worker.ts
 import { SQS } from "@aws-sdk/client-sqs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "effortless-aws",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "license": "MIT",
   "type": "module",
   "description": "Code-first AWS Lambda framework. Export handlers, deploy with one command.",
@@ -43,11 +43,12 @@
     "@aws-sdk/client-ssm": "^3.985.0",
     "@aws-sdk/util-dynamodb": "^3.975.0",
     "@types/aws-lambda": "^8.10.144",
-    "@types/node": "^22.19.9",
+    "@types/node": "22.19.9",
     "tsup": "^8.5.1",
     "type-fest": "^4.22.1",
     "typescript": "^5.9.3",
     "vite-tsconfig-paths": "^6.1.1",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "vitest": "^4.0.18"
   },
   "scripts": {