@farm.js/core 0.1.51-beta.3 → 0.1.61

package/dist/chunk-MNIR7I7B.mjs

@@ -1,217 +0,0 @@
-import {
-  FARM_ACTION_TAG,
-  FARM_OBJECT_TAG,
-  FARM_REFERENCE_TAG,
-  FARM_SLOT_TAG,
-  FARM_TAG,
-  FARM_TAG_VALUE,
-  getFarmTag
-} from "./chunk-NBIVGHAT.mjs";
-
-// src/client/island-codec.ts
-var TYPED_ARRAYS = {
-  Int8Array,
-  Uint8Array,
-  Uint8ClampedArray,
-  Int16Array,
-  Uint16Array,
-  Int32Array,
-  Uint32Array,
-  Float32Array,
-  Float64Array,
-  BigInt64Array,
-  BigUint64Array
-};
-function toBase64(bytes) {
-  let binary = "";
-  for (let index = 0; index < bytes.length; index += 32768) {
-    binary += String.fromCharCode(...bytes.subarray(index, index + 32768));
-  }
-  return btoa(binary);
-}
-function fromBase64(base64) {
-  const binary = atob(base64);
-  const bytes = new Uint8Array(binary.length);
-  for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index);
-  return bytes;
-}
-function farmTagged(tag, value) {
-  return value === void 0 ? { [FARM_TAG]: tag } : { [FARM_TAG]: tag, [FARM_TAG_VALUE]: value };
-}
-function needsFarmObjectTag(object) {
-  return Object.prototype.hasOwnProperty.call(object, FARM_TAG);
-}
-function encodeFarmLeaf(value) {
-  switch (typeof value) {
-    case "undefined":
-      return farmTagged("u");
-    case "bigint":
-      return farmTagged("B", value.toString());
-    case "number":
-      if (Number.isNaN(value)) return farmTagged("n", "NaN");
-      if (value === Infinity) return farmTagged("n", "Infinity");
-      if (value === -Infinity) return farmTagged("n", "-Infinity");
-      if (Object.is(value, -0)) return farmTagged("n", "-0");
-      return void 0;
-    case "object":
-      break;
-    default:
-      return void 0;
-  }
-  if (value === null) return void 0;
-  if (value instanceof Date) {
-    return farmTagged("D", Number.isNaN(value.getTime()) ? null : value.toISOString());
-  }
-  if (typeof URL === "function" && value instanceof URL) return farmTagged("U", value.href);
-  if (value instanceof RegExp) return farmTagged("R", [value.source, value.flags]);
-  if (value instanceof ArrayBuffer) {
-    return farmTagged("Y", ["ArrayBuffer", toBase64(new Uint8Array(value))]);
-  }
-  if (ArrayBuffer.isView(value)) {
-    const name = value instanceof DataView ? "DataView" : value.constructor.name;
-    if (name !== "DataView" && !(name in TYPED_ARRAYS)) return void 0;
-    const bytes = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
-    return farmTagged("Y", [name, toBase64(bytes)]);
-  }
-  return void 0;
-}
-var NOT_A_FARM_MARKER = /* @__PURE__ */ Symbol.for("farm.codec.not-a-marker");
-function farmPlainObject(entries) {
-  const object = {};
-  for (const [key, value] of entries) {
-    Object.defineProperty(object, key, {
-      value,
-      enumerable: true,
-      writable: true,
-      configurable: true
-    });
-  }
-  return object;
-}
-function decodeFarmTagged(object, decodeChild) {
-  const tag = object[FARM_TAG];
-  const data = object[FARM_TAG_VALUE];
-  switch (tag) {
-    case FARM_REFERENCE_TAG:
-    case FARM_SLOT_TAG:
-    case FARM_ACTION_TAG:
-      return NOT_A_FARM_MARKER;
-    case FARM_OBJECT_TAG:
-      if (data && typeof data === "object" && !Array.isArray(data)) {
-        return farmPlainObject(
-          Object.entries(data).map(([key, value]) => [key, decodeChild(value)])
-        );
-      }
-      break;
-    case "u":
-      return void 0;
-    case "n":
-      if (data === "NaN") return Number.NaN;
-      if (data === "Infinity") return Infinity;
-      if (data === "-Infinity") return -Infinity;
-      if (data === "-0") return -0;
-      break;
-    case "B":
-      if (typeof data === "string" && /^-?\d+$/.test(data)) return BigInt(data);
-      break;
-    case "D":
-      if (data === null) return new Date(Number.NaN);
-      if (typeof data === "string") return new Date(data);
-      break;
-    case "U":
-      if (typeof data === "string") return new URL(data);
-      break;
-    case "R":
-      if (Array.isArray(data) && typeof data[0] === "string" && typeof data[1] === "string") {
-        return new RegExp(data[0], data[1]);
-      }
-      break;
-    case "Y": {
-      if (!Array.isArray(data) || typeof data[0] !== "string" || typeof data[1] !== "string") break;
-      const bytes = fromBase64(data[1]);
-      if (data[0] === "ArrayBuffer") return bytes.buffer;
-      if (data[0] === "DataView") return new DataView(bytes.buffer);
-      const TypedArray = Object.prototype.hasOwnProperty.call(TYPED_ARRAYS, data[0]) ? TYPED_ARRAYS[data[0]] : void 0;
-      if (!TypedArray || bytes.byteLength % TypedArray.BYTES_PER_ELEMENT !== 0) break;
-      return new TypedArray(
-        bytes.buffer,
-        0,
-        bytes.byteLength / TypedArray.BYTES_PER_ELEMENT
-      );
-    }
-    case "M":
-      if (Array.isArray(data) && data.every((entry) => Array.isArray(entry) && entry.length === 2)) {
-        return new Map(data.map(([key, value]) => [decodeChild(key), decodeChild(value)]));
-      }
-      break;
-    case "S":
-      if (Array.isArray(data)) return new Set(data.map(decodeChild));
-      break;
-    default:
-      throw new TypeError(`unknown ${JSON.stringify(tag)} tag`);
-  }
-  throw new TypeError(`malformed ${JSON.stringify(tag)} tag`);
-}
-function encodeFarmJson(value, seen = /* @__PURE__ */ new Set()) {
-  const leaf = encodeFarmLeaf(value);
-  if (leaf) return leaf;
-  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
-  if (typeof value === "number") return value;
-  if (typeof value !== "object") throw new TypeError(`${typeof value} values are not serializable`);
-  if (seen.has(value)) throw new TypeError("circular values are not serializable");
-  seen.add(value);
-  try {
-    if (Array.isArray(value)) return value.map((entry) => encodeFarmJson(entry, seen));
-    if (value instanceof Map) {
-      return farmTagged(
-        "M",
-        Array.from(value, ([key, entry]) => [
-          encodeFarmJson(key, seen),
-          encodeFarmJson(entry, seen)
-        ])
-      );
-    }
-    if (value instanceof Set) {
-      return farmTagged(
-        "S",
-        Array.from(value, (entry) => encodeFarmJson(entry, seen))
-      );
-    }
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null) {
-      throw new TypeError("class instances are not serializable");
-    }
-    const encoded = Object.fromEntries(
-      Object.entries(value).map(([key, entry]) => [key, encodeFarmJson(entry, seen)])
-    );
-    return needsFarmObjectTag(value) ? farmTagged(FARM_OBJECT_TAG, encoded) : encoded;
-  } finally {
-    seen.delete(value);
-  }
-}
-function decodeFarmJson(value) {
-  if (Array.isArray(value)) return value.map(decodeFarmJson);
-  if (!value || typeof value !== "object") return value;
-  if (getFarmTag(value) !== void 0) {
-    const decoded = decodeFarmTagged(value, decodeFarmJson);
-    if (decoded === NOT_A_FARM_MARKER) {
-      throw new TypeError(
-        `a ${JSON.stringify(value[FARM_TAG])} reference is not allowed here`
-      );
-    }
-    return decoded;
-  }
-  if (needsFarmObjectTag(value)) throw new TypeError('malformed "$" tag');
-  return farmPlainObject(Object.entries(value).map(([key, entry]) => [key, decodeFarmJson(entry)]));
-}
-
-export {
-  farmTagged,
-  needsFarmObjectTag,
-  encodeFarmLeaf,
-  NOT_A_FARM_MARKER,
-  farmPlainObject,
-  decodeFarmTagged,
-  encodeFarmJson,
-  decodeFarmJson
-};

package/dist/chunk-MPU5DOXX.cjs

@@ -1,21 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/server-query-protocol.ts
-var FARM_SERVER_QUERY_RESULT_VERSION = 1;
-function createFarmServerQueryResult(data, metadata) {
-  return {
-    __farmServerQuery: {
-      version: FARM_SERVER_QUERY_RESULT_VERSION,
-      ...metadata
-    },
-    data
-  };
-}
-function isFarmServerQueryResult(value) {
-  if (!value || typeof value !== "object") return false;
-  const metadata = value.__farmServerQuery;
-  return _optionalChain([metadata, 'optionalAccess', _ => _.version]) === FARM_SERVER_QUERY_RESULT_VERSION && typeof metadata.key === "string" && (metadata.staleTime === false || typeof metadata.staleTime === "number") && typeof metadata.updatedAt === "number" && "data" in value;
-}
-
-
-
-
-exports.createFarmServerQueryResult = createFarmServerQueryResult; exports.isFarmServerQueryResult = isFarmServerQueryResult;

package/dist/chunk-MRNDAJEV.mjs

@@ -1,293 +0,0 @@
-import {
-  FARM_DEFAULT_MCP_DESCRIPTION,
-  FARM_DEFAULT_MCP_PROTOCOL_VERSIONS,
-  FARM_DEFAULT_MCP_TOOLS
-} from "./chunk-E5DXF5GE.mjs";
-import {
-  stripFarmBasePath
-} from "./chunk-SF3JB56B.mjs";
-
-// src/agent-mcp-handler.ts
-var INSTRUCTIONS = "This server reads the site's public pages. Call list_pages or search_pages to find a page, then read_page with its path to get the page as Markdown. It cannot change anything.";
-var MAX_BODY_BYTES = 64 * 1024;
-var MAX_BATCH = 16;
-var READ_TIMEOUT_MS = 3e4;
-var FarmMCPRequestError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-  }
-};
-var PARSE_ERROR = -32700;
-var INVALID_REQUEST = -32600;
-var METHOD_NOT_FOUND = -32601;
-var INVALID_PARAMS = -32602;
-var INTERNAL_ERROR = -32603;
-var TRANSPORT_ERROR = -32e3;
-async function handleFarmDefaultMCPRequest(request, context) {
-  const method = request.method.toUpperCase();
-  if (method !== "POST") {
-    return transportError(405, "Method not allowed. Send MCP requests with POST.", {
-      Allow: "POST"
-    });
-  }
-  const origin = request.headers.get("origin");
-  if (origin && !isSameOrigin(origin, request.url)) {
-    return transportError(403, "Cross-origin requests are not allowed.");
-  }
-  const protocolHeader = request.headers.get("mcp-protocol-version");
-  if (protocolHeader && !FARM_DEFAULT_MCP_PROTOCOL_VERSIONS.includes(protocolHeader.trim())) {
-    return transportError(
-      400,
-      `Unsupported MCP-Protocol-Version: ${protocolHeader.slice(0, 32)}. Supported: ${FARM_DEFAULT_MCP_PROTOCOL_VERSIONS.join(", ")}.`
-    );
-  }
-  const contentType = request.headers.get("content-type") ?? "";
-  if (!/^application\/json\s*(?:;|$)/i.test(contentType.trim())) {
-    return transportError(415, "Content-Type must be application/json.");
-  }
-  const text = await readBody(request);
-  if (text === null) return transportError(413, "The request body is too large.");
-  let message;
-  try {
-    message = JSON.parse(text);
-  } catch {
-    return json(400, rpcError(null, { code: PARSE_ERROR, message: "Parse error." }));
-  }
-  if (Array.isArray(message)) {
-    if (message.length === 0 || message.length > MAX_BATCH) {
-      return json(
-        400,
-        rpcError(null, { code: INVALID_REQUEST, message: "Invalid batch of JSON-RPC messages." })
-      );
-    }
-    const replies = (await Promise.all(message.map((item) => answerMessage(item, request, context)))).filter((reply2) => reply2 !== void 0);
-    return replies.length ? json(200, replies) : new Response(null, { status: 202 });
-  }
-  const reply = await answerMessage(message, request, context);
-  return reply === void 0 ? new Response(null, { status: 202 }) : json(200, reply);
-}
-async function answerMessage(message, request, context) {
-  if (!isRecord(message) || message.jsonrpc !== "2.0") {
-    return rpcError(readId(message), { code: INVALID_REQUEST, message: "Invalid Request." });
-  }
-  const hasId = "id" in message;
-  if (typeof message.method !== "string") {
-    if (hasId && ("result" in message || "error" in message)) return void 0;
-    return rpcError(readId(message), { code: INVALID_REQUEST, message: "Invalid Request." });
-  }
-  if (!hasId) return void 0;
-  const id = readId(message);
-  if (id === void 0) {
-    return rpcError(null, { code: INVALID_REQUEST, message: "Invalid Request id." });
-  }
-  try {
-    const result = await dispatch(message.method, message.params, request, context);
-    return { jsonrpc: "2.0", id, result };
-  } catch (error) {
-    if (error instanceof FarmMCPRequestError) {
-      return rpcError(id, { code: error.code, message: error.message });
-    }
-    return rpcError(id, { code: INTERNAL_ERROR, message: "Internal error." });
-  }
-}
-async function dispatch(method, params, request, context) {
-  switch (method) {
-    case "initialize": {
-      const requested = isRecord(params) ? params.protocolVersion : void 0;
-      const protocolVersion = typeof requested === "string" && FARM_DEFAULT_MCP_PROTOCOL_VERSIONS.includes(requested) ? requested : FARM_DEFAULT_MCP_PROTOCOL_VERSIONS[0];
-      return {
-        protocolVersion,
-        capabilities: { tools: { listChanged: false } },
-        serverInfo: {
-          name: context.server.name,
-          version: context.server.version,
-          ...context.server.title ? { title: context.server.title } : {},
-          description: FARM_DEFAULT_MCP_DESCRIPTION
-        },
-        instructions: INSTRUCTIONS
-      };
-    }
-    case "ping":
-      return {};
-    case "tools/list":
-      return { tools: FARM_DEFAULT_MCP_TOOLS };
-    case "tools/call":
-      return callTool(params, request, context);
-    default:
-      throw new FarmMCPRequestError(METHOD_NOT_FOUND, `Method not found: ${method.slice(0, 64)}`);
-  }
-}
-async function callTool(params, request, context) {
-  if (!isRecord(params) || typeof params.name !== "string") {
-    throw new FarmMCPRequestError(INVALID_PARAMS, "tools/call needs a tool name.");
-  }
-  const tool = FARM_DEFAULT_MCP_TOOLS.find(({ name }) => name === params.name);
-  if (!tool) {
-    throw new FarmMCPRequestError(INVALID_PARAMS, `Unknown tool: ${params.name.slice(0, 64)}`);
-  }
-  const args = params.arguments ?? {};
-  if (!isRecord(args)) return toolError("Arguments must be an object.");
-  const allowed = new Set(Object.keys(tool.inputSchema.properties));
-  const unknown = Object.keys(args).find((key) => !allowed.has(key));
-  if (unknown) return toolError(`Unknown argument: ${unknown.slice(0, 64)}.`);
-  if (tool.name === "list_pages") return pagesResult(await context.listPages());
-  if (tool.name === "search_pages") {
-    const query = args.query;
-    if (typeof query !== "string" || !query.trim() || query.length > 200) {
-      return toolError("query must be a non-empty string of at most 200 characters.");
-    }
-    const limit = args.limit ?? 10;
-    if (typeof limit !== "number" || !Number.isInteger(limit) || limit < 1 || limit > 50) {
-      return toolError("limit must be a whole number from 1 to 50.");
-    }
-    return pagesResult(searchPages(await context.listPages(), query, limit));
-  }
-  const path = args.path;
-  if (typeof path !== "string" || !path.trim() || path.length > 2048) {
-    return toolError('path must be a page path such as "/about".');
-  }
-  const pagePath = toPagePath(path, request.url, context.basePath);
-  const pages = await context.listPages();
-  const page = pagePath ? pages.find((candidate) => candidate.path === pagePath) : void 0;
-  if (!page) {
-    return toolError(
-      `No public page at ${JSON.stringify(path.slice(0, 200))}. Call list_pages for the pages this server can read.`
-    );
-  }
-  const markdown = await readWithTimeout(context.readMarkdown, page.markdownUrl);
-  if (markdown === null) {
-    return toolError(`${page.path} did not answer with Markdown. Try again later.`);
-  }
-  return { content: [{ type: "text", text: markdown }] };
-}
-function pagesResult(pages) {
-  const structured = {
-    pages: pages.map(({ path, title, url, description }) => ({
-      path,
-      title,
-      url,
-      ...description ? { description } : {}
-    }))
-  };
-  return {
-    content: [{ type: "text", text: JSON.stringify(structured) }],
-    structuredContent: structured
-  };
-}
-function toolError(text) {
-  return { content: [{ type: "text", text }], isError: true };
-}
-function searchPages(pages, query, limit) {
-  const terms = query.toLowerCase().split(/\s+/).filter(Boolean).slice(0, 16);
-  return pages.map((page) => {
-    const title = page.title.toLowerCase();
-    const rest = `${page.description ?? ""} ${page.path}`.toLowerCase();
-    let score = 0;
-    for (const term of terms) {
-      if (title.includes(term)) score += 2;
-      else if (rest.includes(term)) score += 1;
-      else return null;
-    }
-    return { page, score };
-  }).filter((match) => match !== null).sort(
-    (left, right) => right.score - left.score || left.page.path.localeCompare(right.page.path)
-  ).slice(0, limit).map(({ page }) => page);
-}
-function toPagePath(input, requestUrl, basePath) {
-  let url;
-  try {
-    url = new URL(input.trim(), requestUrl);
-  } catch {
-    return null;
-  }
-  if (url.origin !== new URL(requestUrl).origin) return null;
-  let path = url.pathname;
-  try {
-    path = decodeURI(path);
-  } catch {
-    return null;
-  }
-  path = stripFarmBasePath(path, basePath);
-  if (path === "/index.md") return "/";
-  if (path.toLowerCase().endsWith(".md")) path = path.slice(0, -3) || "/";
-  return path.length > 1 ? path.replace(/\/+$/, "") || "/" : path;
-}
-async function readWithTimeout(read, url) {
-  let timer;
-  const timedOut = new Promise((resolve) => {
-    timer = setTimeout(resolve, READ_TIMEOUT_MS, null);
-  });
-  try {
-    return await Promise.race([read(url), timedOut]);
-  } finally {
-    clearTimeout(timer);
-  }
-}
-async function readBody(request) {
-  const declared = Number(request.headers.get("content-length"));
-  if (Number.isFinite(declared) && declared > MAX_BODY_BYTES) {
-    await request.body?.cancel().catch(() => {
-    });
-    return null;
-  }
-  if (!request.body) return "";
-  const reader = request.body.getReader();
-  const chunks = [];
-  let size = 0;
-  for (; ; ) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    size += value.byteLength;
-    if (size > MAX_BODY_BYTES) {
-      await reader.cancel().catch(() => {
-      });
-      return null;
-    }
-    chunks.push(value);
-  }
-  const body = new Uint8Array(size);
-  let offset = 0;
-  for (const chunk of chunks) {
-    body.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return new TextDecoder().decode(body);
-}
-function isSameOrigin(origin, requestUrl) {
-  try {
-    return new URL(origin).host === new URL(requestUrl).host;
-  } catch {
-    return false;
-  }
-}
-function readId(message) {
-  if (!isRecord(message)) return null;
-  const { id } = message;
-  return typeof id === "string" || typeof id === "number" && Number.isFinite(id) || id === null ? id : void 0;
-}
-function rpcError(id, error) {
-  return { jsonrpc: "2.0", id: id ?? null, error };
-}
-function json(status, body) {
-  return new Response(JSON.stringify(body), {
-    status,
-    headers: {
-      "Content-Type": "application/json; charset=utf-8",
-      "Cache-Control": "no-store",
-      "X-Content-Type-Options": "nosniff"
-    }
-  });
-}
-function transportError(status, message, headers = {}) {
-  const response = json(status, rpcError(null, { code: TRANSPORT_ERROR, message }));
-  for (const [name, value] of Object.entries(headers)) response.headers.set(name, value);
-  return response;
-}
-function isRecord(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-
-export {
-  handleFarmDefaultMCPRequest
-};