@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-KJMWAUKE.mjs

@@ -0,0 +1,124 @@
+import {
+  resolveFarmAPICanonicalPathname,
+  resolveFarmAPIServerRoutePath
+} from "./chunk-LM2YOGDK.mjs";
+import {
+  matchAPIRoute
+} from "./chunk-GUZC226X.mjs";
+
+// src/mcp-catalog.ts
+var CATALOGS = /* @__PURE__ */ Symbol.for("farm.mcp.catalogs");
+function catalogs() {
+  const state = globalThis;
+  return state[CATALOGS] ?? (state[CATALOGS] = /* @__PURE__ */ new Map());
+}
+function _listFarmMCPCatalogs() {
+  return [...catalogs().values()];
+}
+function _publishFarmMCPCatalog(server, tools, details) {
+  const entry = { server, tools, ...details ? { details } : {} };
+  catalogs().set(server.path, entry);
+  return () => {
+    if (catalogs().get(server.path) === entry) catalogs().delete(server.path);
+  };
+}
+var SERVERS = /* @__PURE__ */ Symbol.for("farm.mcp.servers");
+function registeredServers() {
+  const state = globalThis;
+  return state[SERVERS] ?? (state[SERVERS] = /* @__PURE__ */ new Map());
+}
+function _listFarmRegisteredMCPServers() {
+  return [...registeredServers().values()];
+}
+function registerFarmMCPServer(server) {
+  const entry = validateFarmMCPServerRegistration(server);
+  const key = entry.path ?? entry.url;
+  registeredServers().set(key, entry);
+  return () => {
+    if (registeredServers().get(key) === entry) registeredServers().delete(key);
+  };
+}
+function validateFarmMCPServerRegistration(server) {
+  if (!server || typeof server !== "object") {
+    throw new TypeError("registerFarmMCPServer expects a server object.");
+  }
+  const text = (key, required) => {
+    const value = server[key];
+    if (value === void 0 && !required) return void 0;
+    if (typeof value !== "string" || !value.trim()) {
+      throw new TypeError(`registerFarmMCPServer ${key} must be a non-empty string.`);
+    }
+    return value.trim();
+  };
+  const name = text("name", true);
+  const version = text("version", true);
+  const title = text("title", false);
+  const description = text("description", false);
+  const { path, url } = server;
+  if (path === void 0 === (url === void 0)) {
+    throw new TypeError("registerFarmMCPServer takes exactly one of path and url.");
+  }
+  let endpoint;
+  if (path !== void 0) {
+    if (typeof path !== "string" || !/^\/(?!\/)[^?#\\\s]*$/.test(path) || path.split("/").some((segment) => segment === "." || segment === "..")) {
+      throw new TypeError(
+        "registerFarmMCPServer path must be an absolute app path without a query, hash, or dot segments."
+      );
+    }
+    endpoint = { path: path.length > 1 ? path.replace(/\/+$/, "") : path };
+  } else {
+    let parsed;
+    try {
+      parsed = typeof url === "string" ? new URL(url) : void 0;
+    } catch {
+      parsed = void 0;
+    }
+    if (!parsed || parsed.protocol !== "https:" && parsed.protocol !== "http:" || parsed.username || parsed.password || parsed.search || parsed.hash) {
+      throw new TypeError(
+        "registerFarmMCPServer url must be an absolute http(s) URL without credentials, a query, or a hash."
+      );
+    }
+    endpoint = { url: `${parsed.origin}${parsed.pathname.replace(/\/+$/, "")}` };
+  }
+  const { protocolVersions } = server;
+  if (protocolVersions !== void 0 && (!Array.isArray(protocolVersions) || protocolVersions.some((version2) => typeof version2 !== "string" || !version2.trim()))) {
+    throw new TypeError("registerFarmMCPServer protocolVersions must be non-empty strings.");
+  }
+  return Object.freeze({
+    name,
+    version,
+    ...title ? { title } : {},
+    ...description ? { description } : {},
+    ...protocolVersions?.length ? { protocolVersions: Object.freeze([...protocolVersions]) } : {},
+    ...endpoint
+  });
+}
+function _findFarmMCPEndpointTool(method, pathname, serverBasePath) {
+  const upperMethod = method.toUpperCase();
+  for (const { server, tools } of catalogs().values()) {
+    const routes = /* @__PURE__ */ new Map();
+    for (const tool of tools) {
+      if (tool.kind === "endpoint" && tool.method === upperMethod) {
+        routes.set(tool.path, { path: tool.path, name: tool.name });
+      }
+    }
+    if (routes.size === 0) continue;
+    const canonical = serverBasePath ? resolveFarmAPICanonicalPathname(pathname, serverBasePath) : pathname;
+    const match = matchAPIRoute(routes, canonical);
+    if (match) {
+      return {
+        name: match.route.name,
+        endpoint: resolveFarmAPIServerRoutePath(server.path, serverBasePath)
+      };
+    }
+  }
+  return void 0;
+}
+
+export {
+  _listFarmMCPCatalogs,
+  _publishFarmMCPCatalog,
+  _listFarmRegisteredMCPServers,
+  registerFarmMCPServer,
+  _findFarmMCPEndpointTool
+};

package/dist/chunk-KORZ6PRE.cjs

@@ -0,0 +1,64 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/optional-peer.ts
+var _module = require('module');
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+function isMissingPackageError(error, packageName) {
+  let current = error;
+  for (let depth = 0; depth < 4; depth++) {
+    if (!current || typeof current !== "object") return false;
+    const { code, message, cause } = current;
+    if ((code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") && typeof message === "string") {
+      return message.includes(`'${packageName}'`) || message.includes(`"${packageName}"`);
+    }
+    current = cause;
+  }
+  return false;
+}
+function isOptionalPeerInstalled(root, packageName) {
+  const appRequire = _module.createRequire.call(void 0, _path2.default.join(root, "package.json"));
+  const requires = [appRequire];
+  try {
+    requires.push(_module.createRequire.call(void 0, appRequire.resolve("@farm.js/core")));
+  } catch (e) {
+  }
+  return requires.some((parentRequire) => {
+    try {
+      parentRequire.resolve(`${packageName}/package.json`);
+      return true;
+    } catch (error) {
+      return error.code === "ERR_PACKAGE_PATH_NOT_EXPORTED";
+    }
+  });
+}
+function formatOptionalPeerInstallHint(packageName, purpose, options = {}) {
+  return `Install "${packageName}" to ${purpose}: pnpm add ${options.dev ? "-D " : ""}${packageName}`;
+}
+var VERCEL_OG_INSTALL_HINT = formatOptionalPeerInstallHint(
+  "@vercel/og",
+  "render OG and metadata images"
+);
+var APP_IMPORTED_OPTIONAL_PEERS = [
+  ["@vercel/og", VERCEL_OG_INSTALL_HINT]
+];
+function explainMissingOptionalPeer(error, context) {
+  for (const [packageName, hint] of APP_IMPORTED_OPTIONAL_PEERS) {
+    if (isMissingPackageError(error, packageName)) {
+      return withOptionalPeerCause(
+        new Error(`${context} needs ${packageName}, which is not installed. ${hint}`),
+        error
+      );
+    }
+  }
+  return error;
+}
+function withOptionalPeerCause(error, cause) {
+  return Object.assign(error, { cause });
+}
+
+
+
+
+
+
+
+
+exports.isMissingPackageError = isMissingPackageError; exports.isOptionalPeerInstalled = isOptionalPeerInstalled; exports.formatOptionalPeerInstallHint = formatOptionalPeerInstallHint; exports.VERCEL_OG_INSTALL_HINT = VERCEL_OG_INSTALL_HINT; exports.explainMissingOptionalPeer = explainMissingOptionalPeer; exports.withOptionalPeerCause = withOptionalPeerCause;

package/dist/chunk-KPAJWD3N.mjs

@@ -0,0 +1,168 @@
+import {
+  parseRequestCookieHeader
+} from "./chunk-AY2YD5ZX.mjs";
+import {
+  createWebRequestFromFarmRequest
+} from "./chunk-6HRAK7I5.mjs";
+
+// src/middleware/cookie-header.ts
+function parseMiddlewareCookieHeader(cookieHeader) {
+  const cookies = /* @__PURE__ */ Object.create(null);
+  for (const cookie of parseRequestCookieHeader(cookieHeader)) {
+    if (!Object.prototype.hasOwnProperty.call(cookies, cookie.name)) {
+      cookies[cookie.name] = cookie.value;
+    }
+  }
+  return cookies;
+}
+function applyCookieNamePrefixRequirements(name, options) {
+  if (name.startsWith("__Host-")) {
+    return { ...options, secure: true, path: "/", domain: void 0 };
+  }
+  if (name.startsWith("__Secure-")) {
+    return { ...options, secure: true };
+  }
+  return options;
+}
+function serializeMiddlewareCookie(name, value, options = {}) {
+  const resolved = applyCookieNamePrefixRequirements(name, options);
+  let cookie = `${encodeURIComponent(name)}=${encodeURIComponent(value)}`;
+  if (resolved.maxAge != null) cookie += `; Max-Age=${resolved.maxAge}`;
+  if (resolved.expires) cookie += `; Expires=${resolved.expires.toUTCString()}`;
+  cookie += `; Path=${resolved.path || "/"}`;
+  if (resolved.domain) cookie += `; Domain=${resolved.domain}`;
+  if (resolved.secure || resolved.sameSite === "none") cookie += "; Secure";
+  if (resolved.httpOnly) cookie += "; HttpOnly";
+  if (resolved.sameSite) {
+    cookie += `; SameSite=${resolved.sameSite.charAt(0).toUpperCase()}${resolved.sameSite.slice(1)}`;
+  }
+  return cookie;
+}
+function serializeMiddlewareCookieDeletion(name, options = {}) {
+  return serializeMiddlewareCookie(name, "", { ...options, maxAge: 0, expires: /* @__PURE__ */ new Date(0) });
+}
+
+// src/middleware/module.ts
+function isWebRequest(request) {
+  return typeof Request !== "undefined" && request instanceof Request;
+}
+function toWebRequest(ctx) {
+  if (isWebRequest(ctx.request)) {
+    return ctx.request;
+  }
+  return createWebRequestFromFarmRequest(ctx.request, { origin: ctx.url.origin });
+}
+function createRequestMiddlewareContext(ctx) {
+  const context = {
+    get url() {
+      return ctx.url;
+    },
+    get pathname() {
+      return ctx.pathname;
+    },
+    get routePathname() {
+      return ctx.routePathname;
+    },
+    get searchParams() {
+      return ctx.searchParams;
+    },
+    get method() {
+      return ctx.method;
+    },
+    get params() {
+      return ctx.params;
+    },
+    get route() {
+      return ctx.route;
+    },
+    get locals() {
+      return ctx.locals;
+    },
+    get data() {
+      return ctx.data;
+    },
+    get headers() {
+      return ctx.headers;
+    },
+    get cookies() {
+      return ctx.cookies;
+    },
+    get(key) {
+      return ctx.locals.get(key);
+    },
+    has(key) {
+      return ctx.locals.has(key);
+    },
+    set(key, value) {
+      ctx.locals.set(key, value);
+    },
+    delete(key) {
+      return ctx.locals.delete(key);
+    },
+    redirect(url, status) {
+      ctx.redirect(url, status);
+    },
+    rewrite(url) {
+      ctx.rewrite(url);
+    },
+    json(data, status) {
+      ctx.json(data, status);
+    },
+    text(content, status) {
+      ctx.text(content, status);
+    },
+    html(content, status) {
+      ctx.html(content, status);
+    }
+  };
+  return context;
+}
+function normalizeMiddlewareModule(middlewareModule, routePath) {
+  const module = middlewareModule;
+  const defaultExport = module.default;
+  const namedExport = module.middleware;
+  const hasNamedExport = typeof namedExport === "function";
+  if (namedExport !== void 0 && !hasNamedExport) {
+    throw new TypeError("The named middleware export must be a function");
+  }
+  if (defaultExport && hasNamedExport) {
+    throw new Error(
+      "A middleware file cannot export both a default handler and a named middleware handler"
+    );
+  }
+  if (hasNamedExport) {
+    return {
+      handlers: [
+        async (ctx) => {
+          return namedExport(toWebRequest(ctx), createRequestMiddlewareContext(ctx));
+        }
+      ],
+      config: module.config
+    };
+  }
+  if (defaultExport && typeof defaultExport === "object" && "build" in defaultExport) {
+    if (typeof defaultExport.setBasePath === "function") {
+      defaultExport.setBasePath(routePath);
+    }
+    const built = defaultExport.build();
+    const handlers = Array.isArray(built?.handlers) ? built.handlers.filter((handler) => typeof handler === "function") : [];
+    return handlers.length > 0 ? {
+      handlers,
+      config: module.config || built?.config
+    } : null;
+  }
+  if (typeof defaultExport === "function") {
+    return {
+      handlers: [defaultExport],
+      config: module.config
+    };
+  }
+  return null;
+}
+
+export {
+  parseMiddlewareCookieHeader,
+  serializeMiddlewareCookie,
+  serializeMiddlewareCookieDeletion,
+  normalizeMiddlewareModule
+};

package/dist/chunk-KQH2COEJ.mjs

@@ -0,0 +1,42 @@
+// src/nitro/native-mcp-source.ts
+function generateNativeMCPPluginSource(mcp) {
+  if (mcp?.enabled !== true) {
+    return { importSource: "", registerSource: "", pluginSource: "" };
+  }
+  return {
+    importSource: `import { createFarmMCPPlugin as __farmCreateMCPPlugin } from "@farm.js/mcp/internal";`,
+    registerSource: `function __farmMCPIsPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+
+function __farmMergeMCPConfig(base, override) {
+  const output = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    if (value === undefined) continue;
+    output[key] =
+      __farmMCPIsPlainObject(output[key]) && __farmMCPIsPlainObject(value)
+        ? __farmMergeMCPConfig(output[key], value)
+        : value;
+  }
+  return output;
+}
+
+const farmNativeMCPConfig = farmRuntimeConfigs.reduce((merged, runtimeConfig) => {
+  const value = runtimeConfig?.mcp;
+  if (value === undefined) return merged;
+  if (value === false) return false;
+  return __farmMergeMCPConfig(merged && merged !== false ? merged : {}, value);
+}, undefined);
+const farmNativeMCPPlugin =
+  farmNativeMCPConfig && farmNativeMCPConfig.enabled !== false
+    ? __farmCreateMCPPlugin(farmNativeMCPConfig)
+    : null;`,
+    pluginSource: `...(farmNativeMCPPlugin ? [farmNativeMCPPlugin] : []),`
+  };
+}
+
+export {
+  generateNativeMCPPluginSource
+};

package/dist/chunk-KRRZJ77U.mjs

@@ -0,0 +1,169 @@
+import {
+  collectFarmLlmsTxtPages
+} from "./chunk-LAZK6UV7.mjs";
+import {
+  getFarmMarkdownMirrorPath,
+  isFarmMarkdownMirrorExposed
+} from "./chunk-N77JBPLC.mjs";
+import {
+  _listFarmMCPCatalogs,
+  _listFarmRegisteredMCPServers
+} from "./chunk-KJMWAUKE.mjs";
+import {
+  applyFarmBasePath,
+  stripFarmBasePath
+} from "./chunk-SF3JB56B.mjs";
+
+// src/agent-mcp.ts
+var FARM_DEFAULT_MCP_PATH = "/mcp";
+var FARM_DEFAULT_MCP_PROTOCOL_VERSIONS = [
+  "2025-11-25",
+  "2025-06-18",
+  "2025-03-26",
+  "2024-11-05"
+];
+var FARM_DEFAULT_MCP_DESCRIPTION = "Read-only access to this site's public pages: list, search, and read them as Markdown.";
+var READ_ONLY = {
+  readOnlyHint: true,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: false
+};
+var PAGE_SCHEMA = {
+  type: "object",
+  properties: {
+    path: { type: "string", description: `The page's path, such as "/about".` },
+    title: { type: "string" },
+    url: { type: "string", description: "The page's absolute URL." },
+    description: { type: "string" }
+  },
+  required: ["path", "title", "url"]
+};
+var PAGES_OUTPUT_SCHEMA = {
+  type: "object",
+  properties: { pages: { type: "array", items: PAGE_SCHEMA } },
+  required: ["pages"]
+};
+var FARM_DEFAULT_MCP_TOOLS = [
+  {
+    name: "list_pages",
+    title: "List pages",
+    description: "List this site's public pages with each page's path, title, URL, and description. Pass a page's path to read_page to read it as Markdown.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    outputSchema: PAGES_OUTPUT_SCHEMA,
+    annotations: READ_ONLY
+  },
+  {
+    name: "search_pages",
+    title: "Search pages",
+    description: "Search this site's public pages by title, description, and path. Every word of the query must match. Returns the matching pages, best match first.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          minLength: 1,
+          maxLength: 200,
+          description: 'Words to look for, such as "pricing" or "getting started".'
+        },
+        limit: {
+          type: "integer",
+          minimum: 1,
+          maximum: 50,
+          default: 10,
+          description: "The most pages to return."
+        }
+      },
+      required: ["query"],
+      additionalProperties: false
+    },
+    outputSchema: PAGES_OUTPUT_SCHEMA,
+    annotations: READ_ONLY
+  },
+  {
+    name: "read_page",
+    title: "Read a page",
+    description: `Read one of this site's public pages as Markdown. Takes a path from list_pages or search_pages, such as "/" or "/about".`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          minLength: 1,
+          maxLength: 2048,
+          description: `The page's path, such as "/about", or its full URL on this site.`
+        }
+      },
+      required: ["path"],
+      additionalProperties: false
+    },
+    annotations: READ_ONLY
+  }
+];
+function collectFarmDefaultMCPPages(sources, options) {
+  const readable = [];
+  for (const source of sources) {
+    const module = isRecord(source.module) ? source.module : void 0;
+    if (module?.__farmRouteGuard) continue;
+    if (!isFarmMarkdownMirrorExposed(options.markdown, source.pattern)) continue;
+    readable.push({ pattern: source.pattern, metadata: module?.metadata });
+  }
+  return collectFarmLlmsTxtPages(readable, {
+    origin: options.origin,
+    basePath: options.basePath,
+    markdown: options.markdown
+  }).map((page) => ({
+    path: page.path,
+    title: page.title,
+    url: `${options.origin}${applyFarmBasePath(page.path, options.basePath)}`,
+    ...page.description ? { description: page.description } : {},
+    markdownUrl: `${options.origin}${applyFarmBasePath(
+      getFarmMarkdownMirrorPath(page.path),
+      options.basePath
+    )}`
+  }));
+}
+function createFarmDefaultMCPServer(app, farmVersion) {
+  const name = typeof app?.name === "string" && app.name.trim() ? app.name.trim() : "farm-app";
+  const version = typeof app?.version === "string" && app.version.trim() ? app.version.trim() : farmVersion;
+  return {
+    name,
+    version,
+    description: FARM_DEFAULT_MCP_DESCRIPTION,
+    protocolVersions: [...FARM_DEFAULT_MCP_PROTOCOL_VERSIONS],
+    path: FARM_DEFAULT_MCP_PATH
+  };
+}
+function resolveFarmDefaultMCPServer(server) {
+  if (!server) return void 0;
+  if (_listFarmMCPCatalogs().length > 0 || _listFarmRegisteredMCPServers().length > 0) {
+    return void 0;
+  }
+  return server;
+}
+function isFarmDefaultMCPPathname(pathname, basePath) {
+  const path = stripFarmBasePath(pathname, basePath);
+  return path === FARM_DEFAULT_MCP_PATH || path === `${FARM_DEFAULT_MCP_PATH}/`;
+}
+function farmConfigMountsMCP(config) {
+  const { mcp } = config;
+  if (isRecord(mcp) && mcp.enabled !== false) return true;
+  return Boolean(
+    config.plugins?.some((plugin) => isRecord(plugin) && plugin.name === "farm:api-mcp")
+  );
+}
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+
+export {
+  FARM_DEFAULT_MCP_PATH,
+  FARM_DEFAULT_MCP_PROTOCOL_VERSIONS,
+  FARM_DEFAULT_MCP_DESCRIPTION,
+  FARM_DEFAULT_MCP_TOOLS,
+  collectFarmDefaultMCPPages,
+  createFarmDefaultMCPServer,
+  resolveFarmDefaultMCPServer,
+  isFarmDefaultMCPPathname,
+  farmConfigMountsMCP
+};