@valbuild/mcp 0.123.0

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@valbuild/mcp",
+  "private": false,
+  "description": "Val - content tools for MCP hosts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/valbuild/val.git"
+  },
+  "main": "dist/valbuild-mcp.cjs.js",
+  "module": "dist/valbuild-mcp.esm.js",
+  "exports": {
+    ".": {
+      "module": "./dist/valbuild-mcp.esm.js",
+      "default": "./dist/valbuild-mcp.cjs.js"
+    },
+    "./sharp": {
+      "module": "./sharp/dist/valbuild-mcp-sharp.esm.js",
+      "default": "./sharp/dist/valbuild-mcp-sharp.cjs.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "types": "dist/valbuild-mcp.cjs.d.ts",
+  "version": "0.123.0",
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "preconstruct": {
+    "entrypoints": [
+      "./index.ts",
+      "./sharp/index.ts"
+    ],
+    "exports": true
+  },
+  "dependencies": {
+    "@valbuild/core": "workspace:*",
+    "@valbuild/server": "workspace:*",
+    "@valbuild/shared": "workspace:*",
+    "minimatch": "^10.2.6",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@prettier/sync": "^0.6.1",
+    "@types/jest": "^30.0.0",
+    "prettier": "~3.8.5",
+    "sharp": "^0.35.4",
+    "sucrase": "^3.35.1",
+    "typescript": "^6.0.3"
+  },
+  "engines": {
+    "node": "^20.19.0 || >=22"
+  },
+  "keywords": [
+    "CMS",
+    "mcp",
+    "val",
+    "valbuild"
+  ],
+  "files": [
+    "CHANGELOG.md",
+    "dist",
+    "sharp/dist",
+    "sharp/package.json"
+  ]
+}

package/sharp/dist/valbuild-mcp-sharp.cjs.d.ts

@@ -0,0 +1,2 @@
+export * from "../../dist/declarations/src/sharp/index.js";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFsYnVpbGQtbWNwLXNoYXJwLmNqcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vZGlzdC9kZWNsYXJhdGlvbnMvc3JjL3NoYXJwL2luZGV4LmQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEifQ==

package/sharp/dist/valbuild-mcp-sharp.cjs.dev.js

@@ -0,0 +1,157 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var asyncToGenerator = require('../../dist/asyncToGenerator-c3823d62.cjs.dev.js');
+var core = require('@valbuild/core');
+
+/**
+ * `sharp`, as the image tool wants it.
+ *
+ * The library is passed IN rather than imported, and that is the whole point of
+ * this file existing separately. `sharp` ships a compiled binary per platform;
+ * importing it here would put one in every project that installs Val, for a
+ * feature most of them will not mount. Instead the project installs `sharp`
+ * itself and writes:
+ *
+ * ```ts
+ * import sharp from "sharp";
+ * import { createValImageTools } from "@valbuild/mcp";
+ * import { sharpImageProcessor } from "@valbuild/mcp/sharp";
+ *
+ * const tools = createValImageTools(sharpImageProcessor(sharp));
+ * ```
+ *
+ * The parameter is typed structurally — {@link SharpLike} — rather than as
+ * `import("sharp")`, for the same reason: a type-only import of a package that
+ * is not installed is still a compile error, and this package must typecheck in
+ * a project that has never heard of sharp. The real `sharp` satisfies it, and
+ * `sharpImageProcessor.test.ts` asserts as much against the actual library so
+ * the structural type cannot drift away from it unnoticed.
+ */
+
+/** What `sharp(bytes)` gives back, narrowed to what this file calls. */
+
+/**
+ * Which sharp formats are worth calling an image.
+ *
+ * Mapped explicitly rather than by pasting `image/` in front of
+ * `metadata.format`, because sharp's names and the mime types disagree in the
+ * cases that matter — `jpeg` vs `image/jpeg` is fine, but `heif` covers AVIF,
+ * and `svg` is a format sharp reads and Val stores as text. An unmapped format
+ * is reported as "not an image this library can read", which is the honest
+ * answer and is recoverable: the caller can convert it themselves.
+ */
+var MIME_TYPE_OF_FORMAT = {
+  avif: "image/avif",
+  gif: "image/gif",
+  jpeg: "image/jpeg",
+  jpg: "image/jpeg",
+  jp2: "image/jp2",
+  png: "image/png",
+  svg: "image/svg+xml",
+  tiff: "image/tiff",
+  webp: "image/webp"
+};
+function sharpImageProcessor(sharp) {
+  return {
+    read: function read(bytes) {
+      return asyncToGenerator._asyncToGenerator(/*#__PURE__*/asyncToGenerator._regenerator().m(function _callee() {
+        var metadata, _metadata, width, height, format, mimeType;
+        return asyncToGenerator._regenerator().w(function (_context) {
+          while (1) switch (_context.p = _context.n) {
+            case 0:
+              _context.p = 0;
+              _context.n = 1;
+              return sharp(bytes).metadata();
+            case 1:
+              metadata = _context.v;
+              _context.n = 3;
+              break;
+            case 2:
+              _context.p = 2;
+              _context.v;
+              return _context.a(2, null);
+            case 3:
+              _metadata = metadata, width = _metadata.width, height = _metadata.height, format = _metadata.format;
+              if (!(!width || !height || !format)) {
+                _context.n = 4;
+                break;
+              }
+              return _context.a(2, null);
+            case 4:
+              mimeType = MIME_TYPE_OF_FORMAT[format];
+              if (mimeType) {
+                _context.n = 5;
+                break;
+              }
+              return _context.a(2, null);
+            case 5:
+              if (core.Internal.MIME_TYPES_TO_EXT[mimeType]) {
+                _context.n = 6;
+                break;
+              }
+              return _context.a(2, null);
+            case 6:
+              return _context.a(2, {
+                width: width,
+                height: height,
+                mimeType: mimeType
+              });
+          }
+        }, _callee, null, [[0, 2]]);
+      }))();
+    },
+    encode: function encode(bytes, request) {
+      return asyncToGenerator._asyncToGenerator(/*#__PURE__*/asyncToGenerator._regenerator().m(function _callee2() {
+        var pipeline, encoded;
+        return asyncToGenerator._regenerator().w(function (_context2) {
+          while (1) switch (_context2.p = _context2.n) {
+            case 0:
+              if (!(request.mimeType !== "image/webp")) {
+                _context2.n = 1;
+                break;
+              }
+              return _context2.a(2, null);
+            case 1:
+              _context2.p = 1;
+              // `rotate()` with no argument applies the EXIF orientation, and it has
+              // to be here: the WebP carries no EXIF, so a rotation the source only
+              // described would otherwise be lost and the image would land on its
+              // side. It is also what makes the dimensions the tool re-reads
+              // afterwards the ones a browser would show.
+              pipeline = sharp(bytes).rotate();
+              if (request.resizeTo) {
+                pipeline = pipeline.resize({
+                  width: request.resizeTo.width,
+                  height: request.resizeTo.height,
+                  fit: "inside",
+                  // Belt and braces: `fitWithin` never asks for an upscale, and this
+                  // means a future caller that does cannot get one either.
+                  withoutEnlargement: true
+                });
+              }
+              _context2.n = 2;
+              return pipeline
+              // sharp takes 1-100 where the schema (and `canvas.toBlob`) say 0-1.
+              .webp({
+                quality: Math.round(request.quality * 100)
+              }).toBuffer();
+            case 2:
+              encoded = _context2.v;
+              return _context2.a(2, {
+                bytes: new Uint8Array(encoded),
+                mimeType: "image/webp"
+              });
+            case 3:
+              _context2.p = 3;
+              _context2.v;
+              return _context2.a(2, null);
+          }
+        }, _callee2, null, [[1, 3]]);
+      }))();
+    }
+  };
+}
+
+exports.sharpImageProcessor = sharpImageProcessor;

package/sharp/dist/valbuild-mcp-sharp.cjs.js

@@ -0,0 +1,7 @@
+'use strict';
+
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./valbuild-mcp-sharp.cjs.prod.js");
+} else {
+  module.exports = require("./valbuild-mcp-sharp.cjs.dev.js");
+}

package/sharp/dist/valbuild-mcp-sharp.cjs.prod.js

@@ -0,0 +1,157 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var asyncToGenerator = require('../../dist/asyncToGenerator-8e5c36c8.cjs.prod.js');
+var core = require('@valbuild/core');
+
+/**
+ * `sharp`, as the image tool wants it.
+ *
+ * The library is passed IN rather than imported, and that is the whole point of
+ * this file existing separately. `sharp` ships a compiled binary per platform;
+ * importing it here would put one in every project that installs Val, for a
+ * feature most of them will not mount. Instead the project installs `sharp`
+ * itself and writes:
+ *
+ * ```ts
+ * import sharp from "sharp";
+ * import { createValImageTools } from "@valbuild/mcp";
+ * import { sharpImageProcessor } from "@valbuild/mcp/sharp";
+ *
+ * const tools = createValImageTools(sharpImageProcessor(sharp));
+ * ```
+ *
+ * The parameter is typed structurally — {@link SharpLike} — rather than as
+ * `import("sharp")`, for the same reason: a type-only import of a package that
+ * is not installed is still a compile error, and this package must typecheck in
+ * a project that has never heard of sharp. The real `sharp` satisfies it, and
+ * `sharpImageProcessor.test.ts` asserts as much against the actual library so
+ * the structural type cannot drift away from it unnoticed.
+ */
+
+/** What `sharp(bytes)` gives back, narrowed to what this file calls. */
+
+/**
+ * Which sharp formats are worth calling an image.
+ *
+ * Mapped explicitly rather than by pasting `image/` in front of
+ * `metadata.format`, because sharp's names and the mime types disagree in the
+ * cases that matter — `jpeg` vs `image/jpeg` is fine, but `heif` covers AVIF,
+ * and `svg` is a format sharp reads and Val stores as text. An unmapped format
+ * is reported as "not an image this library can read", which is the honest
+ * answer and is recoverable: the caller can convert it themselves.
+ */
+var MIME_TYPE_OF_FORMAT = {
+  avif: "image/avif",
+  gif: "image/gif",
+  jpeg: "image/jpeg",
+  jpg: "image/jpeg",
+  jp2: "image/jp2",
+  png: "image/png",
+  svg: "image/svg+xml",
+  tiff: "image/tiff",
+  webp: "image/webp"
+};
+function sharpImageProcessor(sharp) {
+  return {
+    read: function read(bytes) {
+      return asyncToGenerator._asyncToGenerator(/*#__PURE__*/asyncToGenerator._regenerator().m(function _callee() {
+        var metadata, _metadata, width, height, format, mimeType;
+        return asyncToGenerator._regenerator().w(function (_context) {
+          while (1) switch (_context.p = _context.n) {
+            case 0:
+              _context.p = 0;
+              _context.n = 1;
+              return sharp(bytes).metadata();
+            case 1:
+              metadata = _context.v;
+              _context.n = 3;
+              break;
+            case 2:
+              _context.p = 2;
+              _context.v;
+              return _context.a(2, null);
+            case 3:
+              _metadata = metadata, width = _metadata.width, height = _metadata.height, format = _metadata.format;
+              if (!(!width || !height || !format)) {
+                _context.n = 4;
+                break;
+              }
+              return _context.a(2, null);
+            case 4:
+              mimeType = MIME_TYPE_OF_FORMAT[format];
+              if (mimeType) {
+                _context.n = 5;
+                break;
+              }
+              return _context.a(2, null);
+            case 5:
+              if (core.Internal.MIME_TYPES_TO_EXT[mimeType]) {
+                _context.n = 6;
+                break;
+              }
+              return _context.a(2, null);
+            case 6:
+              return _context.a(2, {
+                width: width,
+                height: height,
+                mimeType: mimeType
+              });
+          }
+        }, _callee, null, [[0, 2]]);
+      }))();
+    },
+    encode: function encode(bytes, request) {
+      return asyncToGenerator._asyncToGenerator(/*#__PURE__*/asyncToGenerator._regenerator().m(function _callee2() {
+        var pipeline, encoded;
+        return asyncToGenerator._regenerator().w(function (_context2) {
+          while (1) switch (_context2.p = _context2.n) {
+            case 0:
+              if (!(request.mimeType !== "image/webp")) {
+                _context2.n = 1;
+                break;
+              }
+              return _context2.a(2, null);
+            case 1:
+              _context2.p = 1;
+              // `rotate()` with no argument applies the EXIF orientation, and it has
+              // to be here: the WebP carries no EXIF, so a rotation the source only
+              // described would otherwise be lost and the image would land on its
+              // side. It is also what makes the dimensions the tool re-reads
+              // afterwards the ones a browser would show.
+              pipeline = sharp(bytes).rotate();
+              if (request.resizeTo) {
+                pipeline = pipeline.resize({
+                  width: request.resizeTo.width,
+                  height: request.resizeTo.height,
+                  fit: "inside",
+                  // Belt and braces: `fitWithin` never asks for an upscale, and this
+                  // means a future caller that does cannot get one either.
+                  withoutEnlargement: true
+                });
+              }
+              _context2.n = 2;
+              return pipeline
+              // sharp takes 1-100 where the schema (and `canvas.toBlob`) say 0-1.
+              .webp({
+                quality: Math.round(request.quality * 100)
+              }).toBuffer();
+            case 2:
+              encoded = _context2.v;
+              return _context2.a(2, {
+                bytes: new Uint8Array(encoded),
+                mimeType: "image/webp"
+              });
+            case 3:
+              _context2.p = 3;
+              _context2.v;
+              return _context2.a(2, null);
+          }
+        }, _callee2, null, [[1, 3]]);
+      }))();
+    }
+  };
+}
+
+exports.sharpImageProcessor = sharpImageProcessor;

package/sharp/dist/valbuild-mcp-sharp.esm.js

@@ -0,0 +1,153 @@
+import { _ as _asyncToGenerator, a as _regenerator } from '../../dist/asyncToGenerator-500f022f.esm.js';
+import { Internal } from '@valbuild/core';
+
+/**
+ * `sharp`, as the image tool wants it.
+ *
+ * The library is passed IN rather than imported, and that is the whole point of
+ * this file existing separately. `sharp` ships a compiled binary per platform;
+ * importing it here would put one in every project that installs Val, for a
+ * feature most of them will not mount. Instead the project installs `sharp`
+ * itself and writes:
+ *
+ * ```ts
+ * import sharp from "sharp";
+ * import { createValImageTools } from "@valbuild/mcp";
+ * import { sharpImageProcessor } from "@valbuild/mcp/sharp";
+ *
+ * const tools = createValImageTools(sharpImageProcessor(sharp));
+ * ```
+ *
+ * The parameter is typed structurally — {@link SharpLike} — rather than as
+ * `import("sharp")`, for the same reason: a type-only import of a package that
+ * is not installed is still a compile error, and this package must typecheck in
+ * a project that has never heard of sharp. The real `sharp` satisfies it, and
+ * `sharpImageProcessor.test.ts` asserts as much against the actual library so
+ * the structural type cannot drift away from it unnoticed.
+ */
+
+/** What `sharp(bytes)` gives back, narrowed to what this file calls. */
+
+/**
+ * Which sharp formats are worth calling an image.
+ *
+ * Mapped explicitly rather than by pasting `image/` in front of
+ * `metadata.format`, because sharp's names and the mime types disagree in the
+ * cases that matter — `jpeg` vs `image/jpeg` is fine, but `heif` covers AVIF,
+ * and `svg` is a format sharp reads and Val stores as text. An unmapped format
+ * is reported as "not an image this library can read", which is the honest
+ * answer and is recoverable: the caller can convert it themselves.
+ */
+var MIME_TYPE_OF_FORMAT = {
+  avif: "image/avif",
+  gif: "image/gif",
+  jpeg: "image/jpeg",
+  jpg: "image/jpeg",
+  jp2: "image/jp2",
+  png: "image/png",
+  svg: "image/svg+xml",
+  tiff: "image/tiff",
+  webp: "image/webp"
+};
+function sharpImageProcessor(sharp) {
+  return {
+    read: function read(bytes) {
+      return _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+        var metadata, _metadata, width, height, format, mimeType;
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.p = _context.n) {
+            case 0:
+              _context.p = 0;
+              _context.n = 1;
+              return sharp(bytes).metadata();
+            case 1:
+              metadata = _context.v;
+              _context.n = 3;
+              break;
+            case 2:
+              _context.p = 2;
+              _context.v;
+              return _context.a(2, null);
+            case 3:
+              _metadata = metadata, width = _metadata.width, height = _metadata.height, format = _metadata.format;
+              if (!(!width || !height || !format)) {
+                _context.n = 4;
+                break;
+              }
+              return _context.a(2, null);
+            case 4:
+              mimeType = MIME_TYPE_OF_FORMAT[format];
+              if (mimeType) {
+                _context.n = 5;
+                break;
+              }
+              return _context.a(2, null);
+            case 5:
+              if (Internal.MIME_TYPES_TO_EXT[mimeType]) {
+                _context.n = 6;
+                break;
+              }
+              return _context.a(2, null);
+            case 6:
+              return _context.a(2, {
+                width: width,
+                height: height,
+                mimeType: mimeType
+              });
+          }
+        }, _callee, null, [[0, 2]]);
+      }))();
+    },
+    encode: function encode(bytes, request) {
+      return _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2() {
+        var pipeline, encoded;
+        return _regenerator().w(function (_context2) {
+          while (1) switch (_context2.p = _context2.n) {
+            case 0:
+              if (!(request.mimeType !== "image/webp")) {
+                _context2.n = 1;
+                break;
+              }
+              return _context2.a(2, null);
+            case 1:
+              _context2.p = 1;
+              // `rotate()` with no argument applies the EXIF orientation, and it has
+              // to be here: the WebP carries no EXIF, so a rotation the source only
+              // described would otherwise be lost and the image would land on its
+              // side. It is also what makes the dimensions the tool re-reads
+              // afterwards the ones a browser would show.
+              pipeline = sharp(bytes).rotate();
+              if (request.resizeTo) {
+                pipeline = pipeline.resize({
+                  width: request.resizeTo.width,
+                  height: request.resizeTo.height,
+                  fit: "inside",
+                  // Belt and braces: `fitWithin` never asks for an upscale, and this
+                  // means a future caller that does cannot get one either.
+                  withoutEnlargement: true
+                });
+              }
+              _context2.n = 2;
+              return pipeline
+              // sharp takes 1-100 where the schema (and `canvas.toBlob`) say 0-1.
+              .webp({
+                quality: Math.round(request.quality * 100)
+              }).toBuffer();
+            case 2:
+              encoded = _context2.v;
+              return _context2.a(2, {
+                bytes: new Uint8Array(encoded),
+                mimeType: "image/webp"
+              });
+            case 3:
+              _context2.p = 3;
+              _context2.v;
+              return _context2.a(2, null);
+          }
+        }, _callee2, null, [[1, 3]]);
+      }))();
+    }
+  };
+}
+
+export { sharpImageProcessor };

package/sharp/package.json

@@ -0,0 +1,4 @@
+{
+  "main": "dist/valbuild-mcp-sharp.cjs.js",
+  "module": "dist/valbuild-mcp-sharp.esm.js"
+}