@squirrelnotes.app/mcp 2.0.1 → 2.1.0

package/README.md

@@ -6,11 +6,9 @@ An [MCP (Model Context Protocol)](https://modelcontextprotocol.io/) server that
 
 ## ⚠️ Security Caveat — Read This First
 
-The MCP server necessarily decrypts your notes — that is its job. The security implications depend on which transport you use:
+The MCP server necessarily decrypts your notes — that is its job. It runs only as a local process on your machine (the stdio transport); there is no hosted MCP server.
 
-### stdio (local process) — recommended
-
-The passphrase lives in `claude_desktop_config.json` on your machine and is passed as an env var to the local process. It never leaves your machine, and decryption happens locally — similar to the standard Squirrel Notes app, where the passphrase is entered locally in the browser and not sent to the server. Compared with the Remote HTTP/Lambda transport below, stdio avoids sending your passphrase over the network, at the cost of storing it in a local config file.
+The passphrase lives in `claude_desktop_config.json` on your machine and is passed as an env var to the local process. It never leaves your machine, and decryption happens locally — similar to the standard Squirrel Notes app, where the passphrase is entered locally in the browser and not sent to the server. The cost is that the passphrase is stored in a local config file.
 
 | Risk | Mitigation |
 |------|------------|
@@ -18,21 +16,6 @@ The passphrase lives in `claude_desktop_config.json` on your machine and is pass
 | Passphrase in process memory | Env var; cleared when process exits |
 | Decrypted content visible to AI | This is the intended behaviour — AI agents need to read your notes |
 
-### Remote HTTP (Lambda)
-
-Your passphrase is sent over HTTPS to a Lambda function on every call.
-
-| Risk | Mitigation |
-|------|------------|
-| Passphrase sent over the network | HTTPS-only (API Gateway always TLS) |
-| Passphrase in server RAM during invocation | Stack-scoped variable; never assigned to module state; GC'd after invocation |
-| Passphrase in CloudWatch logs | Lambda code never logs headers |
-| Lambda container reuse retaining secrets | Passphrase is NOT module-scope — reused containers hold no residual secret |
-
-**You must trust:** AWS Lambda, the self-hosted MCP server code, and anyone with access to your CloudWatch logs.
-
-If this trade-off is not acceptable, use stdio transport instead.
-
 ---
 
 ## Tools
@@ -65,12 +48,12 @@ If this trade-off is not acceptable, use stdio transport instead.
 
 ### Attachments
 
-| Tool | Transport | Description |
-|------|-----------|-------------|
-| `list_attachments` | All | Lists all attachments for a note with decrypted filenames and metadata. |
-| `get_attachment_download_url` | All | Returns a presigned S3 download URL (expires in 5 minutes). |
-| `delete_attachment` | All | Permanently deletes an attachment from S3 and the database. |
-| `upload_attachment_from_path` | STDIO only | Uploads a file from a local path — **no file bytes in context**. Use after `write_file` (Filesystem MCP) to attach Claude-generated files. See [Filesystem MCP companion](#filesystem-mcp-companion-stdio-only) below. |
+| Tool | Description |
+|------|-------------|
+| `list_attachments` | Lists all attachments for a note with decrypted filenames and metadata. |
+| `get_attachment_download_url` | Returns a presigned S3 download URL (expires in 5 minutes). |
+| `delete_attachment` | Permanently deletes an attachment from S3 and the database. |
+| `upload_attachment_from_path` | Uploads a file from a local path — **no file bytes in context**. Use after `write_file` (Filesystem MCP) to attach Claude-generated files. See [Filesystem MCP companion](#filesystem-mcp-companion-stdio-only) below. |
 
 ---
 
@@ -142,28 +125,15 @@ Add both servers to `claude_desktop_config.json`:
 1. Claude calls `get_note(id)` (Squirrel MCP) to read the note
 2. Claude calls `write_file("/tmp/roadmap.md", content)` (Filesystem MCP)
 
-Every request requires two headers:
-
-```
-Authorization: Bearer sqn_<api_key>
-X-Passphrase: <your_passphrase>
-```
+The server needs an API key and your passphrase, both set as env vars in your client's config (see Setup). The API key is sent to the Squirrel Notes API in the `Authorization` header; the passphrase is never sent anywhere.
 
 Generate an API key in Squirrel Notes → Settings → API Key (requires Pro tier).
 
-Neither header is ever stored, cached, or logged by the server.
-
 ---
 
 ## Setup
 
-> **Which setup should I use?**
-> - **Claude Desktop** → use **stdio (recommended)** — no OAuth, passphrase stays on your machine
-> - **API automation / Cursor / other agents** → use **Remote HTTP (Lambda)**
-
----
-
-### Setup — Claude Desktop (stdio) ✅ Recommended
+### Setup — Claude Desktop, Cursor and other MCP clients (stdio)
 
 The stdio transport runs the MCP server as a local process on your machine. No OAuth, no network headers, no AWS account needed. Your passphrase is set as an env var in the config file and **never leaves your machine**.
 
@@ -232,47 +202,6 @@ Then reference the built file directly:
 
 ---
 
-### Setup — Remote HTTP (Lambda)
-
-Use this if you want to connect agents or tools that support remote HTTP MCP endpoints (Cursor, custom automations, etc.). This requires deploying to AWS and sending the passphrase over HTTPS on every call.
-
-#### 1. Deploy with CDK
-
-```bash
-cd infra
-npx cdk deploy SquirrelMcp
-```
-
-This creates:
-- A Lambda function running the MCP server Docker image
-- An HTTP API Gateway at `https://<id>.execute-api.<region>.amazonaws.com/mcp`
-
-The deployed URL is printed as a CDK output (`McpApiUrl`).
-
-#### 2. Configure your client
-
-```json
-{
-  "mcpServers": {
-    "squirrel-notes": {
-      "url": "https://<your-mcp-api-url>/mcp",
-      "headers": {
-        "Authorization": "Bearer sqn_<your_api_key>",
-        "X-Passphrase": "<your_passphrase>"
-      }
-    }
-  }
-}
-```
-
-> **Note:** Newer versions of Claude Desktop enforce OAuth 2.0 for remote HTTP servers and will reject this config. Use the stdio setup above for Claude Desktop.
-
-#### 3. Verify
-
-Ask Claude: *"List my Squirrel Notes"* — you should see decrypted note titles.
-
----
-
 ## Common Workflows
 
 Once configured, you can speak to Claude naturally. Some examples:
@@ -296,28 +225,15 @@ Once configured, you can speak to Claude naturally. Some examples:
 ## Local Development
 
 ```bash
-cd mcp
-npm install
-npm run dev
+npm --prefix mcp install
+npm --prefix mcp run build      # builds dist/stdio-handler.js
+npm --prefix mcp test
 ```
 
-This starts an HTTP MCP server at `http://localhost:3002` pointing at the local backend (`http://localhost:3001`). No build step needed — `tsx` runs TypeScript directly.
-
-Smoke test with curl:
+Point a client at `mcp/dist/stdio-handler.js` with `SQUIRREL_API_BASE_URL=http://localhost:3001` (the local backend), as in Option B above. Or open the MCP Inspector on it — set the three env vars in the Inspector's UI:
 
 ```bash
-curl -s http://localhost:3002 -X POST \
-  -H "Authorization: Bearer sqn_<your_api_key>" \
-  -H "X-Passphrase: <your_passphrase>" \
-  -H "Content-Type: application/json" \
-  -H "Accept: application/json, text/event-stream" \
-  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}' | jq .
-```
-
-Or use the MCP Inspector for a browser UI:
-
-```bash
-npx @modelcontextprotocol/inspector http://localhost:3002
+make mcp-inspect
 ```
 
 ---
@@ -384,19 +300,9 @@ tail -f /tmp/squirrel-mcp.log
 
 ## Environment Variables
 
-### stdio transport
-
 | Variable | Required | Description |
 |----------|----------|-------------|
 | `SQUIRREL_API_BASE_URL` | ✅ | Base URL of the Squirrel Notes backend API (e.g. `https://api.squirrelnotes.app`) |
 | `SQUIRREL_API_KEY` | ✅ | Your API key from Settings → API Key (requires Pro tier) |
 | `SQUIRREL_PASSPHRASE` | ✅ | Your encryption passphrase — never leaves your machine |
 | `SQUIRREL_LOG_FILE` | — | Absolute path to a log file. When set, all stderr output is also appended to this file. |
-
-### Lambda (HTTP) transport
-
-| Variable | Description |
-|----------|-------------|
-| `SQUIRREL_API_BASE_URL` | Base URL of the Squirrel Notes backend API |
-
-For Lambda, the API key and passphrase are passed per-request via `Authorization` and `X-Passphrase` headers — **not** environment variables.

package/dist/stdio-handler.js

@@ -4755,12 +4755,11 @@ function assertCompleteRequestResourceTemplate(request) {
   }
   void request;
 }
-var LATEST_PROTOCOL_VERSION, DEFAULT_NEGOTIATED_PROTOCOL_VERSION, SUPPORTED_PROTOCOL_VERSIONS, RELATED_TASK_META_KEY, JSONRPC_VERSION, AssertObjectSchema, ProgressTokenSchema, CursorSchema, TaskCreationParamsSchema, TaskMetadataSchema, RelatedTaskMetadataSchema, RequestMetaSchema, BaseRequestParamsSchema, TaskAugmentedRequestParamsSchema, isTaskAugmentedRequestParams, RequestSchema, NotificationsParamsSchema, NotificationSchema, ResultSchema, RequestIdSchema, JSONRPCRequestSchema, isJSONRPCRequest, JSONRPCNotificationSchema, isJSONRPCNotification, JSONRPCResultResponseSchema, isJSONRPCResultResponse, ErrorCode, JSONRPCErrorResponseSchema, isJSONRPCErrorResponse, JSONRPCMessageSchema, JSONRPCResponseSchema, EmptyResultSchema, CancelledNotificationParamsSchema, CancelledNotificationSchema, IconSchema, IconsSchema, BaseMetadataSchema, ImplementationSchema, FormElicitationCapabilitySchema, ElicitationCapabilitySchema, ClientTasksCapabilitySchema, ServerTasksCapabilitySchema, ClientCapabilitiesSchema, InitializeRequestParamsSchema, InitializeRequestSchema, isInitializeRequest, ServerCapabilitiesSchema, InitializeResultSchema, InitializedNotificationSchema, PingRequestSchema, ProgressSchema, ProgressNotificationParamsSchema, ProgressNotificationSchema, PaginatedRequestParamsSchema, PaginatedRequestSchema, PaginatedResultSchema, TaskStatusSchema, TaskSchema, CreateTaskResultSchema, TaskStatusNotificationParamsSchema, TaskStatusNotificationSchema, GetTaskRequestSchema, GetTaskResultSchema, GetTaskPayloadRequestSchema, GetTaskPayloadResultSchema, ListTasksRequestSchema, ListTasksResultSchema, CancelTaskRequestSchema, CancelTaskResultSchema, ResourceContentsSchema, TextResourceContentsSchema, Base64Schema, BlobResourceContentsSchema, RoleSchema, AnnotationsSchema, ResourceSchema, ResourceTemplateSchema, ListResourcesRequestSchema, ListResourcesResultSchema, ListResourceTemplatesRequestSchema, ListResourceTemplatesResultSchema, ResourceRequestParamsSchema, ReadResourceRequestParamsSchema, ReadResourceRequestSchema, ReadResourceResultSchema, ResourceListChangedNotificationSchema, SubscribeRequestParamsSchema, SubscribeRequestSchema, UnsubscribeRequestParamsSchema, UnsubscribeRequestSchema, ResourceUpdatedNotificationParamsSchema, ResourceUpdatedNotificationSchema, PromptArgumentSchema, PromptSchema, ListPromptsRequestSchema, ListPromptsResultSchema, GetPromptRequestParamsSchema, GetPromptRequestSchema, TextContentSchema, ImageContentSchema, AudioContentSchema, ToolUseContentSchema, EmbeddedResourceSchema, ResourceLinkSchema, ContentBlockSchema, PromptMessageSchema, GetPromptResultSchema, PromptListChangedNotificationSchema, ToolAnnotationsSchema, ToolExecutionSchema, ToolSchema, ListToolsRequestSchema, ListToolsResultSchema, CallToolResultSchema, CompatibilityCallToolResultSchema, CallToolRequestParamsSchema, CallToolRequestSchema, ToolListChangedNotificationSchema, ListChangedOptionsBaseSchema, LoggingLevelSchema, SetLevelRequestParamsSchema, SetLevelRequestSchema, LoggingMessageNotificationParamsSchema, LoggingMessageNotificationSchema, ModelHintSchema, ModelPreferencesSchema, ToolChoiceSchema, ToolResultContentSchema, SamplingContentSchema, SamplingMessageContentBlockSchema, SamplingMessageSchema, CreateMessageRequestParamsSchema, CreateMessageRequestSchema, CreateMessageResultSchema, CreateMessageResultWithToolsSchema, BooleanSchemaSchema, StringSchemaSchema, NumberSchemaSchema, UntitledSingleSelectEnumSchemaSchema, TitledSingleSelectEnumSchemaSchema, LegacyTitledEnumSchemaSchema, SingleSelectEnumSchemaSchema, UntitledMultiSelectEnumSchemaSchema, TitledMultiSelectEnumSchemaSchema, MultiSelectEnumSchemaSchema, EnumSchemaSchema, PrimitiveSchemaDefinitionSchema, ElicitRequestFormParamsSchema, ElicitRequestURLParamsSchema, ElicitRequestParamsSchema, ElicitRequestSchema, ElicitationCompleteNotificationParamsSchema, ElicitationCompleteNotificationSchema, ElicitResultSchema, ResourceTemplateReferenceSchema, PromptReferenceSchema, CompleteRequestParamsSchema, CompleteRequestSchema, CompleteResultSchema, RootSchema, ListRootsRequestSchema, ListRootsResultSchema, RootsListChangedNotificationSchema, ClientRequestSchema, ClientNotificationSchema, ClientResultSchema, ServerRequestSchema, ServerNotificationSchema, ServerResultSchema, McpError, UrlElicitationRequiredError;
+var LATEST_PROTOCOL_VERSION, SUPPORTED_PROTOCOL_VERSIONS, RELATED_TASK_META_KEY, JSONRPC_VERSION, AssertObjectSchema, ProgressTokenSchema, CursorSchema, TaskCreationParamsSchema, TaskMetadataSchema, RelatedTaskMetadataSchema, RequestMetaSchema, BaseRequestParamsSchema, TaskAugmentedRequestParamsSchema, isTaskAugmentedRequestParams, RequestSchema, NotificationsParamsSchema, NotificationSchema, ResultSchema, RequestIdSchema, JSONRPCRequestSchema, isJSONRPCRequest, JSONRPCNotificationSchema, isJSONRPCNotification, JSONRPCResultResponseSchema, isJSONRPCResultResponse, ErrorCode, JSONRPCErrorResponseSchema, isJSONRPCErrorResponse, JSONRPCMessageSchema, JSONRPCResponseSchema, EmptyResultSchema, CancelledNotificationParamsSchema, CancelledNotificationSchema, IconSchema, IconsSchema, BaseMetadataSchema, ImplementationSchema, FormElicitationCapabilitySchema, ElicitationCapabilitySchema, ClientTasksCapabilitySchema, ServerTasksCapabilitySchema, ClientCapabilitiesSchema, InitializeRequestParamsSchema, InitializeRequestSchema, ServerCapabilitiesSchema, InitializeResultSchema, InitializedNotificationSchema, PingRequestSchema, ProgressSchema, ProgressNotificationParamsSchema, ProgressNotificationSchema, PaginatedRequestParamsSchema, PaginatedRequestSchema, PaginatedResultSchema, TaskStatusSchema, TaskSchema, CreateTaskResultSchema, TaskStatusNotificationParamsSchema, TaskStatusNotificationSchema, GetTaskRequestSchema, GetTaskResultSchema, GetTaskPayloadRequestSchema, GetTaskPayloadResultSchema, ListTasksRequestSchema, ListTasksResultSchema, CancelTaskRequestSchema, CancelTaskResultSchema, ResourceContentsSchema, TextResourceContentsSchema, Base64Schema, BlobResourceContentsSchema, RoleSchema, AnnotationsSchema, ResourceSchema, ResourceTemplateSchema, ListResourcesRequestSchema, ListResourcesResultSchema, ListResourceTemplatesRequestSchema, ListResourceTemplatesResultSchema, ResourceRequestParamsSchema, ReadResourceRequestParamsSchema, ReadResourceRequestSchema, ReadResourceResultSchema, ResourceListChangedNotificationSchema, SubscribeRequestParamsSchema, SubscribeRequestSchema, UnsubscribeRequestParamsSchema, UnsubscribeRequestSchema, ResourceUpdatedNotificationParamsSchema, ResourceUpdatedNotificationSchema, PromptArgumentSchema, PromptSchema, ListPromptsRequestSchema, ListPromptsResultSchema, GetPromptRequestParamsSchema, GetPromptRequestSchema, TextContentSchema, ImageContentSchema, AudioContentSchema, ToolUseContentSchema, EmbeddedResourceSchema, ResourceLinkSchema, ContentBlockSchema, PromptMessageSchema, GetPromptResultSchema, PromptListChangedNotificationSchema, ToolAnnotationsSchema, ToolExecutionSchema, ToolSchema, ListToolsRequestSchema, ListToolsResultSchema, CallToolResultSchema, CompatibilityCallToolResultSchema, CallToolRequestParamsSchema, CallToolRequestSchema, ToolListChangedNotificationSchema, ListChangedOptionsBaseSchema, LoggingLevelSchema, SetLevelRequestParamsSchema, SetLevelRequestSchema, LoggingMessageNotificationParamsSchema, LoggingMessageNotificationSchema, ModelHintSchema, ModelPreferencesSchema, ToolChoiceSchema, ToolResultContentSchema, SamplingContentSchema, SamplingMessageContentBlockSchema, SamplingMessageSchema, CreateMessageRequestParamsSchema, CreateMessageRequestSchema, CreateMessageResultSchema, CreateMessageResultWithToolsSchema, BooleanSchemaSchema, StringSchemaSchema, NumberSchemaSchema, UntitledSingleSelectEnumSchemaSchema, TitledSingleSelectEnumSchemaSchema, LegacyTitledEnumSchemaSchema, SingleSelectEnumSchemaSchema, UntitledMultiSelectEnumSchemaSchema, TitledMultiSelectEnumSchemaSchema, MultiSelectEnumSchemaSchema, EnumSchemaSchema, PrimitiveSchemaDefinitionSchema, ElicitRequestFormParamsSchema, ElicitRequestURLParamsSchema, ElicitRequestParamsSchema, ElicitRequestSchema, ElicitationCompleteNotificationParamsSchema, ElicitationCompleteNotificationSchema, ElicitResultSchema, ResourceTemplateReferenceSchema, PromptReferenceSchema, CompleteRequestParamsSchema, CompleteRequestSchema, CompleteResultSchema, RootSchema, ListRootsRequestSchema, ListRootsResultSchema, RootsListChangedNotificationSchema, ClientRequestSchema, ClientNotificationSchema, ClientResultSchema, ServerRequestSchema, ServerNotificationSchema, ServerResultSchema, McpError, UrlElicitationRequiredError;
 var init_types = __esm({
   "node_modules/@modelcontextprotocol/sdk/dist/esm/types.js"() {
     init_v4();
     LATEST_PROTOCOL_VERSION = "2025-11-25";
-    DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26";
     SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05", "2024-10-07"];
     RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task";
     JSONRPC_VERSION = "2.0";
@@ -4769,10 +4768,9 @@ var init_types = __esm({
     CursorSchema = string2();
     TaskCreationParamsSchema = looseObject({
       /**
-       * Time in milliseconds to keep task results available after completion.
-       * If null, the task has unlimited lifetime until manually cleaned up.
+       * Requested duration in milliseconds to retain task from creation.
        */
-      ttl: union([number2(), _null3()]).optional(),
+      ttl: number2().optional(),
       /**
        * Time in milliseconds to wait between task status requests.
        */
@@ -5071,7 +5069,11 @@ var init_types = __esm({
       /**
        * Present if the client supports task creation.
        */
-      tasks: ClientTasksCapabilitySchema.optional()
+      tasks: ClientTasksCapabilitySchema.optional(),
+      /**
+       * Extensions that the client supports. Keys are extension identifiers (vendor-prefix/extension-name).
+       */
+      extensions: record(string2(), AssertObjectSchema).optional()
     });
     InitializeRequestParamsSchema = BaseRequestParamsSchema.extend({
       /**
@@ -5085,7 +5087,6 @@ var init_types = __esm({
       method: literal("initialize"),
       params: InitializeRequestParamsSchema
     });
-    isInitializeRequest = (value) => InitializeRequestSchema.safeParse(value).success;
     ServerCapabilitiesSchema = object({
       /**
        * Experimental, non-standard capabilities that the server supports.
@@ -5133,7 +5134,11 @@ var init_types = __esm({
       /**
        * Present if the server supports task creation.
        */
-      tasks: ServerTasksCapabilitySchema.optional()
+      tasks: ServerTasksCapabilitySchema.optional(),
+      /**
+       * Extensions that the server supports. Keys are extension identifiers (vendor-prefix/extension-name).
+       */
+      extensions: record(string2(), AssertObjectSchema).optional()
     });
     InitializeResultSchema = ResultSchema.extend({
       /**
@@ -5325,6 +5330,12 @@ var init_types = __esm({
        * The MIME type of this resource, if known.
        */
       mimeType: optional(string2()),
+      /**
+       * The size of the raw resource content, in bytes (i.e., before base64 encoding or any tokenization), if known.
+       *
+       * This can be used by Hosts to display file sizes and estimate context window usage.
+       */
+      size: optional(number2()),
       /**
        * Optional annotations for the client.
        */
@@ -6274,12 +6285,21 @@ function deserializeMessage(line) {
 function serializeMessage(message) {
   return JSON.stringify(message) + "\n";
 }
-var ReadBuffer;
+var STDIO_DEFAULT_MAX_BUFFER_SIZE, ReadBuffer;
 var init_stdio = __esm({
   "node_modules/@modelcontextprotocol/sdk/dist/esm/shared/stdio.js"() {
     init_types();
+    STDIO_DEFAULT_MAX_BUFFER_SIZE = 10 * 1024 * 1024;
     ReadBuffer = class {
+      constructor(options) {
+        this._maxBufferSize = options?.maxBufferSize ?? STDIO_DEFAULT_MAX_BUFFER_SIZE;
+      }
       append(chunk) {
+        const newSize = (this._buffer?.length ?? 0) + chunk.length;
+        if (newSize > this._maxBufferSize) {
+          this.clear();
+          throw new Error(`ReadBuffer exceeded maximum size of ${this._maxBufferSize} bytes`);
+        }
         this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
       }
       readMessage() {
@@ -6312,18 +6332,24 @@ var init_stdio2 = __esm({
   "node_modules/@modelcontextprotocol/sdk/dist/esm/server/stdio.js"() {
     init_stdio();
     StdioServerTransport = class {
-      constructor(_stdin = process2.stdin, _stdout = process2.stdout) {
+      constructor(_stdin = process2.stdin, _stdout = process2.stdout, options) {
         this._stdin = _stdin;
         this._stdout = _stdout;
-        this._readBuffer = new ReadBuffer();
         this._started = false;
         this._ondata = (chunk) => {
-          this._readBuffer.append(chunk);
-          this.processReadBuffer();
+          try {
+            this._readBuffer.append(chunk);
+            this.processReadBuffer();
+          } catch (error2) {
+            this.onerror?.(error2);
+            this.close().catch(() => {
+            });
+          }
         };
         this._onerror = (error2) => {
           this.onerror?.(error2);
         };
+        this._readBuffer = new ReadBuffer({ maxBufferSize: options?.maxBufferSize });
       }
       /**
        * Starts listening for messages on stdin.
@@ -10669,17 +10695,33 @@ function normalizeObjectSchema(schema) {
   }
   return void 0;
 }
+function getDotPath(path) {
+  if (path.length === 0) {
+    return "object root";
+  }
+  return path.reduce((acc, seg, index) => {
+    if (index === 0) {
+      return String(seg);
+    }
+    if (typeof seg === "number") {
+      return `${acc}[${seg}]`;
+    }
+    return `${acc}.${seg}`;
+  }, "");
+}
 function getParseErrorMessage(error2) {
   if (error2 && typeof error2 === "object") {
+    if ("issues" in error2 && Array.isArray(error2.issues) && error2.issues.length > 0) {
+      return error2.issues.map((i) => {
+        if (!i.path?.length) {
+          return i.message;
+        }
+        return `${i.message} at ${getDotPath(i.path)}`;
+      }).join("\n");
+    }
     if ("message" in error2 && typeof error2.message === "string") {
       return error2.message;
     }
-    if ("issues" in error2 && Array.isArray(error2.issues) && error2.issues.length > 0) {
-      const firstIssue = error2.issues[0];
-      if (firstIssue && typeof firstIssue === "object" && "message" in firstIssue) {
-        return String(firstIssue.message);
-      }
-    }
     try {
       return JSON.stringify(error2);
     } catch {
@@ -12604,6 +12646,10 @@ var init_protocol = __esm({
         this._progressHandlers.clear();
         this._taskProgressTokens.clear();
         this._pendingDebouncedNotifications.clear();
+        for (const info of this._timeoutInfo.values()) {
+          clearTimeout(info.timeoutId);
+        }
+        this._timeoutInfo.clear();
         for (const controller of this._requestHandlerAbortControllers.values()) {
           controller.abort();
         }
@@ -12734,7 +12780,9 @@ var init_protocol = __esm({
             await capturedTransport?.send(errorResponse);
           }
         }).catch((error2) => this._onerror(new Error(`Failed to send response: ${error2}`))).finally(() => {
-          this._requestHandlerAbortControllers.delete(request.id);
+          if (this._requestHandlerAbortControllers.get(request.id) === abortController) {
+            this._requestHandlerAbortControllers.delete(request.id);
+          }
         });
       }
       _onprogress(notification) {
@@ -20895,16 +20943,7 @@ var init_server2 = __esm({
         if (!methodSchema) {
           throw new Error("Schema is missing a method literal");
         }
-        let methodValue;
-        if (isZ4Schema(methodSchema)) {
-          const v4Schema = methodSchema;
-          const v4Def = v4Schema._zod?.def;
-          methodValue = v4Def?.value ?? v4Schema.value;
-        } else {
-          const v3Schema = methodSchema;
-          const legacyDef = v3Schema._def;
-          methodValue = legacyDef?.value ?? v3Schema.value;
-        }
+        const methodValue = getLiteralValue(methodSchema);
         if (typeof methodValue !== "string") {
           throw new Error("Schema method literal must be a string");
         }
@@ -21352,6 +21391,9 @@ function getZodSchemaObject(schema) {
   if (isZodRawShapeCompat(schema)) {
     return objectFromShape(schema);
   }
+  if (!isZodSchemaInstance(schema)) {
+    throw new Error("inputSchema must be a Zod schema or raw shape, received an unrecognized object");
+  }
   return schema;
 }
 function promptArgumentsFromSchema(schema) {
@@ -22024,6 +22066,9 @@ var init_mcp = __esm({
               annotations = rest.shift();
             }
           } else if (typeof firstArg === "object" && firstArg !== null) {
+            if (Object.values(firstArg).some((v) => typeof v === "object" && v !== null)) {
+              throw new Error(`Tool ${name} expected a Zod schema or ToolAnnotations, but received an unrecognized object`);
+            }
             annotations = rest.shift();
           }
         }
@@ -22126,614 +22171,6 @@ var init_mcp = __esm({
   }
 });
 
-// node_modules/@modelcontextprotocol/sdk/dist/esm/server/webStandardStreamableHttp.js
-var WebStandardStreamableHTTPServerTransport;
-var init_webStandardStreamableHttp = __esm({
-  "node_modules/@modelcontextprotocol/sdk/dist/esm/server/webStandardStreamableHttp.js"() {
-    init_types();
-    WebStandardStreamableHTTPServerTransport = class {
-      constructor(options = {}) {
-        this._started = false;
-        this._hasHandledRequest = false;
-        this._streamMapping = /* @__PURE__ */ new Map();
-        this._requestToStreamMapping = /* @__PURE__ */ new Map();
-        this._requestResponseMap = /* @__PURE__ */ new Map();
-        this._initialized = false;
-        this._enableJsonResponse = false;
-        this._standaloneSseStreamId = "_GET_stream";
-        this.sessionIdGenerator = options.sessionIdGenerator;
-        this._enableJsonResponse = options.enableJsonResponse ?? false;
-        this._eventStore = options.eventStore;
-        this._onsessioninitialized = options.onsessioninitialized;
-        this._onsessionclosed = options.onsessionclosed;
-        this._allowedHosts = options.allowedHosts;
-        this._allowedOrigins = options.allowedOrigins;
-        this._enableDnsRebindingProtection = options.enableDnsRebindingProtection ?? false;
-        this._retryInterval = options.retryInterval;
-      }
-      /**
-       * Starts the transport. This is required by the Transport interface but is a no-op
-       * for the Streamable HTTP transport as connections are managed per-request.
-       */
-      async start() {
-        if (this._started) {
-          throw new Error("Transport already started");
-        }
-        this._started = true;
-      }
-      /**
-       * Helper to create a JSON error response
-       */
-      createJsonErrorResponse(status, code, message, options) {
-        const error2 = { code, message };
-        if (options?.data !== void 0) {
-          error2.data = options.data;
-        }
-        return new Response(JSON.stringify({
-          jsonrpc: "2.0",
-          error: error2,
-          id: null
-        }), {
-          status,
-          headers: {
-            "Content-Type": "application/json",
-            ...options?.headers
-          }
-        });
-      }
-      /**
-       * Validates request headers for DNS rebinding protection.
-       * @returns Error response if validation fails, undefined if validation passes.
-       */
-      validateRequestHeaders(req) {
-        if (!this._enableDnsRebindingProtection) {
-          return void 0;
-        }
-        if (this._allowedHosts && this._allowedHosts.length > 0) {
-          const hostHeader = req.headers.get("host");
-          if (!hostHeader || !this._allowedHosts.includes(hostHeader)) {
-            const error2 = `Invalid Host header: ${hostHeader}`;
-            this.onerror?.(new Error(error2));
-            return this.createJsonErrorResponse(403, -32e3, error2);
-          }
-        }
-        if (this._allowedOrigins && this._allowedOrigins.length > 0) {
-          const originHeader = req.headers.get("origin");
-          if (originHeader && !this._allowedOrigins.includes(originHeader)) {
-            const error2 = `Invalid Origin header: ${originHeader}`;
-            this.onerror?.(new Error(error2));
-            return this.createJsonErrorResponse(403, -32e3, error2);
-          }
-        }
-        return void 0;
-      }
-      /**
-       * Handles an incoming HTTP request, whether GET, POST, or DELETE
-       * Returns a Response object (Web Standard)
-       */
-      async handleRequest(req, options) {
-        if (!this.sessionIdGenerator && this._hasHandledRequest) {
-          throw new Error("Stateless transport cannot be reused across requests. Create a new transport per request.");
-        }
-        this._hasHandledRequest = true;
-        const validationError = this.validateRequestHeaders(req);
-        if (validationError) {
-          return validationError;
-        }
-        switch (req.method) {
-          case "POST":
-            return this.handlePostRequest(req, options);
-          case "GET":
-            return this.handleGetRequest(req);
-          case "DELETE":
-            return this.handleDeleteRequest(req);
-          default:
-            return this.handleUnsupportedRequest();
-        }
-      }
-      /**
-       * Writes a priming event to establish resumption capability.
-       * Only sends if eventStore is configured (opt-in for resumability) and
-       * the client's protocol version supports empty SSE data (>= 2025-11-25).
-       */
-      async writePrimingEvent(controller, encoder, streamId, protocolVersion) {
-        if (!this._eventStore) {
-          return;
-        }
-        if (protocolVersion < "2025-11-25") {
-          return;
-        }
-        const primingEventId = await this._eventStore.storeEvent(streamId, {});
-        let primingEvent = `id: ${primingEventId}
-data: 
-
-`;
-        if (this._retryInterval !== void 0) {
-          primingEvent = `id: ${primingEventId}
-retry: ${this._retryInterval}
-data: 
-
-`;
-        }
-        controller.enqueue(encoder.encode(primingEvent));
-      }
-      /**
-       * Handles GET requests for SSE stream
-       */
-      async handleGetRequest(req) {
-        const acceptHeader = req.headers.get("accept");
-        if (!acceptHeader?.includes("text/event-stream")) {
-          this.onerror?.(new Error("Not Acceptable: Client must accept text/event-stream"));
-          return this.createJsonErrorResponse(406, -32e3, "Not Acceptable: Client must accept text/event-stream");
-        }
-        const sessionError = this.validateSession(req);
-        if (sessionError) {
-          return sessionError;
-        }
-        const protocolError = this.validateProtocolVersion(req);
-        if (protocolError) {
-          return protocolError;
-        }
-        if (this._eventStore) {
-          const lastEventId = req.headers.get("last-event-id");
-          if (lastEventId) {
-            return this.replayEvents(lastEventId);
-          }
-        }
-        if (this._streamMapping.get(this._standaloneSseStreamId) !== void 0) {
-          this.onerror?.(new Error("Conflict: Only one SSE stream is allowed per session"));
-          return this.createJsonErrorResponse(409, -32e3, "Conflict: Only one SSE stream is allowed per session");
-        }
-        const encoder = new TextEncoder();
-        let streamController;
-        const readable = new ReadableStream({
-          start: (controller) => {
-            streamController = controller;
-          },
-          cancel: () => {
-            this._streamMapping.delete(this._standaloneSseStreamId);
-          }
-        });
-        const headers = {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache, no-transform",
-          Connection: "keep-alive"
-        };
-        if (this.sessionId !== void 0) {
-          headers["mcp-session-id"] = this.sessionId;
-        }
-        this._streamMapping.set(this._standaloneSseStreamId, {
-          controller: streamController,
-          encoder,
-          cleanup: () => {
-            this._streamMapping.delete(this._standaloneSseStreamId);
-            try {
-              streamController.close();
-            } catch {
-            }
-          }
-        });
-        return new Response(readable, { headers });
-      }
-      /**
-       * Replays events that would have been sent after the specified event ID
-       * Only used when resumability is enabled
-       */
-      async replayEvents(lastEventId) {
-        if (!this._eventStore) {
-          this.onerror?.(new Error("Event store not configured"));
-          return this.createJsonErrorResponse(400, -32e3, "Event store not configured");
-        }
-        try {
-          let streamId;
-          if (this._eventStore.getStreamIdForEventId) {
-            streamId = await this._eventStore.getStreamIdForEventId(lastEventId);
-            if (!streamId) {
-              this.onerror?.(new Error("Invalid event ID format"));
-              return this.createJsonErrorResponse(400, -32e3, "Invalid event ID format");
-            }
-            if (this._streamMapping.get(streamId) !== void 0) {
-              this.onerror?.(new Error("Conflict: Stream already has an active connection"));
-              return this.createJsonErrorResponse(409, -32e3, "Conflict: Stream already has an active connection");
-            }
-          }
-          const headers = {
-            "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache, no-transform",
-            Connection: "keep-alive"
-          };
-          if (this.sessionId !== void 0) {
-            headers["mcp-session-id"] = this.sessionId;
-          }
-          const encoder = new TextEncoder();
-          let streamController;
-          const readable = new ReadableStream({
-            start: (controller) => {
-              streamController = controller;
-            },
-            cancel: () => {
-            }
-          });
-          const replayedStreamId = await this._eventStore.replayEventsAfter(lastEventId, {
-            send: async (eventId, message) => {
-              const success = this.writeSSEEvent(streamController, encoder, message, eventId);
-              if (!success) {
-                this.onerror?.(new Error("Failed replay events"));
-                try {
-                  streamController.close();
-                } catch {
-                }
-              }
-            }
-          });
-          this._streamMapping.set(replayedStreamId, {
-            controller: streamController,
-            encoder,
-            cleanup: () => {
-              this._streamMapping.delete(replayedStreamId);
-              try {
-                streamController.close();
-              } catch {
-              }
-            }
-          });
-          return new Response(readable, { headers });
-        } catch (error2) {
-          this.onerror?.(error2);
-          return this.createJsonErrorResponse(500, -32e3, "Error replaying events");
-        }
-      }
-      /**
-       * Writes an event to an SSE stream via controller with proper formatting
-       */
-      writeSSEEvent(controller, encoder, message, eventId) {
-        try {
-          let eventData = `event: message
-`;
-          if (eventId) {
-            eventData += `id: ${eventId}
-`;
-          }
-          eventData += `data: ${JSON.stringify(message)}
-
-`;
-          controller.enqueue(encoder.encode(eventData));
-          return true;
-        } catch (error2) {
-          this.onerror?.(error2);
-          return false;
-        }
-      }
-      /**
-       * Handles unsupported requests (PUT, PATCH, etc.)
-       */
-      handleUnsupportedRequest() {
-        this.onerror?.(new Error("Method not allowed."));
-        return new Response(JSON.stringify({
-          jsonrpc: "2.0",
-          error: {
-            code: -32e3,
-            message: "Method not allowed."
-          },
-          id: null
-        }), {
-          status: 405,
-          headers: {
-            Allow: "GET, POST, DELETE",
-            "Content-Type": "application/json"
-          }
-        });
-      }
-      /**
-       * Handles POST requests containing JSON-RPC messages
-       */
-      async handlePostRequest(req, options) {
-        try {
-          const acceptHeader = req.headers.get("accept");
-          if (!acceptHeader?.includes("application/json") || !acceptHeader.includes("text/event-stream")) {
-            this.onerror?.(new Error("Not Acceptable: Client must accept both application/json and text/event-stream"));
-            return this.createJsonErrorResponse(406, -32e3, "Not Acceptable: Client must accept both application/json and text/event-stream");
-          }
-          const ct = req.headers.get("content-type");
-          if (!ct || !ct.includes("application/json")) {
-            this.onerror?.(new Error("Unsupported Media Type: Content-Type must be application/json"));
-            return this.createJsonErrorResponse(415, -32e3, "Unsupported Media Type: Content-Type must be application/json");
-          }
-          const requestInfo = {
-            headers: Object.fromEntries(req.headers.entries()),
-            url: new URL(req.url)
-          };
-          let rawMessage;
-          if (options?.parsedBody !== void 0) {
-            rawMessage = options.parsedBody;
-          } else {
-            try {
-              rawMessage = await req.json();
-            } catch {
-              this.onerror?.(new Error("Parse error: Invalid JSON"));
-              return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON");
-            }
-          }
-          let messages;
-          try {
-            if (Array.isArray(rawMessage)) {
-              messages = rawMessage.map((msg) => JSONRPCMessageSchema.parse(msg));
-            } else {
-              messages = [JSONRPCMessageSchema.parse(rawMessage)];
-            }
-          } catch {
-            this.onerror?.(new Error("Parse error: Invalid JSON-RPC message"));
-            return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON-RPC message");
-          }
-          const isInitializationRequest = messages.some(isInitializeRequest);
-          if (isInitializationRequest) {
-            if (this._initialized && this.sessionId !== void 0) {
-              this.onerror?.(new Error("Invalid Request: Server already initialized"));
-              return this.createJsonErrorResponse(400, -32600, "Invalid Request: Server already initialized");
-            }
-            if (messages.length > 1) {
-              this.onerror?.(new Error("Invalid Request: Only one initialization request is allowed"));
-              return this.createJsonErrorResponse(400, -32600, "Invalid Request: Only one initialization request is allowed");
-            }
-            this.sessionId = this.sessionIdGenerator?.();
-            this._initialized = true;
-            if (this.sessionId && this._onsessioninitialized) {
-              await Promise.resolve(this._onsessioninitialized(this.sessionId));
-            }
-          }
-          if (!isInitializationRequest) {
-            const sessionError = this.validateSession(req);
-            if (sessionError) {
-              return sessionError;
-            }
-            const protocolError = this.validateProtocolVersion(req);
-            if (protocolError) {
-              return protocolError;
-            }
-          }
-          const hasRequests = messages.some(isJSONRPCRequest);
-          if (!hasRequests) {
-            for (const message of messages) {
-              this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo });
-            }
-            return new Response(null, { status: 202 });
-          }
-          const streamId = crypto.randomUUID();
-          const initRequest = messages.find((m) => isInitializeRequest(m));
-          const clientProtocolVersion = initRequest ? initRequest.params.protocolVersion : req.headers.get("mcp-protocol-version") ?? DEFAULT_NEGOTIATED_PROTOCOL_VERSION;
-          if (this._enableJsonResponse) {
-            return new Promise((resolve2) => {
-              this._streamMapping.set(streamId, {
-                resolveJson: resolve2,
-                cleanup: () => {
-                  this._streamMapping.delete(streamId);
-                }
-              });
-              for (const message of messages) {
-                if (isJSONRPCRequest(message)) {
-                  this._requestToStreamMapping.set(message.id, streamId);
-                }
-              }
-              for (const message of messages) {
-                this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo });
-              }
-            });
-          }
-          const encoder = new TextEncoder();
-          let streamController;
-          const readable = new ReadableStream({
-            start: (controller) => {
-              streamController = controller;
-            },
-            cancel: () => {
-              this._streamMapping.delete(streamId);
-            }
-          });
-          const headers = {
-            "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache",
-            Connection: "keep-alive"
-          };
-          if (this.sessionId !== void 0) {
-            headers["mcp-session-id"] = this.sessionId;
-          }
-          for (const message of messages) {
-            if (isJSONRPCRequest(message)) {
-              this._streamMapping.set(streamId, {
-                controller: streamController,
-                encoder,
-                cleanup: () => {
-                  this._streamMapping.delete(streamId);
-                  try {
-                    streamController.close();
-                  } catch {
-                  }
-                }
-              });
-              this._requestToStreamMapping.set(message.id, streamId);
-            }
-          }
-          await this.writePrimingEvent(streamController, encoder, streamId, clientProtocolVersion);
-          for (const message of messages) {
-            let closeSSEStream;
-            let closeStandaloneSSEStream;
-            if (isJSONRPCRequest(message) && this._eventStore && clientProtocolVersion >= "2025-11-25") {
-              closeSSEStream = () => {
-                this.closeSSEStream(message.id);
-              };
-              closeStandaloneSSEStream = () => {
-                this.closeStandaloneSSEStream();
-              };
-            }
-            this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo, closeSSEStream, closeStandaloneSSEStream });
-          }
-          return new Response(readable, { status: 200, headers });
-        } catch (error2) {
-          this.onerror?.(error2);
-          return this.createJsonErrorResponse(400, -32700, "Parse error", { data: String(error2) });
-        }
-      }
-      /**
-       * Handles DELETE requests to terminate sessions
-       */
-      async handleDeleteRequest(req) {
-        const sessionError = this.validateSession(req);
-        if (sessionError) {
-          return sessionError;
-        }
-        const protocolError = this.validateProtocolVersion(req);
-        if (protocolError) {
-          return protocolError;
-        }
-        await Promise.resolve(this._onsessionclosed?.(this.sessionId));
-        await this.close();
-        return new Response(null, { status: 200 });
-      }
-      /**
-       * Validates session ID for non-initialization requests.
-       * Returns Response error if invalid, undefined otherwise
-       */
-      validateSession(req) {
-        if (this.sessionIdGenerator === void 0) {
-          return void 0;
-        }
-        if (!this._initialized) {
-          this.onerror?.(new Error("Bad Request: Server not initialized"));
-          return this.createJsonErrorResponse(400, -32e3, "Bad Request: Server not initialized");
-        }
-        const sessionId = req.headers.get("mcp-session-id");
-        if (!sessionId) {
-          this.onerror?.(new Error("Bad Request: Mcp-Session-Id header is required"));
-          return this.createJsonErrorResponse(400, -32e3, "Bad Request: Mcp-Session-Id header is required");
-        }
-        if (sessionId !== this.sessionId) {
-          this.onerror?.(new Error("Session not found"));
-          return this.createJsonErrorResponse(404, -32001, "Session not found");
-        }
-        return void 0;
-      }
-      /**
-       * Validates the MCP-Protocol-Version header on incoming requests.
-       *
-       * For initialization: Version negotiation handles unknown versions gracefully
-       * (server responds with its supported version).
-       *
-       * For subsequent requests with MCP-Protocol-Version header:
-       * - Accept if in supported list
-       * - 400 if unsupported
-       *
-       * For HTTP requests without the MCP-Protocol-Version header:
-       * - Accept and default to the version negotiated at initialization
-       */
-      validateProtocolVersion(req) {
-        const protocolVersion = req.headers.get("mcp-protocol-version");
-        if (protocolVersion !== null && !SUPPORTED_PROTOCOL_VERSIONS.includes(protocolVersion)) {
-          this.onerror?.(new Error(`Bad Request: Unsupported protocol version: ${protocolVersion} (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`));
-          return this.createJsonErrorResponse(400, -32e3, `Bad Request: Unsupported protocol version: ${protocolVersion} (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`);
-        }
-        return void 0;
-      }
-      async close() {
-        this._streamMapping.forEach(({ cleanup }) => {
-          cleanup();
-        });
-        this._streamMapping.clear();
-        this._requestResponseMap.clear();
-        this.onclose?.();
-      }
-      /**
-       * Close an SSE stream for a specific request, triggering client reconnection.
-       * Use this to implement polling behavior during long-running operations -
-       * client will reconnect after the retry interval specified in the priming event.
-       */
-      closeSSEStream(requestId) {
-        const streamId = this._requestToStreamMapping.get(requestId);
-        if (!streamId)
-          return;
-        const stream = this._streamMapping.get(streamId);
-        if (stream) {
-          stream.cleanup();
-        }
-      }
-      /**
-       * Close the standalone GET SSE stream, triggering client reconnection.
-       * Use this to implement polling behavior for server-initiated notifications.
-       */
-      closeStandaloneSSEStream() {
-        const stream = this._streamMapping.get(this._standaloneSseStreamId);
-        if (stream) {
-          stream.cleanup();
-        }
-      }
-      async send(message, options) {
-        let requestId = options?.relatedRequestId;
-        if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
-          requestId = message.id;
-        }
-        if (requestId === void 0) {
-          if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
-            throw new Error("Cannot send a response on a standalone SSE stream unless resuming a previous client request");
-          }
-          let eventId;
-          if (this._eventStore) {
-            eventId = await this._eventStore.storeEvent(this._standaloneSseStreamId, message);
-          }
-          const standaloneSse = this._streamMapping.get(this._standaloneSseStreamId);
-          if (standaloneSse === void 0) {
-            return;
-          }
-          if (standaloneSse.controller && standaloneSse.encoder) {
-            this.writeSSEEvent(standaloneSse.controller, standaloneSse.encoder, message, eventId);
-          }
-          return;
-        }
-        const streamId = this._requestToStreamMapping.get(requestId);
-        if (!streamId) {
-          throw new Error(`No connection established for request ID: ${String(requestId)}`);
-        }
-        const stream = this._streamMapping.get(streamId);
-        if (!this._enableJsonResponse && stream?.controller && stream?.encoder) {
-          let eventId;
-          if (this._eventStore) {
-            eventId = await this._eventStore.storeEvent(streamId, message);
-          }
-          this.writeSSEEvent(stream.controller, stream.encoder, message, eventId);
-        }
-        if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
-          this._requestResponseMap.set(requestId, message);
-          const relatedIds = Array.from(this._requestToStreamMapping.entries()).filter(([_, sid]) => sid === streamId).map(([id]) => id);
-          const allResponsesReady = relatedIds.every((id) => this._requestResponseMap.has(id));
-          if (allResponsesReady) {
-            if (!stream) {
-              throw new Error(`No connection established for request ID: ${String(requestId)}`);
-            }
-            if (this._enableJsonResponse && stream.resolveJson) {
-              const headers = {
-                "Content-Type": "application/json"
-              };
-              if (this.sessionId !== void 0) {
-                headers["mcp-session-id"] = this.sessionId;
-              }
-              const responses = relatedIds.map((id) => this._requestResponseMap.get(id));
-              if (responses.length === 1) {
-                stream.resolveJson(new Response(JSON.stringify(responses[0]), { status: 200, headers }));
-              } else {
-                stream.resolveJson(new Response(JSON.stringify(responses), { status: 200, headers }));
-              }
-            } else {
-              stream.cleanup();
-            }
-            for (const id of relatedIds) {
-              this._requestResponseMap.delete(id);
-              this._requestToStreamMapping.delete(id);
-            }
-          }
-        }
-      }
-    };
-  }
-});
-
 // src/api.ts
 var SquirrelApiClient;
 var init_api2 = __esm({
@@ -22987,24 +22424,11 @@ var server_exports = {};
 __export(server_exports, {
   MARKDOWN_CAPABILITIES_DESCRIPTION: () => MARKDOWN_CAPABILITIES_DESCRIPTION,
   createMcpServer: () => createMcpServer,
-  handleRequest: () => handleRequest,
   inferMimeType: () => inferMimeType
 });
 import { readFile } from "node:fs/promises";
 import { basename, extname, resolve, sep } from "node:path";
 import { tmpdir } from "node:os";
-function emitAuditEvent(event) {
-  if (!AUDIT_INTERNAL_SECRET) return;
-  fetch(`${SQUIRREL_API_BASE_URL}/audit/internal`, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      "x-audit-internal-secret": AUDIT_INTERNAL_SECRET
-    },
-    body: JSON.stringify(event)
-  }).catch(() => {
-  });
-}
 async function buildContext(creds) {
   const client = new SquirrelApiClient(SQUIRREL_API_BASE_URL, creds.apiKey);
   const { salt, keyCheck, wrappedDek, dekIv } = await client.getEncryption();
@@ -23020,7 +22444,6 @@ async function buildContext(creds) {
   } else {
     throw new Error("Inconsistent encryption metadata from server: wrappedDek/dekIv mismatch");
   }
-  emitAuditEvent({ eventType: "auth.mcp.access", authMethod: "mcp", outcome: "success" });
   return { client, key };
 }
 function decryptNoteTitle(note, key) {
@@ -23979,29 +23402,11 @@ function createMcpServer(creds, opts = {}) {
   }
   return server2;
 }
-async function handleRequest(event, creds) {
-  const server2 = createMcpServer(creds);
-  const transport2 = new WebStandardStreamableHTTPServerTransport({ sessionIdGenerator: void 0 });
-  await server2.connect(transport2);
-  const request = new Request("https://lambda/mcp", {
-    method: "POST",
-    headers: event.headers,
-    body: event.body ?? ""
-  });
-  const response = await transport2.handleRequest(request);
-  const responseBody = await response.text();
-  const responseHeaders = {};
-  response.headers.forEach((value, key) => {
-    responseHeaders[key] = value;
-  });
-  return { statusCode: response.status, headers: responseHeaders, body: responseBody };
-}
-var SQUIRREL_API_BASE_URL, AUDIT_INTERNAL_SECRET, MIME_TYPES, MARKDOWN_CAPABILITIES_DESCRIPTION;
+var SQUIRREL_API_BASE_URL, MIME_TYPES, MARKDOWN_CAPABILITIES_DESCRIPTION;
 var init_server3 = __esm({
   "src/server.ts"() {
     "use strict";
     init_mcp();
-    init_webStandardStreamableHttp();
     init_zod();
     init_api2();
     init_crypto();
@@ -24010,7 +23415,6 @@ var init_server3 = __esm({
     if (!SQUIRREL_API_BASE_URL) {
       throw new Error("SQUIRREL_API_BASE_URL environment variable is required");
     }
-    AUDIT_INTERNAL_SECRET = process.env.AUDIT_INTERNAL_SECRET;
     MIME_TYPES = {
       png: "image/png",
       jpg: "image/jpeg",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squirrelnotes.app/mcp",
-  "version": "2.0.1",
+  "version": "2.1.0",
   "description": "MCP stdio CLI for Squirrel Notes — bridges AI agents to the encrypted note-taking API",
   "type": "module",
   "bin": {
@@ -14,10 +14,8 @@
     "access": "public"
   },
   "scripts": {
-    "build": "esbuild src/handler.ts --bundle --platform=node --target=node20 --outfile=dist/handler.js --format=cjs --external:aws-sdk",
+    "build": "npm run build:stdio",
     "build:stdio": "esbuild src/stdio-handler.ts --bundle --platform=node --target=node20 --outfile=dist/stdio-handler.js --format=esm --banner:js='#!/usr/bin/env node'",
-    "build:all": "npm run build && npm run build:stdio",
-    "dev": "SQUIRREL_API_BASE_URL=http://localhost:3001 tsx src/dev-server.ts",
     "test": "node --experimental-vm-modules node_modules/.bin/jest",
     "lint": "tsc --noEmit"
   },
@@ -26,13 +24,11 @@
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@types/aws-lambda": "^8.10.145",
     "@types/jest": "^30.0.0",
     "@types/node": "^20.0.0",
     "esbuild": "^0.28.1",
     "jest": "^29.7.0",
     "ts-jest": "^29.1.5",
-    "tsx": "^4.21.0",
     "typescript": "^5.4.5"
   },
   "jest": {