@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-ZMHAFH4R.mjs

@@ -1,491 +0,0 @@
-import {
-  FARM_DEFAULT_MCP_PATH,
-  FARM_DEFAULT_MCP_TOOLS
-} from "./chunk-UZZ6IEQP.mjs";
-import {
-  resolveFarmAppManifestConfig
-} from "./chunk-2WZTGPK6.mjs";
-import {
-  emitFarmAgentRead,
-  getFarmMarkdownMirrorPath
-} from "./chunk-YSXTNSXS.mjs";
-import {
-  _listFarmMCPCatalogs,
-  _listFarmRegisteredMCPServers
-} from "./chunk-C7GJDVN4.mjs";
-import {
-  resolveFarmAPIServerBasePath,
-  resolveFarmAPIServerRoutePath
-} from "./chunk-2I6PUKWJ.mjs";
-import {
-  createFarmWeakETag,
-  matchesFarmIfNoneMatch
-} from "./chunk-GFT5AHAT.mjs";
-import {
-  FARM_VERSION
-} from "./chunk-HPWB57PZ.mjs";
-import {
-  applyFarmBasePath
-} from "./chunk-SF3JB56B.mjs";
-
-// src/ai-catalog.ts
-var FARM_AI_CATALOG_PATH = "/.well-known/ai-catalog.json";
-var FARM_ARD_PATH = "/.well-known/ard.json";
-var FARM_MCP_SERVER_CARD_SUFFIX = "/server-card";
-var SERVER_CARD_SCHEMA = "https://static.modelcontextprotocol.io/schemas/v1/server-card.schema.json";
-var SERVER_CARD_TYPE = "application/mcp-server-card+json";
-var AI_CATALOG_TYPE = "application/ai-catalog+json";
-var CARD_DESCRIPTION_MAX = 100;
-var REVERSE_DNS_NAME = /^[a-zA-Z0-9.-]+\/[a-zA-Z0-9._-]+$/;
-function listFarmMCPServerSources(input) {
-  const sources = /* @__PURE__ */ new Map();
-  for (const { server, details } of _listFarmMCPCatalogs()) {
-    const endpoint = resolveFarmAPIServerRoutePath(server.path, input.apiServerBasePath);
-    if (sources.has(endpoint)) continue;
-    sources.set(endpoint, {
-      ...server,
-      protocolVersions: details?.protocolVersions,
-      endpoint,
-      local: true
-    });
-  }
-  for (const server of _listFarmRegisteredMCPServers()) {
-    const endpoint = server.path ? applyFarmBasePath(server.path, input.basePath) : server.url;
-    if (sources.has(endpoint)) continue;
-    sources.set(endpoint, { ...server, endpoint, local: Boolean(server.path) });
-  }
-  if (sources.size === 0 && input.defaultMCP) {
-    const server = input.defaultMCP();
-    if (server) {
-      const endpoint = applyFarmBasePath(server.path, input.basePath);
-      sources.set(endpoint, { ...server, endpoint, local: true });
-    }
-  }
-  return [...sources.values()];
-}
-function serverCardLocation(endpoint) {
-  return `${endpoint.replace(/\/$/, "")}${FARM_MCP_SERVER_CARD_SUFFIX}`;
-}
-function listFarmMCPServerCards(origin, input = {}) {
-  const host = new URL(origin).hostname;
-  return listFarmMCPServerSources(input).map((server) => {
-    const endpointUrl = server.local ? `${origin}${server.endpoint}` : server.endpoint;
-    const cardPath = server.local ? serverCardLocation(server.endpoint) : void 0;
-    const slug = cardSlug(server.name);
-    const description = truncate(server.description?.trim() || `MCP server for ${host}`);
-    const card = {
-      $schema: SERVER_CARD_SCHEMA,
-      // The card's name is reverse-DNS; a plain server name is namespaced by the host.
-      name: REVERSE_DNS_NAME.test(server.name) ? server.name : `${cardNamespace(host)}/${slug}`,
-      version: server.version,
-      description,
-      ...server.title ? { title: server.title } : {},
-      websiteUrl: `${origin}${applyFarmBasePath("/", input.basePath).replace(/(.)\/$/, "$1")}`,
-      remotes: [
-        {
-          type: "streamable-http",
-          url: endpointUrl,
-          ...server.protocolVersions?.length ? { supportedProtocolVersions: [...server.protocolVersions] } : {}
-        }
-      ]
-    };
-    return {
-      ...cardPath ? { cardPath } : {},
-      card,
-      entry: {
-        identifier: `urn:air:${host}:mcp:${slug}`,
-        type: SERVER_CARD_TYPE,
-        url: cardPath ? `${origin}${cardPath}` : serverCardLocation(endpointUrl),
-        displayName: server.title ?? server.name,
-        description,
-        version: server.version
-      }
-    };
-  });
-}
-function listFarmMCPLlmsTxtLinks(origin, input = {}) {
-  const servers = listFarmMCPServerCards(origin, input);
-  if (!servers.length) return [];
-  return [
-    ...servers.map(({ card, entry }) => ({
-      title: entry.displayName,
-      url: card.remotes[0].url,
-      description: `${card.description} (Streamable HTTP MCP endpoint; server card at ${entry.url})`
-    })),
-    {
-      title: "AI catalog",
-      url: `${origin}${applyFarmBasePath(FARM_AI_CATALOG_PATH, input.basePath)}`,
-      description: "MCP server cards for this site"
-    }
-  ];
-}
-function createFarmAiCatalogResponse(request, input = {}, requestUrl) {
-  let url;
-  try {
-    url = requestUrl ?? new URL(request.url);
-  } catch {
-    return null;
-  }
-  const { pathname } = url;
-  if (!pathname.endsWith(FARM_MCP_SERVER_CARD_SUFFIX) && !pathname.includes("/.well-known/")) {
-    return null;
-  }
-  const ard = pathname === applyFarmBasePath(FARM_ARD_PATH, input.basePath);
-  const catalogPath = ard || pathname === applyFarmBasePath(FARM_AI_CATALOG_PATH, input.basePath);
-  if (!catalogPath && !pathname.endsWith(FARM_MCP_SERVER_CARD_SUFFIX)) return null;
-  const servers = listFarmMCPServerCards(url.origin, input);
-  const card = catalogPath ? void 0 : servers.find((server) => server.cardPath === pathname);
-  if (!servers.length || !catalogPath && !card) return null;
-  const method = request.method.toUpperCase();
-  if (method === "OPTIONS") return new Response(null, { status: 204, headers: corsHeaders() });
-  if (method !== "GET" && method !== "HEAD") {
-    return new Response("Method Not Allowed", {
-      status: 405,
-      headers: { ...corsHeaders(), Allow: "GET, HEAD, OPTIONS", "Content-Type": "text/plain" }
-    });
-  }
-  const body = JSON.stringify(
-    card ? card.card : { specVersion: "1.0", entries: servers.map(({ entry }) => entry) }
-  );
-  const etag = createFarmWeakETag(body);
-  const headers = {
-    ...corsHeaders(),
-    "Content-Type": card ? `${SERVER_CARD_TYPE}; charset=utf-8` : ard ? "application/json; charset=utf-8" : `${AI_CATALOG_TYPE}; charset=utf-8`,
-    // The body names the request's origin, so caches revalidate rather than reuse it.
-    "Cache-Control": "public, max-age=0, must-revalidate",
-    ETag: etag,
-    "X-Content-Type-Options": "nosniff"
-  };
-  if (matchesFarmIfNoneMatch(request.headers.get("if-none-match"), etag)) {
-    return new Response(null, { status: 304, headers });
-  }
-  emitFarmAgentRead(request, card ? "mcp-server-card" : "ai-catalog", 200);
-  return new Response(method === "HEAD" ? null : body, { status: 200, headers });
-}
-function corsHeaders() {
-  return {
-    "Access-Control-Allow-Origin": "*",
-    "Access-Control-Allow-Methods": "GET, HEAD, OPTIONS",
-    "Access-Control-Allow-Headers": "Content-Type, If-None-Match",
-    "Access-Control-Expose-Headers": "ETag"
-  };
-}
-function cardNamespace(host) {
-  if (host.includes(":") || /^\d+(?:\.\d+){3}$/.test(host)) return "local";
-  return host.split(".").reverse().join(".");
-}
-function cardSlug(name) {
-  const last = name.includes("/") ? name.slice(name.lastIndexOf("/") + 1) : name;
-  return last.toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "mcp";
-}
-function truncate(text) {
-  return text.length <= CARD_DESCRIPTION_MAX ? text : `${text.slice(0, CARD_DESCRIPTION_MAX - 1).trimEnd()}\u2026`;
-}
-
-// src/api-catalog.ts
-var FARM_API_CATALOG_PATH = "/.well-known/api-catalog";
-var API_CATALOG_CONTENT_TYPE = 'application/linkset+json; profile="https://www.rfc-editor.org/info/rfc9727"';
-function resolveFarmApiCatalogInput(config) {
-  const mcp = config.mcp && config.mcp.enabled !== false ? config.mcp : void 0;
-  return {
-    basePath: config.basePath,
-    apiBaseURL: config.openapi?.servers?.[0]?.url ?? config.api.baseURL,
-    openapi: config.openapi?.enabled ? { specRoute: config.openapi.specRoute, route: config.openapi.route } : void 0,
-    mcpPath: mcp ? resolveFarmAPIServerRoutePath(
-      mcp.path ?? "/api/mcp",
-      resolveFarmAPIServerBasePath(config.api)
-    ) : void 0
-  };
-}
-function createFarmApiCatalog(input) {
-  const appPath = (path) => applyFarmBasePath(path, input.basePath);
-  const items = [];
-  const contexts = [];
-  const specRoute = input.openapi?.specRoute;
-  const reference = input.openapi?.route;
-  if (specRoute || reference) {
-    const api = { anchor: input.apiBaseURL };
-    if (specRoute) {
-      api["service-desc"] = [
-        { href: appPath(specRoute), type: "application/vnd.oai.openapi+json" }
-      ];
-    }
-    if (reference) api["service-doc"] = [{ href: appPath(reference), type: "text/html" }];
-    items.push({ href: input.apiBaseURL });
-    contexts.push(api);
-  }
-  if (input.mcpPath) items.push({ href: input.mcpPath });
-  return {
-    linkset: [{ anchor: appPath(FARM_API_CATALOG_PATH), item: items }, ...contexts]
-  };
-}
-function createFarmApiCatalogResponse(method, input, request) {
-  const upperMethod = method.toUpperCase();
-  if (upperMethod !== "GET" && upperMethod !== "HEAD") {
-    return new Response("Method Not Allowed", {
-      status: 405,
-      headers: { Allow: "GET, HEAD", "Content-Type": "text/plain; charset=utf-8" }
-    });
-  }
-  if (request) emitFarmAgentRead(request, "api-catalog", 200);
-  const catalog = createFarmApiCatalog(input);
-  return new Response(upperMethod === "HEAD" ? null : JSON.stringify(catalog), {
-    status: 200,
-    headers: {
-      "Content-Type": API_CATALOG_CONTENT_TYPE,
-      "Cache-Control": "public, max-age=0, must-revalidate",
-      Link: `<${catalog.linkset[0].anchor}>; rel="api-catalog"`,
-      "X-Content-Type-Options": "nosniff"
-    }
-  });
-}
-
-// src/app-manifest.ts
-var FARM_APP_MANIFEST_PATH = "/.well-known/farmjs.json";
-var FARM_APP_MANIFEST_LEGACY_PATH = "/.well-known/farmjs";
-function isFarmAppManifestPath(pathname) {
-  return pathname === FARM_APP_MANIFEST_PATH || pathname === FARM_APP_MANIFEST_LEGACY_PATH;
-}
-function resolveFarmAppManifestInput(config, extra) {
-  const llms = config.agent?.llmsTxt;
-  const plugins = (config.plugins ?? []).map(({ name }) => name);
-  const webmcp = plugins.includes("farm:webmcp");
-  const sections = resolveFarmAppManifestConfig(config.agent?.manifest);
-  return {
-    renderer: config.renderer?.name ?? "react",
-    basePath: config.basePath || "/",
-    build: extra.build,
-    packages: extra.packages,
-    webmcp: { enabled: webmcp, tools: webmcp ? extra.webmcpTools ?? [] : [] },
-    integrations: Object.entries(config.integrations ?? {}).flatMap(([key, integration]) => {
-      const category = integration?.category ?? integration?.slot;
-      return integration && category && integration.type ? [{ key, category, type: integration.type }] : [];
-    }),
-    agent: {
-      apiCatalog: config.agent?.apiCatalog ? "/.well-known/api-catalog" : null,
-      llmsTxt: llms === true || typeof llms === "object" && llms !== null && llms.enabled !== false,
-      openapi: config.openapi?.enabled && config.openapi.specRoute ? config.openapi.specRoute : null
-    },
-    plugins,
-    ...sections ? { sections } : {}
-  };
-}
-var SOURCES = {
-  endpoint: "endpoint",
-  standalone: "defineTool",
-  serverFunction: "serverFunction"
-};
-var DEFAULT_SECTIONS = resolveFarmAppManifestConfig(void 0);
-function createFarmAppManifest(input) {
-  const sections = input.sections ?? DEFAULT_SECTIONS;
-  const { app, mcp, webmcp } = sections;
-  return {
-    schemaVersion: 1,
-    app: app ? {
-      ...app.version ? { farm: FARM_VERSION } : {},
-      ...app.renderer ? { renderer: input.renderer } : {},
-      basePath: input.basePath,
-      ...app.build ? { build: input.build } : {}
-    } : null,
-    packages: sections.packages === "names" ? Object.fromEntries(Object.keys(input.packages).map((name) => [name, null])) : sections.packages ? input.packages : null,
-    mcp: mcp ? { servers: listServers(input, mcp) } : null,
-    webmcp: webmcp ? {
-      enabled: input.webmcp.enabled,
-      tools: input.webmcp.tools.filter((tool) => !webmcp.hide.includes(tool.name))
-    } : null,
-    integrations: sections.integrations ? input.integrations : null,
-    agent: sections.agent ? input.agent : null,
-    plugins: sections.plugins ? input.plugins : null
-  };
-}
-function listServers(input, mcp) {
-  const servers = _listFarmMCPCatalogs().map(({ server, tools, details }) => {
-    const open = details?.public === true && !input.guardCoversPath?.(server.path);
-    return {
-      name: server.name,
-      version: server.version,
-      path: server.path,
-      authorization: open ? "none" : "required",
-      resources: open ? [...details?.resources ?? []] : [],
-      prompts: open ? [...details?.prompts ?? []] : [],
-      tools: (open ? tools : []).map((tool) => {
-        const schemas = details?.schemas?.[tool.name];
-        const hints = Object.fromEntries(
-          ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"].filter((hint) => typeof tool[hint] === "boolean").map((hint) => [hint, tool[hint]])
-        );
-        return {
-          name: tool.name,
-          ...tool.title ? { title: tool.title } : {},
-          ...tool.description ? { description: tool.description } : {},
-          source: SOURCES[tool.kind],
-          ...hints,
-          ...schemas ? { inputSchema: schemas.input } : {},
-          ...schemas?.output ? { outputSchema: schemas.output } : {}
-        };
-      })
-    };
-  });
-  return [...servers, ...listDefaultServer(input)].filter((server) => !mcp.hide.includes(server.name)).map((server) => ({
-    ...server,
-    tools: server.tools.filter((tool) => !mcp.hide.includes(`${server.name}/${tool.name}`)).map((tool) => mcp.schemas ? tool : withoutSchemas(tool))
-  }));
-}
-function withoutSchemas({
-  inputSchema: _input,
-  outputSchema: _output,
-  ...tool
-}) {
-  return tool;
-}
-function listDefaultServer(input) {
-  const server = input.defaultMCP?.();
-  if (!server) return [];
-  return [
-    {
-      name: server.name,
-      version: server.version,
-      path: server.path,
-      authorization: "none",
-      resources: [],
-      prompts: [],
-      tools: FARM_DEFAULT_MCP_TOOLS.map((tool) => ({
-        name: tool.name,
-        title: tool.title,
-        description: tool.description,
-        // Standalone tools with no endpoint behind them, like defineTool's.
-        source: "defineTool",
-        ...tool.annotations,
-        inputSchema: tool.inputSchema,
-        ..."outputSchema" in tool ? { outputSchema: tool.outputSchema } : {}
-      }))
-    }
-  ];
-}
-var CORS_HEADERS = {
-  "access-control-allow-origin": "*",
-  "access-control-allow-methods": "GET, HEAD, OPTIONS",
-  "access-control-allow-headers": "If-None-Match",
-  "access-control-expose-headers": "ETag"
-};
-async function createFarmAppManifestResponse(request, input) {
-  const method = request.method.toUpperCase();
-  if (method === "OPTIONS") return new Response(null, { status: 204, headers: CORS_HEADERS });
-  if (method !== "GET" && method !== "HEAD") {
-    return new Response("Method Not Allowed", {
-      status: 405,
-      headers: { ...CORS_HEADERS, allow: "GET, HEAD, OPTIONS", "content-type": "text/plain" }
-    });
-  }
-  const body = JSON.stringify(createFarmAppManifest(input));
-  const etag = createFarmWeakETag(body);
-  const headers = {
-    ...CORS_HEADERS,
-    "content-type": "application/json; charset=utf-8",
-    "cache-control": "public, max-age=0, must-revalidate",
-    etag,
-    "x-content-type-options": "nosniff"
-  };
-  if (matchesFarmIfNoneMatch(request.headers.get("if-none-match"), etag)) {
-    return new Response(null, { status: 304, headers });
-  }
-  return new Response(method === "HEAD" ? null : body, { status: 200, headers });
-}
-
-// src/route-label.ts
-var FARM_ROUTE_LABEL = /* @__PURE__ */ Symbol.for("farm.route.label");
-function getFarmRouteLabel(route) {
-  if (!route) return void 0;
-  const labeled = route;
-  return labeled[FARM_ROUTE_LABEL] ?? labeled.pattern;
-}
-function setFarmRouteLabel(route, label) {
-  if (route && label) route[FARM_ROUTE_LABEL] = label;
-  return route;
-}
-function listFarmBuiltInRoutePaths(input) {
-  const agent = input.agent ?? {};
-  return [
-    ...agent.manifest !== false ? [FARM_APP_MANIFEST_PATH, FARM_APP_MANIFEST_LEGACY_PATH] : [],
-    ...agent.apiCatalog ? [FARM_API_CATALOG_PATH] : [],
-    ...agent.aiCatalog !== false ? [FARM_AI_CATALOG_PATH, FARM_ARD_PATH] : [],
-    ...agent.mcp === true ? [FARM_DEFAULT_MCP_PATH, `${FARM_DEFAULT_MCP_PATH}${FARM_MCP_SERVER_CARD_SUFFIX}`] : [],
-    ...agent.llmsTxt?.enabled ? ["/llms.txt"] : [],
-    ...agent.llmsTxt?.enabled && agent.llmsTxt.full ? ["/llms-full.txt"] : [],
-    ...agent.sitemap?.enabled ? ["/sitemap.xml"] : [],
-    ...agent.crawlers?.enabled ? ["/robots.txt"] : [],
-    ...input.openapi?.route ? [input.openapi.route] : [],
-    ...input.openapi?.specRoute ? [input.openapi.specRoute] : []
-  ];
-}
-function normalize(pathname) {
-  return pathname.length > 1 ? pathname.replace(/\/+$/, "") || "/" : pathname;
-}
-function resolveFarmMCPRouteLabel(routePathname, apiServerBasePath) {
-  const pathname = normalize(routePathname);
-  const endpoints = [];
-  for (const server of _listFarmRegisteredMCPServers()) {
-    if (server.path) endpoints.push(server.path);
-  }
-  for (const { server } of _listFarmMCPCatalogs()) {
-    endpoints.push(resolveFarmAPIServerRoutePath(server.path, apiServerBasePath));
-  }
-  for (const endpoint of endpoints) {
-    const path = normalize(endpoint);
-    if (pathname === path) return path;
-    if (pathname === `${path === "/" ? "" : path}${FARM_MCP_SERVER_CARD_SUFFIX}`) return pathname;
-  }
-  return null;
-}
-function resolveFarmDocsRouteLabel(routePathname, docs) {
-  const pathname = normalize(routePathname);
-  const apiPath = normalize(docs.apiPath ?? "/api/docs");
-  if (pathname === apiPath) return apiPath;
-  if (pathname.startsWith(`${apiPath}/`)) return `${apiPath}/[...path]`;
-  const markdown = pathname.toLowerCase().endsWith(".md");
-  const page = markdown ? pathname.slice(0, -".md".length) : pathname;
-  const entries = [docs.path, ...docs.roots ?? []].map(normalize).sort((a, b) => b.length - a.length);
-  for (const entry of entries) {
-    const base = entry === "/" ? "" : entry;
-    if (page === entry || entry === "/" && page === "/index") {
-      return markdown ? getFarmMarkdownMirrorPath(entry) : entry;
-    }
-    if (page.startsWith(`${base}/`)) return `${base}/[...slug]${markdown ? ".md" : ""}`;
-  }
-  return null;
-}
-function resolveFarmDocsEngineRouteLabel(routePathname, docs) {
-  const docsLabel = resolveFarmDocsRouteLabel(routePathname, docs);
-  if (docsLabel) return docsLabel;
-  const mcpLabel = resolveFarmMCPRouteLabel(routePathname);
-  if (mcpLabel) return mcpLabel;
-  const segments = normalize(routePathname).split("/").filter(Boolean);
-  const fixed = segments[0] === ".well-known" ? 2 : 1;
-  if (segments.length <= fixed) return `/${segments.join("/")}`;
-  return `/${segments.slice(0, fixed).join("/")}/[...path]`;
-}
-function resolveFarmMarkdownRouteLabel(routePathname, matchPagePattern) {
-  if (!routePathname.toLowerCase().endsWith(".md")) return null;
-  const page = routePathname === "/index.md" ? "/" : routePathname.slice(0, -".md".length) || "/";
-  const pattern = matchPagePattern(page);
-  return pattern ? getFarmMarkdownMirrorPath(pattern) : null;
-}
-
-export {
-  listFarmMCPLlmsTxtLinks,
-  createFarmAiCatalogResponse,
-  FARM_API_CATALOG_PATH,
-  resolveFarmApiCatalogInput,
-  createFarmApiCatalogResponse,
-  FARM_APP_MANIFEST_PATH,
-  FARM_APP_MANIFEST_LEGACY_PATH,
-  isFarmAppManifestPath,
-  resolveFarmAppManifestInput,
-  createFarmAppManifestResponse,
-  getFarmRouteLabel,
-  setFarmRouteLabel,
-  listFarmBuiltInRoutePaths,
-  resolveFarmMCPRouteLabel,
-  resolveFarmDocsRouteLabel,
-  resolveFarmDocsEngineRouteLabel,
-  resolveFarmMarkdownRouteLabel
-};