@farm.js/core 0.1.46 → 0.1.48

package/dist/chunk-HUL4LTC6.cjs

@@ -0,0 +1,390 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } 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; }
+
+var _chunkZGS3ZDF7cjs = require('./chunk-ZGS3ZDF7.cjs');
+
+
+var _chunkWJFFPXCVcjs = require('./chunk-WJFFPXCV.cjs');
+
+
+var _chunkEVIWKPJVcjs = require('./chunk-EVIWKPJV.cjs');
+
+
+var _chunkHNAISJFDcjs = require('./chunk-HNAISJFD.cjs');
+
+// src/plugins/infra-analytics.ts
+var _async_hooks = require('async_hooks');
+var FARM_PRERENDER_ENV = "FARM_PRERENDER";
+var DEFAULT_URL = "https://app.farmjs.dev";
+var EVENTS_PATH = "/api/telemetry/v1/events";
+var INGESTION_KEY = /^fti_[A-Za-z0-9_-]{43}$/;
+var API_KEY = /^farmjs_[A-Za-z0-9_-]{32}$/;
+var PROJECT = /^proj_[0-9a-f-]{36}$/;
+var ENVIRONMENTS = ["production", "staging", "development"];
+var METHODS = /* @__PURE__ */ new Set(["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "QUERY"]);
+var MAX_QUEUE = 500;
+var MAX_AGE = 3e5;
+var MAX_ATTEMPTS = 5;
+var FLUSH_BUDGET = 5e3;
+var TIMEOUT = 2e3;
+var encoder = new TextEncoder();
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var uuid = () => globalThis.crypto.randomUUID();
+function processEnv() {
+  return _nullishCoalesce(_optionalChain([globalThis, 'access', _ => _.process, 'optionalAccess', _2 => _2.env]), () => ( {}));
+}
+function defaultFarmInfraEnvironment(env = processEnv()) {
+  const explicit = env.FARMJS_ENVIRONMENT;
+  if (explicit && ENVIRONMENTS.includes(explicit)) return explicit;
+  if (env.VERCEL_ENV === "production") return "production";
+  if (env.VERCEL_ENV === "preview") return "staging";
+  if (env.VERCEL_ENV === "development") return "development";
+  return env.NODE_ENV === "production" ? "production" : "development";
+}
+function resolveFarmInfraAnalytics(env = processEnv()) {
+  const key = _optionalChain([env, 'access', _3 => _3.FARMJS_API_KEY, 'optionalAccess', _4 => _4.trim, 'call', _5 => _5()]);
+  if (!key || env[FARM_PRERENDER_ENV] === "1") return { off: null };
+  const ingestionKey = INGESTION_KEY.test(key);
+  const projectId = _optionalChain([env, 'access', _6 => _6.FARMJS_PROJECT_ID, 'optionalAccess', _7 => _7.trim, 'call', _8 => _8()]) || void 0;
+  if (!ingestionKey && !projectId) return { off: null };
+  if (!ingestionKey && !API_KEY.test(key)) {
+    return {
+      off: "FARMJS_API_KEY isn't a Farm Infra API key (farmjs_\u2026) or write-only key (fti_\u2026)"
+    };
+  }
+  if (!ingestionKey && !PROJECT.test(projectId)) {
+    return { off: "FARMJS_PROJECT_ID isn't a Farm Infra project ID (proj_\u2026)" };
+  }
+  if (env.FARMJS_ENVIRONMENT && !ENVIRONMENTS.includes(env.FARMJS_ENVIRONMENT)) {
+    return { off: "FARMJS_ENVIRONMENT must be production, staging or development" };
+  }
+  let endpoint;
+  try {
+    endpoint = new URL(EVENTS_PATH, _optionalChain([env, 'access', _9 => _9.FARMJS_API_URL, 'optionalAccess', _10 => _10.trim, 'call', _11 => _11()]) || DEFAULT_URL);
+  } catch (e) {
+    return { off: "FARMJS_API_URL isn't a URL" };
+  }
+  const loopback = ["localhost", "127.0.0.1", "[::1]"].includes(endpoint.hostname);
+  if (endpoint.protocol !== "https:" && !(endpoint.protocol === "http:" && loopback) || endpoint.username || endpoint.password) {
+    return { off: "FARMJS_API_URL must use HTTPS (HTTP only for localhost)" };
+  }
+  return {
+    options: {
+      endpoint: endpoint.href,
+      key,
+      ...ingestionKey ? {} : { projectId, environment: defaultFarmInfraEnvironment(env) }
+    }
+  };
+}
+function classifyFarmInfraAgent(userAgent) {
+  return _chunkWJFFPXCVcjs.classifyFarmAgent.call(void 0, userAgent);
+}
+function routeTemplate(pattern) {
+  return typeof pattern === "string" && pattern.length <= 256 && /^\/(?!\/)[a-zA-Z0-9_./:[\]()*-]*$/.test(pattern) ? pattern : "/[unmatched]";
+}
+function duration(value) {
+  return Number.isFinite(value) ? Math.min(864e5, Math.max(0, value)) : 0;
+}
+function isToolEvent(value) {
+  if (!value || typeof value !== "object") return false;
+  const event = value;
+  return event.type === "mcp.tool.complete" && typeof event.tool === "string" && /^[a-zA-Z0-9_.:/-]{1,128}$/.test(event.tool) && (event.outcome === "success" || event.outcome === "error") && typeof event.durationMs === "number" && Number.isFinite(event.durationMs);
+}
+function retryAt(value, now) {
+  if (!value) return now;
+  if (/^\d+$/.test(value.trim())) return now + Math.min(Number(value), 86400) * 1e3;
+  const date = Date.parse(value);
+  return Number.isFinite(date) ? Math.max(now, Math.min(date, now + 864e5)) : now;
+}
+function createFarmInfraAnalyticsExporter(options, send = (input, init) => fetch(input, init)) {
+  const requestHeaders = {
+    "content-type": "application/json",
+    authorization: `Bearer ${options.key}`
+  };
+  if (!INGESTION_KEY.test(options.key)) {
+    requestHeaders["x-farm-project"] = options.projectId;
+    requestHeaders["x-farm-environment"] = _nullishCoalesce(options.environment, () => ( defaultFarmInfraEnvironment()));
+  }
+  const queue = [];
+  let stopped = false;
+  let closing = false;
+  let pending;
+  let notBefore = 0;
+  let active;
+  let inFlight = /* @__PURE__ */ new Set();
+  const diagnostic = (event) => {
+    try {
+      void Promise.resolve(_optionalChain([options, 'access', _12 => _12.onDiagnostic, 'optionalCall', _13 => _13(event)])).catch(() => {
+      });
+    } catch (e2) {
+    }
+  };
+  const expired = (item, now) => !inFlight.has(item) && (now - item.enqueuedAt >= MAX_AGE || item.attempts >= MAX_ATTEMPTS);
+  function prune() {
+    const now = Date.now();
+    let count = 0;
+    for (let i = queue.length - 1; i >= 0; i--) {
+      if (expired(queue[i], now)) {
+        queue.splice(i, 1);
+        count++;
+      }
+    }
+    if (count) diagnostic({ code: "dropped", count });
+  }
+  function remove(batch) {
+    const sent = new Set(batch);
+    for (let i = queue.length - 1; i >= 0; i--) if (sent.has(queue[i])) queue.splice(i, 1);
+  }
+  function enqueue(event) {
+    if (stopped || closing) return;
+    prune();
+    if (queue.length >= MAX_QUEUE) {
+      diagnostic({ code: "dropped", count: 1 });
+      return;
+    }
+    queue.push({ event, enqueuedAt: Date.now(), attempts: 0 });
+  }
+  async function drain() {
+    const deadline = Date.now() + FLUSH_BUDGET;
+    await sleep(25);
+    while (!stopped && queue.length && Date.now() < deadline) {
+      prune();
+      if (!queue.length || notBefore >= deadline) break;
+      if (notBefore > Date.now()) await sleep(notBefore - Date.now());
+      if (stopped || Date.now() >= deadline) break;
+      const batch = queue.slice(0, 50);
+      const body = JSON.stringify({ schemaVersion: 1, events: batch.map(({ event }) => event) });
+      if (encoder.encode(body).length > 128 * 1024) {
+        queue.splice(0, batch.length);
+        diagnostic({ code: "dropped", count: batch.length });
+        continue;
+      }
+      for (const item of batch) item.attempts++;
+      inFlight = new Set(batch);
+      active = new AbortController();
+      const timeout = setTimeout(() => _optionalChain([active, 'optionalAccess', _14 => _14.abort, 'call', _15 => _15()]), Math.min(TIMEOUT, deadline - Date.now()));
+      let status;
+      try {
+        const response = await send(options.endpoint, {
+          method: "POST",
+          redirect: "error",
+          signal: active.signal,
+          headers: requestHeaders,
+          body
+        });
+        status = response.status;
+        void _optionalChain([response, 'access', _16 => _16.body, 'optionalAccess', _17 => _17.cancel, 'call', _18 => _18(), 'access', _19 => _19.catch, 'call', _20 => _20(() => {
+        })]);
+        if (response.ok) {
+          remove(batch);
+          continue;
+        }
+        if ([400, 401, 403, 404, 413, 415].includes(status) || status >= 300 && status < 400) {
+          stopped = true;
+          queue.length = 0;
+          diagnostic({ code: "disabled", status });
+          break;
+        }
+        if (status !== 408 && status !== 429 && status < 500) {
+          remove(batch);
+          diagnostic({ code: "dropped", count: batch.length, status });
+          continue;
+        }
+        notBefore = Math.max(notBefore, retryAt(response.headers.get("retry-after"), Date.now()));
+      } catch (e3) {
+      } finally {
+        clearTimeout(timeout);
+        active = void 0;
+        inFlight.clear();
+      }
+      notBefore = Math.max(
+        notBefore,
+        Date.now() + Math.min(3e4, 500 * 2 ** (batch[0].attempts - 1))
+      );
+      diagnostic({ code: "retry", ...status === void 0 ? {} : { status } });
+    }
+  }
+  function flush() {
+    if (stopped || !queue.length || notBefore > Date.now() + FLUSH_BUDGET)
+      return _nullishCoalesce(pending, () => ( Promise.resolve()));
+    _nullishCoalesce(pending, () => ( (pending = drain().catch(() => {
+    }).finally(() => {
+      pending = void 0;
+    }))));
+    return pending;
+  }
+  async function close() {
+    if (closing) {
+      await pending;
+      return;
+    }
+    closing = true;
+    await flush();
+    stopped = true;
+    _optionalChain([active, 'optionalAccess', _21 => _21.abort, 'call', _22 => _22()]);
+    if (queue.length) diagnostic({ code: "dropped", count: queue.length });
+    queue.length = 0;
+  }
+  return { enqueue, flush, close };
+}
+var CONTEXT_KEY = "farm.infra.analytics";
+function beginRequest(request, route, waitUntil) {
+  return {
+    id: uuid(),
+    agent: classifyFarmInfraAgent(request.headers.get("user-agent")),
+    route,
+    completed: false,
+    waitUntil
+  };
+}
+function requestEvent(metadata, method, status, durationMs) {
+  return {
+    id: uuid(),
+    requestId: metadata.id,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    route: routeTemplate(_chunkZGS3ZDF7cjs.getFarmRouteLabel.call(void 0, metadata.route)),
+    agent: metadata.agent,
+    kind: "request",
+    method,
+    status,
+    durationMs: duration(durationMs)
+  };
+}
+function toolEvent(metadata, event) {
+  return {
+    id: uuid(),
+    requestId: metadata.id,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    route: routeTemplate(_chunkZGS3ZDF7cjs.getFarmRouteLabel.call(void 0, metadata.route)),
+    agent: metadata.agent,
+    kind: "mcp.tool",
+    tool: event.tool,
+    outcome: event.outcome,
+    durationMs: duration(event.durationMs)
+  };
+}
+function farmInfraAnalyticsPlugin(options, send) {
+  const contextKey = `${CONTEXT_KEY}.${uuid()}`;
+  return {
+    name: "farm:infra-analytics",
+    enforce: "post",
+    setup(context) {
+      const state = { exporter: createFarmInfraAnalyticsExporter(options, send) };
+      context.lifecycle.onShutdown(async () => {
+        _optionalChain([state, 'access', _23 => _23.unsubscribe, 'optionalCall', _24 => _24()]);
+        await state.exporter.close();
+      });
+      return state;
+    },
+    runtime: {
+      // Recording a request decides nothing about who may read the response.
+      cache: "public",
+      start(context) {
+        const { exporter } = context.state;
+        context.state.unsubscribe = _chunkEVIWKPJVcjs.onFarmEvent.call(void 0, 
+          (event) => {
+            if (!isToolEvent(event)) return;
+            const request = _chunkHNAISJFDcjs.getCurrentRequestOrNull.call(void 0, );
+            if (!request) return;
+            const metadata = context.requestContext.get(request, contextKey);
+            if (!metadata) return;
+            exporter.enqueue(toolEvent(metadata, event));
+            metadata.waitUntil(exporter.flush());
+          },
+          { unfiltered: true }
+        );
+      },
+      before(event) {
+        if (event.kind === "asset" || !event.state) return;
+        event.req.set(contextKey, beginRequest(event.request, event.route, event.waitUntil));
+      },
+      after(event) {
+        const metadata = _nullishCoalesce(event.req.get(contextKey), () => ( (event.kind === "endpoint" ? beginRequest(event.request, event.route, event.waitUntil) : void 0)));
+        if (!metadata || metadata.completed || !event.state) return;
+        metadata.completed = true;
+        if (!METHODS.has(event.request.method)) return;
+        event.state.exporter.enqueue(
+          requestEvent(metadata, event.request.method, event.response.status, event.durationMs)
+        );
+        event.waitUntil(event.state.exporter.flush());
+      },
+      // Unhandled exceptions have no final HTTP status at this boundary. Do not fabricate a 500.
+      error(event) {
+        const metadata = event.req.get(contextKey);
+        if (metadata) metadata.completed = true;
+        if (event.state) event.waitUntil(event.state.exporter.flush());
+      }
+    }
+  };
+}
+function farmInfraAnalyticsRecorder(options, send) {
+  const exporter = createFarmInfraAnalyticsExporter(options, send);
+  const requests = new (0, _async_hooks.AsyncLocalStorage)();
+  const unsubscribe = _chunkEVIWKPJVcjs.onFarmEvent.call(void 0, 
+    (event) => {
+      if (!isToolEvent(event)) return;
+      const metadata = requests.getStore();
+      if (!metadata) return;
+      exporter.enqueue(toolEvent(metadata, event));
+      metadata.waitUntil(exporter.flush());
+    },
+    { unfiltered: true }
+  );
+  return {
+    async record(request, runtime, waitUntil, handler) {
+      if (runtime.kind === "asset") return handler();
+      const background = (promise) => waitUntil ? waitUntil(promise) : void promise.catch(() => {
+      });
+      const metadata = beginRequest(request, runtime.route, background);
+      const startedAt = performance.now();
+      let response;
+      try {
+        response = await requests.run(metadata, handler);
+      } catch (error) {
+        background(exporter.flush());
+        throw error;
+      }
+      if (METHODS.has(request.method)) {
+        exporter.enqueue(
+          requestEvent(metadata, request.method, response.status, performance.now() - startedAt)
+        );
+      }
+      background(exporter.flush());
+      return response;
+    },
+    close() {
+      unsubscribe();
+      return exporter.close();
+    }
+  };
+}
+function linkedOptions(env, warn) {
+  const resolved = resolveFarmInfraAnalytics(env);
+  if ("off" in resolved) {
+    if (resolved.off) warn(`[Farm] Farm Infra analytics is off: ${resolved.off}.`);
+    return null;
+  }
+  return {
+    ...resolved.options,
+    onDiagnostic(event) {
+      if (event.code === "disabled") {
+        warn(
+          `[Farm] Farm Infra analytics stopped: Farm Infra answered ${event.status}. Check FARMJS_API_KEY and FARMJS_PROJECT_ID, then restart the server.`
+        );
+      }
+    }
+  };
+}
+function createFarmInfraAnalyticsPlugin(env = processEnv(), warn = console.warn) {
+  const options = linkedOptions(env, warn);
+  return options ? farmInfraAnalyticsPlugin(options) : null;
+}
+function createFarmInfraAnalyticsRecorder(env = processEnv(), warn = console.warn) {
+  const options = linkedOptions(env, warn);
+  return options ? farmInfraAnalyticsRecorder(options) : null;
+}
+
+
+
+
+
+exports.FARM_PRERENDER_ENV = FARM_PRERENDER_ENV; exports.createFarmInfraAnalyticsPlugin = createFarmInfraAnalyticsPlugin; exports.createFarmInfraAnalyticsRecorder = createFarmInfraAnalyticsRecorder;

package/dist/chunk-HXNLKCWH.cjs

@@ -0,0 +1,13 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/redirect-query.ts
+function appendFarmRedirectQuery(destination, search) {
+  if (!search || search === "?") return destination;
+  const hashIndex = destination.indexOf("#");
+  const pathAndQuery = hashIndex === -1 ? destination : destination.slice(0, hashIndex);
+  if (pathAndQuery.includes("?")) return destination;
+  if (hashIndex === -1) return `${destination}${search}`;
+  return `${pathAndQuery}${search}${destination.slice(hashIndex)}`;
+}
+
+
+
+exports.appendFarmRedirectQuery = appendFarmRedirectQuery;

package/dist/chunk-HZOMT5DY.mjs

@@ -0,0 +1,30 @@
+// src/font.ts
+function defineLayoutFonts(fonts) {
+  return fonts;
+}
+function resolveFarmLayoutFonts(layouts) {
+  let resolved;
+  for (const layout of layouts) {
+    if (!layout.fonts) continue;
+    resolved = { ...resolved, ...layout.fonts };
+  }
+  return resolved;
+}
+function fontCompilerError(loader) {
+  throw new Error(
+    `[Farm fonts] ${loader}() must be called at module scope with static options and compiled by the Farm Vite plugin.`
+  );
+}
+function localFont(_options) {
+  return fontCompilerError("localFont");
+}
+function remoteFont(_options) {
+  return fontCompilerError("remoteFont");
+}
+
+export {
+  defineLayoutFonts,
+  resolveFarmLayoutFonts,
+  localFont,
+  remoteFont
+};