theokit 0.48.7 → 0.48.9

package/dist/{routes-6AMNVFMI.js → routes-OLNQX7CT.js}

@@ -5,9 +5,9 @@ import {
 } from "./chunk-GEQJAFSV.js";
 import {
   loadConfig
-} from "./chunk-GH32R55S.js";
+} from "./chunk-S433N3CT.js";
 import "./chunk-HBU2GIMZ.js";
-import "./chunk-A4ZEP3FE.js";
+import "./chunk-GVW5EKEU.js";
 import "./chunk-7VPQHEAJ.js";
 import {
   scanServerActions,
@@ -62,4 +62,4 @@ async function routesCommand() {
 export {
   routesCommand
 };
-//# sourceMappingURL=routes-6AMNVFMI.js.map
+//# sourceMappingURL=routes-OLNQX7CT.js.map

package/dist/{schema-Z3Y7SFLE.js → schema-ZO3OSWVG.js}

@@ -6,7 +6,7 @@ import {
   securityHeadersSchema,
   storageSchema,
   theoConfigSchema
-} from "./chunk-A4ZEP3FE.js";
+} from "./chunk-GVW5EKEU.js";
 import "./chunk-7VPQHEAJ.js";
 export {
   cacheSchema,
@@ -15,4 +15,4 @@ export {
   storageSchema,
   theoConfigSchema
 };
-//# sourceMappingURL=schema-Z3Y7SFLE.js.map
+//# sourceMappingURL=schema-ZO3OSWVG.js.map

package/dist/server/index.js

@@ -47,7 +47,7 @@ import {
   deriveKey,
   deriveKeyFromRequest,
   matchRoutePattern
-} from "../chunk-UDPJP42U.js";
+} from "../chunk-GPX7I5ZY.js";
 import {
   ChannelManager
 } from "../chunk-4PBJ266F.js";

package/dist/server/rate-limit/index.d.ts

@@ -4,6 +4,41 @@ import { R as RateLimitStore } from '../../rate-limit-store-BEJnhWdw.js';
 export { I as InMemoryStore, a as RateLimitState } from '../../rate-limit-store-BEJnhWdw.js';
 import { IncomingMessage } from 'node:http';
 
+/**
+ * Resolves the address a rate-limit bucket should be keyed on.
+ *
+ * ## Why this is not just `req.socket.remoteAddress`
+ *
+ * Behind any reverse proxy — Caddy, nginx, a load balancer, an ingress controller — the socket
+ * address is the PROXY's, identical for every visitor on the internet. Keying buckets on it gives
+ * the whole world one shared budget, so the first few requests each minute exhaust it and everyone
+ * else is refused. That is worse than no limiting: a limit meant to stop one abusive client becomes
+ * a denial of service any single client can trigger for everybody.
+ *
+ * ## Why it is opt-in
+ *
+ * `x-forwarded-for` is a request header, and a request header is whatever the client typed. Reading
+ * it without being told to would let anyone bypass the limiter by rotating a forged value — a
+ * one-line `curl -H`. So the default is to trust nothing and use the socket.
+ *
+ * ## Why the RIGHTMOST entry
+ *
+ * Each proxy APPENDS the address that connected to it. A client that sends `x-forwarded-for: 1.2.3.4`
+ * through one proxy produces `1.2.3.4, <real client>` — the forgery lands on the left, and the entry
+ * the trusted proxy wrote is last. Counting from the right therefore skips exactly the hops the
+ * operator vouched for, and everything a client can influence stays to the left of where we look.
+ *
+ * This mirrors the `'trusted-proxy'` policy in `adapters/web-shim.ts`, which documents the same rule
+ * for the Web-Request runtimes.
+ */
+/**
+ * How many proxies sit in front of the app.
+ *
+ * `false` (the default) trusts nothing and uses the socket address. `true` means one trusted proxy.
+ * A number names the hop count for a longer chain — a CDN in front of your own proxy is `2`.
+ */
+type TrustProxy = boolean | number;
+
 /**
  * T2.2 — Per-route + per-user rate limiting.
  *
@@ -29,6 +64,19 @@ interface RouteRateLimitConfig {
     cookieName?: string;
     /** Optional shared store (for multi-route correlation). Default per-limiter InMemoryStore. */
     store?: RateLimitStore;
+    /**
+     * How many reverse proxies sit in front of the app, for `keyBy: 'ip'`. Default `false` — trust
+     * none and key on the socket address.
+     *
+     * Set this whenever the app is behind Caddy, nginx, a load balancer or an ingress controller:
+     * without it every visitor keys on the proxy's address and shares one bucket, so a handful of
+     * requests exhausts the budget for the entire internet. With it, the client address is read from
+     * `x-forwarded-for` counting in from the right, past exactly the hops declared here.
+     *
+     * Leaving it off by default is deliberate — `x-forwarded-for` is client-writable, and honouring it
+     * uninvited turns the limiter into a one-header bypass. See `client-ip.ts`.
+     */
+    trustProxy?: TrustProxy;
 }
 /**
  * Test whether `path` matches `pattern`. String patterns are compared
@@ -44,7 +92,7 @@ declare function matchRoutePattern(path: string, pattern: string | RegExp): bool
  * we fall back to IP so anonymous users still get rate-limited rather
  * than sharing an empty bucket.
  */
-declare function deriveKey(req: IncomingMessage, keyBy: KeyByMode, cookieName: string): Promise<string>;
+declare function deriveKey(req: IncomingMessage, keyBy: KeyByMode, cookieName: string, trustProxy?: TrustProxy): Promise<string>;
 /**
  * Per-route rate limiter factory. Returns a sync checker compatible with
  * the existing api-middleware shape.

package/dist/server/rate-limit/index.js

@@ -4,7 +4,7 @@ import {
   deriveKey,
   deriveKeyFromRequest,
   matchRoutePattern
-} from "../../chunk-UDPJP42U.js";
+} from "../../chunk-GPX7I5ZY.js";
 import {
   InMemoryStore,
   createRateLimiter,

package/dist/{start-IITIEJTY.js → start-KR2JJR7K.js}

@@ -3,10 +3,14 @@ import "tsx/esm";
 import {
   CONTROLLER_MANIFEST_FILE
 } from "./chunk-47CINLWF.js";
+import {
+  parseCookieHeader
+} from "./chunk-V7MTRM6Q.js";
 import {
   preflightNodeAndBindings
 } from "./chunk-KTMQUYED.js";
 import {
+  applyNonceToInlineScripts,
   extractHeadTags,
   handleAgentApproval,
   injectIntoHead,
@@ -14,30 +18,30 @@ import {
   resolveTransformer,
   serveAgentAuxRoute,
   writeWebResponseToServerResponse
-} from "./chunk-3GUXSNHY.js";
+} from "./chunk-GRI4XHBJ.js";
 import "./chunk-2CVV6CNN.js";
 import {
   findRootDiv
 } from "./chunk-3PWQQWT6.js";
 import {
   loadConfig
-} from "./chunk-GH32R55S.js";
+} from "./chunk-S433N3CT.js";
 import {
   loadEnv
 } from "./chunk-HBU2GIMZ.js";
-import "./chunk-A4ZEP3FE.js";
+import "./chunk-GVW5EKEU.js";
 import "./chunk-7VPQHEAJ.js";
 import {
+  InMemoryStore,
   buildSecurityHeaders,
   createPluginRunnerFromConfig,
   createProductionLoader,
-  createRateLimiter,
   executeAction,
   executeRoute,
   findSuggestion,
   generateNonce,
   mountAgent
-} from "./chunk-H6YBKIUN.js";
+} from "./chunk-BIVCP6X5.js";
 import {
   getApprovalRegistry,
   resolveProvider
@@ -96,6 +100,131 @@ async function serveReservedRoute(pathname, routes = {}) {
   return null;
 }
 
+// src/server/rate-limit/client-ip.ts
+function hopCount(trustProxy) {
+  if (trustProxy === true) return 1;
+  if (trustProxy === false) return 0;
+  return trustProxy;
+}
+function headerValue(req, name) {
+  const raw = req.headers[name];
+  if (Array.isArray(raw)) return raw[raw.length - 1];
+  return raw;
+}
+function resolveClientIp(req, trustProxy = false) {
+  const socketAddress = req.socket?.remoteAddress ?? "unknown";
+  const hops = hopCount(trustProxy);
+  if (hops < 1) return socketAddress;
+  const forwarded = headerValue(req, "x-forwarded-for");
+  if (forwarded) {
+    const entries = forwarded.split(",").map((entry) => entry.trim()).filter(Boolean);
+    const index = entries.length - hops;
+    if (index >= 0 && index < entries.length) return entries[index];
+  }
+  const realIp = headerValue(req, "x-real-ip");
+  if (realIp) return realIp.trim();
+  return socketAddress;
+}
+
+// src/server/rate-limit/rate-limit-per-route.ts
+function normalizePath(input) {
+  const noQuery = input.split("?")[0];
+  if (noQuery.length > 1 && noQuery.endsWith("/")) return noQuery.slice(0, -1);
+  return noQuery;
+}
+function matchRoutePattern(path, pattern) {
+  const canonical = normalizePath(path);
+  if (typeof pattern === "string") {
+    return canonical === normalizePath(pattern);
+  }
+  pattern.lastIndex = 0;
+  return pattern.test(canonical);
+}
+async function hashFragment(input) {
+  const buf = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(input));
+  const bytes = new Uint8Array(buf);
+  let bin = "";
+  for (const b of bytes) bin += String.fromCharCode(b);
+  const b64url = btoa(bin).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  return b64url.slice(0, 16);
+}
+function readCookie(req, name) {
+  return parseCookieHeader(req.headers.cookie ?? void 0).get(name);
+}
+async function deriveKey(req, keyBy, cookieName, trustProxy = false) {
+  if (typeof keyBy === "function") return keyBy(req);
+  const ip = resolveClientIp(req, trustProxy);
+  switch (keyBy) {
+    case "session": {
+      const cookie = readCookie(req, cookieName);
+      return cookie ? `session:${await hashFragment(cookie)}` : `ip:${ip}`;
+    }
+    case "user": {
+      const userId = req.user?.id;
+      return userId ? `user:${userId}` : `ip:${ip}`;
+    }
+    case "ip":
+    default:
+      return `ip:${ip}`;
+  }
+}
+function createRouteRateLimiter(config) {
+  const isFlat = "windowMs" in config && "max" in config && !("default" in config) && !("routes" in config);
+  const cfg = isFlat ? { default: config } : config;
+  const store = cfg.store ?? new InMemoryStore();
+  if (!(store instanceof InMemoryStore)) {
+    throw new Error(
+      "createRouteRateLimiter: async RateLimitStore implementations require a dedicated async middleware path. Use the InMemoryStore default for the sync facade."
+    );
+  }
+  const inMemoryStore = store;
+  const keyBy = cfg.keyBy ?? "ip";
+  const cookieName = cfg.cookieName ?? "theo_session";
+  const trustProxy = cfg.trustProxy ?? false;
+  const patternList = [];
+  if (cfg.routes) {
+    for (const [pattern, c] of Object.entries(cfg.routes)) patternList.push([pattern, c]);
+  }
+  if (cfg.routePatterns) {
+    for (const tuple of cfg.routePatterns) patternList.push(tuple);
+  }
+  return async function checkRouteRateLimit(req) {
+    const url = req.url ?? "";
+    let matched;
+    for (const [pattern, c] of patternList) {
+      if (matchRoutePattern(url, pattern)) {
+        matched = c;
+        break;
+      }
+    }
+    const effective = matched ?? cfg.default;
+    if (!effective) {
+      return { limited: false, headers: {} };
+    }
+    const bucketSuffix = typeof matched === "undefined" ? "*default*" : normalizePath(url);
+    const key = `${await deriveKey(req, keyBy, cookieName, trustProxy)}|${bucketSuffix}`;
+    const state = inMemoryStore.incrSync(key, effective.windowMs);
+    if (state.count > effective.max) {
+      const retryAfter = Math.ceil((state.resetAt - Date.now()) / 1e3);
+      return {
+        limited: true,
+        headers: {
+          "X-RateLimit-Limit": String(effective.max),
+          "X-RateLimit-Remaining": "0",
+          "Retry-After": String(retryAfter)
+        }
+      };
+    }
+    return {
+      limited: false,
+      headers: {
+        "X-RateLimit-Limit": String(effective.max),
+        "X-RateLimit-Remaining": String(Math.max(0, effective.max - state.count))
+      }
+    };
+  };
+}
+
 // src/cli/commands/start/assert-sdk-compatible.ts
 import { readFileSync } from "fs";
 import { createRequire } from "module";
@@ -201,7 +330,7 @@ async function configureStorageManagerFromConfig(storageConfig) {
   if (storageConfig === void 0 || storageConfig === null) return;
   try {
     const { getStorageManager } = await import("./storage-manager-3O5PDO6O.js");
-    const { storageSchema } = await import("./schema-Z3Y7SFLE.js");
+    const { storageSchema } = await import("./schema-ZO3OSWVG.js");
     const parsed = storageSchema.parse(storageConfig);
     getStorageManager().configure(parsed);
   } catch (err) {
@@ -358,9 +487,9 @@ async function loadCompiledController(absPath) {
   return await import(pathToFileURL(absPath).href);
 }
 var X_REQUEST_ID = "x-request-id";
-function applyRateLimit(c, method) {
+async function applyRateLimit(c, method) {
   if (!c.rateLimiter) return false;
-  const check = c.rateLimiter(c.req);
+  const check = await c.rateLimiter(c.req);
   for (const [k, v] of Object.entries(check.headers)) c.res.setHeader(k, v);
   if (check.limited) {
     sendError(c.res, "RATE_LIMITED", "Too many requests", 429, void 0, c.requestId);
@@ -378,7 +507,7 @@ function applyRateLimit(c, method) {
 async function tryServeAction(c) {
   if (!c.url.startsWith("/api/__actions/")) return false;
   c.res.setHeader(X_REQUEST_ID, c.requestId);
-  if (applyRateLimit(c, c.req.method ?? "POST")) return true;
+  if (await applyRateLimit(c, c.req.method ?? "POST")) return true;
   const pathAfterPrefix = c.url.slice("/api/__actions/".length).split("?")[0];
   const segments = pathAfterPrefix.split("/").filter(Boolean);
   if (segments.length < 2) {
@@ -467,7 +596,7 @@ async function tryServeAgent(c) {
   const urlPath = c.url.split("?")[0];
   if (isApprovalPath(urlPath)) {
     c.res.setHeader(X_REQUEST_ID, c.requestId);
-    if (applyRateLimit(c, c.req.method ?? "POST")) return true;
+    if (await applyRateLimit(c, c.req.method ?? "POST")) return true;
     const method2 = (c.req.method ?? "POST").toUpperCase();
     if (method2 !== "POST") {
       sendError(
@@ -518,7 +647,7 @@ async function tryServeAgent(c) {
   const agent = c.cachedAgents.find((a) => a.agentPath === urlPath);
   if (!agent) return false;
   c.res.setHeader(X_REQUEST_ID, c.requestId);
-  if (applyRateLimit(c, c.req.method ?? "POST")) return true;
+  if (await applyRateLimit(c, c.req.method ?? "POST")) return true;
   const method = (c.req.method ?? "POST").toUpperCase();
   if (method !== "POST") {
     sendError(
@@ -570,7 +699,7 @@ async function tryServeAgent(c) {
 async function tryServeApiRoute(c) {
   if (!c.url.startsWith("/api/")) return false;
   c.res.setHeader(X_REQUEST_ID, c.requestId);
-  if (applyRateLimit(c, c.req.method ?? "GET")) return true;
+  if (await applyRateLimit(c, c.req.method ?? "GET")) return true;
   const match = matchRoute(c.url, c.cachedRoutes);
   if (!match) {
     if (c.controllersDistDir !== void 0) {
@@ -702,23 +831,24 @@ function send500(res, custom500Html) {
     res.end(custom500Html ?? "<h1>500 \u2014 Server Error</h1>");
   }
 }
-function withHoistedHead(htmlHead, ssrHtml) {
+function withHoistedHead(htmlHead, ssrHtml, nonce) {
   const { html, headTags } = extractHeadTags(ssrHtml);
-  return { head: injectIntoHead(htmlHead, headTags), body: html };
+  const head = applyNonceToInlineScripts(injectIntoHead(htmlHead, headTags), nonce);
+  return { head, body: html };
 }
 function buildSsrHtml(ctx, result, nonce) {
   if (typeof result === "string") {
-    const { head, body } = withHoistedHead(ctx.htmlHead, result);
+    const { head, body } = withHoistedHead(ctx.htmlHead, result, nonce);
     return head + body + ctx.htmlTail;
   }
   if (isSsrRenderResult(result)) {
     const rendered = asSsrRenderResult(result);
     const dataJson = JSON.stringify(rendered.hydrationData).replace(/</g, "\\u003c");
     const hydrationScript = `<script${nonce ? ` nonce="${nonce}"` : ""}>window.__staticRouterHydrationData=${dataJson}</script>`;
-    const { head, body } = withHoistedHead(ctx.htmlHead, rendered.html);
+    const { head, body } = withHoistedHead(ctx.htmlHead, rendered.html, nonce);
     return head + body + hydrationScript + ctx.htmlTail;
   }
-  return ctx.htmlHead + ctx.htmlTail;
+  return applyNonceToInlineScripts(ctx.htmlHead, nonce) + ctx.htmlTail;
 }
 async function handleSsrStreaming(ctx, req, res, url, nonce) {
   if (!ctx.ssrStreamingEnabled || !ctx.ssrRenderStreaming) return false;
@@ -880,8 +1010,7 @@ async function startCommand(options) {
     wsRoutes: cachedWsRoutes,
     agents: cachedAgents
   } = loadRoutesAndActions(distDir, serverDir, config.agentsDir);
-  const flatRateLimit = config.rateLimit && "windowMs" in config.rateLimit && "max" in config.rateLimit ? config.rateLimit : void 0;
-  const rateLimiter = flatRateLimit ? createRateLimiter(flatRateLimit) : null;
+  const rateLimiter = config.rateLimit ? createRouteRateLimiter(config.rateLimit) : null;
   const ssr = await setupSsr({
     distDir,
     indexHtml,
@@ -938,4 +1067,4 @@ export {
   resolveSsrEntry,
   startCommand
 };
-//# sourceMappingURL=start-IITIEJTY.js.map
+//# sourceMappingURL=start-KR2JJR7K.js.map