@yawlabs/lemonsqueezy-mcp 0.10.6 → 0.10.8

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 All notable changes to `@yawlabs/lemonsqueezy-mcp` are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and versioning follows [SEMVER.md](./SEMVER.md).
 
+## [0.10.8] -- 2026-05-19
+
+### Security
+
+- **Sink response body size guard extended to the error branch.** `sinkRequest` in `src/tools/sink.ts` previously only size-checked 2xx response bodies; a misbehaving sink returning a giant 4xx/5xx body could still buffer the whole thing into memory before any limit fired. A new `readBodyOrSizeError` helper pre-checks `Content-Length` against the 10 MB cap and is applied to both the error and success branches. The post-read length check on the 2xx path is retained as belt-and-braces against a lying `Content-Length`.
+
+### Changed
+
+- **2xx body-read mid-stream failures now collapse to the uniform `{ ok: false, error }` shape.** Previously a socket reset partway through reading the body propagated as an exception out of `sinkRequest`, surfacing as a less-informative error via the wrapper's catch-all. The 2xx body read is now wrapped in a try/catch that returns `Sink response body read failed: <message>` -- consistent with every other failure mode in the function.
+- **`src/secret.ts` cache-hit branch tightened.** The test-mode cache-hit branch previously called `announceTestModeOnce()` redundantly (the flag is set on the first miss, so the cache-hit call was dead). Removed the call and the now-obsolete defensive comment.
+
+### Tests
+
+- **Sink coverage expanded** to pin `authorityClass` per tool (`read` for `ls_sink_events_list` / `ls_sink_stats`, `mutate` for `ls_sink_event_mark_processed`), 4xx-oversized-Content-Length, 2xx-lying-Content-Length, and 2xx mid-stream body-read failures. `stubFetch` gained an optional `responseHeaders` field so error-branch tests no longer override `globalThis.fetch` inline.
+- **`parseCommand` contract pinned** in `src/secret.test.ts` for the four tokenizer edges that the rest of the suite only touched by accident: unterminated quote, all-quotes-collapse-to-empty, quoted-args-with-spaces (both quote styles), and quote-then-bare-word concatenation. Also added a 64 KB `maxBuffer` overflow test that exercises the `execFile` `ERR_CHILD_PROCESS_STDIO_MAXBUFFER` rewrap path.
+
+## [0.10.7] -- 2026-05-16
+
+### Security
+
+- **Allowlist-bypass surface closed at the test layer.** `checkStoreScopedToolInput` in `src/wrapper.ts` enforces `LEMONSQUEEZY_ALLOWED_STORE_IDS` by reading the literal input field name `storeId` from the tool's Zod shape. Today every list tool that filters by store happens to use that name, but the convention wasn't asserted anywhere -- a future tool whose filterMap mapped a differently-named input (e.g. `store`) to `filter[store_id]` would silently bypass the allowlist. `src/api.ts` `listHandler` now exposes its `filterMap` on the returned handler, and `src/tools/tools.test.ts` adds an invariant that fails CI for any drift between the filter key (`store_id`) and the input field name (`storeId`).
+
+### Changed
+
+- **`wrapper.ts` skips the success/error entry literal when no consumer wants it.** A non-destructive read at `LEMONSQUEEZY_LOG` unset (i.e. "off") previously built a full audit entry on every call, then `logEvent` discarded it inside its level check. Now the wrapper consults `wouldLogToolCall({ isDestructive, isError })` -- a new export from `src/logger.ts` -- before allocating. Destructive calls always build the entry because the audit-buffer push is independent of the log level. No observable behavior change; saves a small object literal per non-destructive read on the most common configuration.
+
 ## [0.10.6] -- 2026-05-16
 
 ### Security
@@ -333,7 +359,9 @@ Hardening pass for unattended automation against live billing flows.
 
 Initial release. 59 tools covering all 17 LemonSqueezy API resources.
 
-[Unreleased]: https://github.com/YawLabs/lemonsqueezy-mcp/compare/v0.10.6...HEAD
+[Unreleased]: https://github.com/YawLabs/lemonsqueezy-mcp/compare/v0.10.8...HEAD
+[0.10.8]: https://github.com/YawLabs/lemonsqueezy-mcp/compare/v0.10.7...v0.10.8
+[0.10.7]: https://github.com/YawLabs/lemonsqueezy-mcp/compare/v0.10.6...v0.10.7
 [0.10.6]: https://github.com/YawLabs/lemonsqueezy-mcp/compare/v0.10.5...v0.10.6
 [0.10.5]: https://github.com/YawLabs/lemonsqueezy-mcp/compare/v0.10.4...v0.10.5
 [0.10.4]: https://github.com/YawLabs/lemonsqueezy-mcp/compare/v0.10.3...v0.10.4

package/dist/index.js

@@ -30410,6 +30410,19 @@ function shouldLog(entry, level) {
       return isErrorEntry(entry);
   }
 }
+function wouldLogToolCall(opts) {
+  const level = getLogLevel();
+  switch (level) {
+    case "off":
+      return false;
+    case "all":
+      return true;
+    case "audit":
+      return opts.isDestructive || opts.isError;
+    case "error":
+      return opts.isError;
+  }
+}
 function safeString(value) {
   if (value === void 0) return void 0;
   if (typeof value === "string") return value;
@@ -30640,10 +30653,7 @@ async function loadApiKey() {
   if (testRaw && testRaw.trim() !== "") {
     const fingerprint2 = fingerprintFor("test", testRaw);
     const hit2 = fromCache(fingerprint2);
-    if (hit2 !== null) {
-      announceTestModeOnce();
-      return hit2;
-    }
+    if (hit2 !== null) return hit2;
     announceTestModeOnce();
     intoCache(fingerprint2, testRaw);
     return testRaw;
@@ -30886,7 +30896,7 @@ function getHandler(endpoint, idField) {
   };
 }
 function listHandler(endpoint, filterMap = {}) {
-  return async (input) => {
+  const handler = async (input) => {
     const filter = {};
     for (const [inputKey, apiKey] of Object.entries(filterMap)) {
       const val = input[inputKey];
@@ -30899,6 +30909,7 @@ function listHandler(endpoint, filterMap = {}) {
     });
     return apiGet(`${endpoint}${query}`);
   };
+  return Object.assign(handler, { filterMap });
 }
 async function apiGet(path) {
   return apiRequest("GET", path);
@@ -31849,6 +31860,16 @@ function loadSinkConfig() {
 function isToolHandlerResponse(value) {
   return "ok" in value;
 }
+async function readBodyOrSizeError(res) {
+  const contentLength = res.headers.get("content-length");
+  if (contentLength) {
+    const declared = Number.parseInt(contentLength, 10);
+    if (Number.isFinite(declared) && declared > MAX_BODY_SIZE_BYTES) {
+      return { ok: false, declared };
+    }
+  }
+  return { ok: true, text: await res.text() };
+}
 function buildSinkPath(path, params) {
   const parts = [];
   for (const [k, v] of Object.entries(params)) {
@@ -31883,7 +31904,12 @@ async function sinkRequest(config2, method, pathAndQuery) {
   if (!res.ok) {
     let body = "";
     try {
-      body = await res.text();
+      const readResult2 = await readBodyOrSizeError(res);
+      if (readResult2.ok) {
+        body = readResult2.text;
+      } else {
+        body = `[body too large: ${readResult2.declared} bytes exceeds ${MAX_BODY_SIZE_BYTES} byte limit]`;
+      }
     } catch {
     }
     let detail = body;
@@ -31909,7 +31935,20 @@ async function sinkRequest(config2, method, pathAndQuery) {
       error: `Sink returned ${res.status}: ${detail || res.statusText}`
     };
   }
-  const text = await res.text();
+  let readResult;
+  try {
+    readResult = await readBodyOrSizeError(res);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: `Sink response body read failed: ${message}` };
+  }
+  if (!readResult.ok) {
+    return {
+      ok: false,
+      error: `Sink response body too large: ${readResult.declared} bytes exceeds ${MAX_BODY_SIZE_BYTES} byte limit`
+    };
+  }
+  const text = readResult.text;
   if (!text.trim()) return { ok: true, data: {} };
   if (text.length > MAX_BODY_SIZE_BYTES) {
     return {
@@ -32719,19 +32758,22 @@ function createToolHandler(tool) {
       checkStoreScopedToolInput(toolAsRecord, inputAsRecord);
       const response = await tool.handler(input);
       const latency_ms = Date.now() - start;
-      const successEntry = {
-        event: "tool_call",
-        tool: tool.name,
-        status: response.ok ? "ok" : "error",
-        latency_ms,
-        request_id: response.requestId,
-        error: response.ok ? void 0 : response.error,
-        audit: isDestructive ? true : void 0,
-        inputs: isDestructive ? redactSecrets(input) : void 0
-      };
-      logEvent(successEntry);
-      if (isDestructive) {
-        pushAuditEntry({ ts: (/* @__PURE__ */ new Date()).toISOString(), ...successEntry });
+      const wouldLog = wouldLogToolCall({ isDestructive, isError: !response.ok });
+      if (wouldLog || isDestructive) {
+        const successEntry = {
+          event: "tool_call",
+          tool: tool.name,
+          status: response.ok ? "ok" : "error",
+          latency_ms,
+          request_id: response.requestId,
+          error: response.ok ? void 0 : response.error,
+          audit: isDestructive ? true : void 0,
+          inputs: isDestructive ? redactSecrets(input) : void 0
+        };
+        if (wouldLog) logEvent(successEntry);
+        if (isDestructive) {
+          pushAuditEntry({ ts: (/* @__PURE__ */ new Date()).toISOString(), ...successEntry });
+        }
       }
       if (!response.ok) {
         return {
@@ -32751,18 +32793,21 @@ function createToolHandler(tool) {
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       const latency_ms = Date.now() - start;
-      const errorEntry = {
-        event: "tool_call",
-        tool: tool.name,
-        status: err instanceof GuardrailError ? "guardrail_block" : "exception",
-        latency_ms,
-        error: message,
-        audit: isDestructive ? true : void 0,
-        inputs: isDestructive ? redactSecrets(input) : void 0
-      };
-      logEvent(errorEntry);
-      if (isDestructive) {
-        pushAuditEntry({ ts: (/* @__PURE__ */ new Date()).toISOString(), ...errorEntry });
+      const wouldLog = wouldLogToolCall({ isDestructive, isError: true });
+      if (wouldLog || isDestructive) {
+        const errorEntry = {
+          event: "tool_call",
+          tool: tool.name,
+          status: err instanceof GuardrailError ? "guardrail_block" : "exception",
+          latency_ms,
+          error: message,
+          audit: isDestructive ? true : void 0,
+          inputs: isDestructive ? redactSecrets(input) : void 0
+        };
+        if (wouldLog) logEvent(errorEntry);
+        if (isDestructive) {
+          pushAuditEntry({ ts: (/* @__PURE__ */ new Date()).toISOString(), ...errorEntry });
+        }
       }
       return {
         content: [{ type: "text", text: `Error: ${message}` }],
@@ -32786,7 +32831,7 @@ function readAuditLogResource(uri) {
 }
 
 // src/index.ts
-var version2 = true ? "0.10.6" : (await null).createRequire(import.meta.url)("../package.json").version;
+var version2 = true ? "0.10.8" : (await null).createRequire(import.meta.url)("../package.json").version;
 var subcommand = process.argv[2];
 if (subcommand === "version" || subcommand === "--version") {
   console.log(version2);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yawlabs/lemonsqueezy-mcp",
-  "version": "0.10.6",
+  "version": "0.10.8",
   "mcpName": "io.github.YawLabs/lemonsqueezy-mcp",
   "description": "LemonSqueezy MCP server for managing your store from AI assistants",
   "license": "MIT",