akanjs 3.1.1 → 3.1.2-rc.0

package/server/imageOptimizer.ts

@@ -1,7 +1,9 @@
 import { createHash } from "node:crypto";
+import { lookup } from "node:dns/promises";
 import fs from "node:fs/promises";
+import { isIP } from "node:net";
 import path from "node:path";
-import { Logger } from "akanjs/common";
+import { Logger, TrustedProxy } from "akanjs/common";
 import { isAnimatedImage } from "./animatedImage";
 import { matchesIfNoneMatch } from "./contentEncoding";
 import { ImageOptimizerError } from "./imageOptimizerError";
@@ -13,6 +15,7 @@ import {
   type AkanImagePattern,
   getAkanImageWidths,
   mergeAkanImageConfig,
+  type ResolvedAkanImageConfig,
 } from "./types";
 
 export interface ImageOptimizerOptions {
@@ -20,6 +23,7 @@ export interface ImageOptimizerOptions {
   cacheDir: string;
   prodMode: boolean;
   config?: Partial<AkanImageConfig>;
+  resolveHost?: (hostname: string) => Promise<{ address: string }[]>;
 }
 
 interface ParsedImageRequest {
@@ -67,12 +71,17 @@ export class ImageOptimizer {
   #publicDir: string;
   #cacheDir: string;
   #prodMode: boolean;
-  #config: AkanImageConfig;
+  #config: ResolvedAkanImageConfig;
   #semaphore: Semaphore;
+  readonly #resolveHost: (hostname: string) => Promise<{ address: string }[]>;
+  readonly #encodeSlots: number;
+  #encoding = 0;
+  #cacheBytes: number | null = null;
+  #pruning: Promise<void> | null = null;
   readonly #inflight = new Map<string, Promise<OptimizedImage>>();
   #logger = new Logger("ImageOptimizer");
 
-  constructor({ publicDir, cacheDir, prodMode, config }: ImageOptimizerOptions) {
+  constructor({ publicDir, cacheDir, prodMode, config, resolveHost }: ImageOptimizerOptions) {
     this.#publicDir = publicDir;
     this.#cacheDir = cacheDir;
     this.#prodMode = prodMode;
@@ -83,7 +92,18 @@ export class ImageOptimizer {
       this.#logger.warn(`${dropped.join(", ")} needs an OS codec this platform does not have; serving webp instead`);
     }
     this.#config = { ...merged, formats: formats.length ? formats : ["image/webp"] };
-    this.#semaphore = new Semaphore(ImageOptimizer.#resolveConcurrency(this.#config.maxConcurrency));
+    const concurrency = ImageOptimizer.#resolveConcurrency(this.#config.maxConcurrency);
+    this.#semaphore = new Semaphore(concurrency);
+    this.#encodeSlots = this.#config.maxQueue > 0 ? concurrency + this.#config.maxQueue : Number.POSITIVE_INFINITY;
+    this.#resolveHost =
+      resolveHost ??
+      (async (hostname) =>
+        await Promise.race([
+          lookup(hostname, { all: true }),
+          new Promise<never>((_resolve, reject) =>
+            setTimeout(() => reject(new Error("DNS lookup timed out")), this.#config.fetchTimeoutMs).unref(),
+          ),
+        ]));
   }
 
   static #resolveConcurrency(configured: number): number {
@@ -105,7 +125,7 @@ export class ImageOptimizer {
     } catch (error) {
       const message = error instanceof ImageOptimizerError ? error.message : "Unable to optimize image";
       const status = error instanceof ImageOptimizerError ? error.status : 500;
-      return new Response(message, { status });
+      return new Response(message, { status, headers: status === 503 ? { "retry-after": "1" } : undefined });
     }
   }
 
@@ -145,9 +165,8 @@ export class ImageOptimizer {
       return null;
     }
     if (!pointer.file || pointer.expireAt <= Date.now()) return null;
-    const file = Bun.file(pointer.file);
-    if (!(await file.exists())) return null;
-    const buffer = Buffer.from(await file.arrayBuffer());
+    const buffer = await ImageOptimizer.#readCached(pointer.file);
+    if (!buffer) return null;
     return {
       buffer,
       contentType: pointer.contentType,
@@ -165,7 +184,7 @@ export class ImageOptimizer {
       maxAge: optimized.maxAge,
       expireAt: Date.now() + optimized.maxAge * 1000,
     };
-    await Bun.write(this.#getPointerPath(parsed), JSON.stringify(pointer));
+    await this.#writeCache(this.#getPointerPath(parsed), JSON.stringify(pointer));
   }
 
   #getPointerPath(parsed: ParsedImageRequest) {
@@ -191,7 +210,7 @@ export class ImageOptimizer {
     let href: string;
     let isRemote = false;
     if (url.startsWith("/")) {
-      href = url;
+      href = ImageOptimizer.#localHref(this.#config.localPatterns, url);
       const pathname = ImageOptimizer.#safeDecodePathname(url);
       if (!pathname) return { error: '"url" parameter is invalid' };
       if (pathname === ImageOptimizer.#optimizerPath || pathname.startsWith(`${ImageOptimizer.#optimizerPath}/`)) {
@@ -263,6 +282,7 @@ export class ImageOptimizer {
       if (!ImageOptimizer.#hasRemoteMatch(this.#config.remotePatterns, current)) {
         throw new ImageOptimizerError(400, '"url" parameter is not allowed');
       }
+      await this.#assertPublicHost(current);
       const controller = new AbortController();
       const timeout = setTimeout(() => controller.abort(), this.#config.fetchTimeoutMs);
       try {
@@ -277,7 +297,7 @@ export class ImageOptimizer {
           current = new URL(location, current);
           continue;
         }
-        if (!res.ok) throw new ImageOptimizerError(res.status, "Remote image request failed");
+        if (!res.ok) throw new ImageOptimizerError(502, "Remote image request failed");
         const buffer = await ImageOptimizer.#readResponseBuffer(res, this.#config.maxRemoteBytes);
         return {
           buffer,
@@ -293,6 +313,22 @@ export class ImageOptimizer {
     throw new ImageOptimizerError(400, "Remote image exceeded maximum redirects");
   }
 
+  async #assertPublicHost(url: URL) {
+    if (this.#config.dangerouslyAllowLocalIP) return;
+    const host = url.hostname.replace(/^\[|\]$/g, "");
+    let addresses: string[];
+    if (isIP(host)) addresses = [host];
+    else {
+      try {
+        addresses = (await this.#resolveHost(host)).map(({ address }) => address);
+      } catch {
+        throw new ImageOptimizerError(502, "Remote image request failed");
+      }
+    }
+    if (!addresses.length || addresses.some((address) => TrustedProxy.isPrivateAddress(address)))
+      throw new ImageOptimizerError(400, '"url" parameter is not allowed');
+  }
+
   async #getOptimizedImage(source: ImageSource, params: ParsedImageRequest): Promise<OptimizedImage> {
     const inputType = ImageOptimizer.#detectContentType(source.buffer) || source.contentType;
     if (!inputType.startsWith("image/") || inputType.includes(",")) {
@@ -320,13 +356,12 @@ export class ImageOptimizer {
       outputType,
       upstreamTag: source.upstreamTag,
     });
-    const cached = Bun.file(cachePath);
-    if (await cached.exists()) {
-      const buffer = Buffer.from(await cached.arrayBuffer());
+    const cached = await ImageOptimizer.#readCached(cachePath);
+    if (cached) {
       return {
-        buffer,
+        buffer: cached,
         contentType: outputType,
-        etag: ImageOptimizer.#hashBuffer(buffer),
+        etag: ImageOptimizer.#hashBuffer(cached),
         maxAge,
         cacheFile: cachePath,
       };
@@ -336,12 +371,15 @@ export class ImageOptimizer {
     let contentType = inputType;
     let cacheable = true;
     if (shouldEncode) {
+      if (this.#encoding >= this.#encodeSlots) throw new ImageOptimizerError(503, "Image optimizer is busy");
+      this.#encoding += 1;
       try {
         buffer = await this.#semaphore.run(() =>
           ImageOptimizer.#optimize(source.buffer, {
             width: params.width,
             quality: params.quality,
             contentType: outputType,
+            maxPixels: this.#config.maxInputPixels,
           }),
         );
         contentType = outputType;
@@ -349,13 +387,12 @@ export class ImageOptimizer {
         buffer = source.buffer;
         contentType = inputType;
         cacheable = false;
+      } finally {
+        this.#encoding -= 1;
       }
     }
 
-    if (cacheable) {
-      await fs.mkdir(this.#cacheDir, { recursive: true });
-      await Bun.write(cachePath, buffer);
-    }
+    if (cacheable) await this.#writeCache(cachePath, buffer);
     return {
       buffer,
       contentType,
@@ -365,6 +402,51 @@ export class ImageOptimizer {
     };
   }
 
+  static async #readCached(cachePath: string): Promise<Buffer | null> {
+    try {
+      const file = Bun.file(cachePath);
+      return (await file.exists()) ? Buffer.from(await file.arrayBuffer()) : null;
+    } catch {
+      return null;
+    }
+  }
+
+  async #writeCache(file: string, data: Buffer | string) {
+    await fs.mkdir(this.#cacheDir, { recursive: true });
+    this.#cacheBytes ??= (await this.#listCache()).reduce((total, entry) => total + entry.size, 0);
+    await Bun.write(file, data);
+    this.#cacheBytes += Buffer.byteLength(data);
+    const ceiling = this.#config.maxCacheBytes;
+    if (ceiling <= 0 || this.#cacheBytes <= ceiling) return;
+    this.#pruning ??= this.#pruneCache(ceiling).finally(() => {
+      this.#pruning = null;
+    });
+    await this.#pruning;
+  }
+
+  async #listCache(): Promise<{ file: string; size: number; mtimeMs: number }[]> {
+    const names = await fs.readdir(this.#cacheDir).catch(() => [] as string[]);
+    const entries = await Promise.all(
+      names.map(async (name) => {
+        const file = path.join(this.#cacheDir, name);
+        const stat = await fs.stat(file).catch(() => null);
+        return stat?.isFile() ? { file, size: stat.size, mtimeMs: stat.mtimeMs } : null;
+      }),
+    );
+    return entries.filter((entry) => entry !== null);
+  }
+
+  async #pruneCache(ceiling: number) {
+    const entries = (await this.#listCache()).sort((a, b) => a.mtimeMs - b.mtimeMs);
+    let total = entries.reduce((sum, entry) => sum + entry.size, 0);
+    for (const entry of entries) {
+      if (total <= ceiling * 0.8) break;
+      await fs.rm(entry.file, { force: true });
+      total -= entry.size;
+    }
+    this.#cacheBytes = total;
+  }
+
   #getCachePath(input: Record<string, string | number>) {
     const contentType = String(input.outputType);
     return path.join(
@@ -389,9 +471,11 @@ export class ImageOptimizer {
 
   static async #optimize(
     buffer: Buffer,
-    options: { width: number; quality: number; contentType: string },
+    options: { width: number; quality: number; contentType: string; maxPixels: number },
   ): Promise<Buffer> {
-    const image = new Bun.Image(buffer).resize(options.width, undefined, { withoutEnlargement: true });
+    const image = new Bun.Image(buffer, { maxPixels: options.maxPixels }).resize(options.width, undefined, {
+      withoutEnlargement: true,
+    });
 
     if (options.contentType === ImageOptimizer.#avif) return await image.avif({ quality: options.quality }).toBuffer();
     if (options.contentType === ImageOptimizer.#webp) return await image.webp({ quality: options.quality }).toBuffer();
@@ -411,6 +495,17 @@ export class ImageOptimizer {
     });
   }
 
+  static #localHref(patterns: Pick<AkanImagePattern, "pathname" | "search">[], href: string): string {
+    const url = new URL(href, "http://local.akan");
+    const namesQuery = patterns.some(
+      (pattern) =>
+        pattern.search !== undefined &&
+        pattern.search === url.search &&
+        (!pattern.pathname || ImageOptimizer.#globMatch(pattern.pathname, url.pathname)),
+    );
+    return namesQuery ? `${url.pathname}${url.search}` : url.pathname;
+  }
+
   static #hasLocalMatch(patterns: Pick<AkanImagePattern, "pathname" | "search">[], href: string): boolean {
     const url = new URL(href, "http://local.akan");
     return patterns.some((pattern) => {

package/server/lifecycle/buildEnv.ts

@@ -0,0 +1,11 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+
+export const BUILD_ENV_FILE = "akan.env.json";
+
+export const applyBuildEnv = (dir: string = path.dirname(Bun.main), env: NodeJS.ProcessEnv = process.env): void => {
+  const file = path.join(dir, BUILD_ENV_FILE);
+  if (!existsSync(file)) return;
+  const defaults = JSON.parse(readFileSync(file, "utf8")) as Record<string, string>;
+  for (const [key, value] of Object.entries(defaults)) env[key] ??= value;
+};

package/server/lifecycle/loadBuildEnv.ts

@@ -0,0 +1,3 @@
+import { applyBuildEnv } from "./buildEnv";
+
+applyBuildEnv();

package/server/logging/logControlSocket.ts

@@ -63,21 +63,27 @@ export class LogControlSocket {
 
     if (await LogControlSocket.#answers(this.path)) throw new Error("another server is listening on it");
     await rm(this.path, { force: true });
-    this.#server = Bun.listen<ClientState>({
-      unix: this.path,
-      socket: {
-        open: (socket) => {
-          socket.data = { inbox: "", pending: "", droppedWhilePending: 0, subscriptions: new Map() };
-        },
-        data: (socket, chunk) => this.#onData(socket, chunk),
-        drain: (socket) => this.#drain(socket),
-        close: (socket) => this.#release(socket),
-        error: (socket, error) => {
-          this.#logger.debug(`control socket client error: ${error.message}`);
-          this.#release(socket);
+    
+    const umask = process.platform === "win32" ? null : process.umask(0o177);
+    try {
+      this.#server = Bun.listen<ClientState>({
+        unix: this.path,
+        socket: {
+          open: (socket) => {
+            socket.data = { inbox: "", pending: "", droppedWhilePending: 0, subscriptions: new Map() };
+          },
+          data: (socket, chunk) => this.#onData(socket, chunk),
+          drain: (socket) => this.#drain(socket),
+          close: (socket) => this.#release(socket),
+          error: (socket, error) => {
+            this.#logger.debug(`control socket client error: ${error.message}`);
+            this.#release(socket);
+          },
         },
-      },
-    });
+      });
+    } finally {
+      if (umask !== null) process.umask(umask);
+    }
     await chmod(this.path, 0o600);
   }
 

package/server/logging/logStreamRoute.ts

@@ -1,5 +1,7 @@
 import { timingSafeEqual } from "node:crypto";
 import { bearerTokenOf, EventStream, Logger } from "akanjs/common";
+import { FailureLimiter } from "../ops/failureLimiter";
+import { StatusAccess } from "../ops/statusAccess";
 import type { LogHub, LogHubEntry } from "./logHub";
 import { LogQueryMatcher } from "./logQuery";
 import { LogStdoutWriter } from "./logStdoutWriter";
@@ -10,11 +12,12 @@ export class LogStreamRoute {
   static readonly heartbeatMs = 15_000;
 
   readonly #hub: () => LogHub | null;
-  readonly #token: Buffer;
+  readonly #digest: Buffer;
+  readonly #failures = new FailureLimiter({ limit: 10 });
 
   constructor(hub: () => LogHub | null, token: string) {
     this.#hub = hub;
-    this.#token = Buffer.from(token);
+    this.#digest = StatusAccess.digest(token);
   }
 
   /** Without a token the route is not registered at all, rather than mounted to answer "forbidden". */
@@ -31,8 +34,8 @@ export class LogStreamRoute {
     return new LogStreamRoute(hub, token);
   }
 
-  handle(req: Request): Response {
-    if (!this.#authorized(req))
+  handle(req: Request, client?: string | null): Response {
+    if (!this.#authorized(req, client))
       return new Response("Unauthorized", { status: 401, headers: { "www-authenticate": "Bearer" } });
     const hub = this.#hub();
     if (!hub) return new Response("Log hub is not running", { status: 503 });
@@ -53,11 +56,12 @@ export class LogStreamRoute {
     return stream.response();
   }
 
-  #authorized(req: Request): boolean {
+  #authorized(req: Request, client: string | null | undefined): boolean {
     const token = bearerTokenOf(req.headers.get("authorization"));
-    if (!token) return false;
-    const presented = Buffer.from(token);
-    return presented.length === this.#token.length && timingSafeEqual(presented, this.#token);
+    if (!token || this.#failures.blocked(client)) return false;
+    const matched = timingSafeEqual(StatusAccess.digest(token), this.#digest);
+    if (!matched) this.#failures.fail(client);
+    return matched;
   }
 
   static #resume(hub: LogHub, stream: EventStream, matcher: LogQueryMatcher, lastEventId: number) {

package/server/logging/rotatingLogWriter.ts

@@ -22,6 +22,7 @@ export interface RotatingLogWriterOptions {
   operationMode: string;
   maxSizeBytes?: number;
   maxFiles?: number;
+  fileMode?: number;
   now?: () => Date;
   warn?: (message: string) => void;
 }
@@ -29,11 +30,13 @@ export interface RotatingLogWriterOptions {
 export class RotatingLogWriter {
   static readonly defaultMaxSizeBytes = 50 * 1024 * 1024;
   static readonly defaultMaxFiles = 100;
+  static readonly defaultFileMode = 0o600;
 
   readonly #logDir: string;
   readonly #basePrefix: string;
   readonly #maxSizeBytes: number;
   readonly #maxFiles: number;
+  readonly #fileMode: number;
   readonly #now: () => Date;
   readonly #warn: (message: string) => void;
   readonly #states = new Map<string, RotatingLogWriterState>();
@@ -50,6 +53,7 @@ export class RotatingLogWriter {
     ].join("-");
     this.#maxSizeBytes = options.maxSizeBytes ?? RotatingLogWriter.defaultMaxSizeBytes;
     this.#maxFiles = options.maxFiles ?? RotatingLogWriter.defaultMaxFiles;
+    this.#fileMode = options.fileMode ?? RotatingLogWriter.defaultFileMode;
     this.#now = options.now ?? (() => new Date());
     this.#warn = options.warn ?? RotatingLogWriter.#defaultWarn;
   }
@@ -65,6 +69,7 @@ export class RotatingLogWriter {
         operationMode: env.operationMode,
         maxSizeBytes: RotatingLogWriter.#parseMaxSizeBytes(process.env.AKAN_LOG_MAX_SIZE_MB),
         maxFiles: RotatingLogWriter.#parseMaxFiles(process.env.AKAN_LOG_MAX_FILES),
+        fileMode: RotatingLogWriter.fileMode(),
       });
     } catch (error) {
       RotatingLogWriter.#defaultWarn(
@@ -109,7 +114,7 @@ export class RotatingLogWriter {
     }
 
     const filePath = this.#getFilePath(processKey, state.date, state.sequence);
-    await appendFile(filePath, chunk);
+    await appendFile(filePath, chunk, { mode: this.#fileMode });
     state.sizeBytes += byteLength;
     if (createdState) await this.#cleanupRetention(processKey);
   }
@@ -182,6 +187,15 @@ export class RotatingLogWriter {
     return parsed;
   }
 
+  static fileMode(value = process.env.AKAN_LOG_FILE_MODE, warn = RotatingLogWriter.#defaultWarn) {
+    const raw = value?.trim();
+    if (!raw) return RotatingLogWriter.defaultFileMode;
+    const parsed = /^[0-7]{3,4}$/.test(raw) ? Number.parseInt(raw, 8) : 0;
+    if (parsed > 0 && parsed <= 0o777) return parsed;
+    warn(`AKAN_LOG_FILE_MODE="${raw}" is not an octal mode such as 644; using 600`);
+    return RotatingLogWriter.defaultFileMode;
+  }
+
   static #defaultWarn(message: string) {
     process.stderr.write(`[AkanLog] ${message}\n`);
   }

package/server/machine/machineToken.ts

@@ -70,6 +70,10 @@ export class MachineToken {
     return !!MachineToken.#keyPair().publicKey;
   }
 
+  static publicKey(): KeyObject | null {
+    return MachineToken.#keyPair().publicKey;
+  }
+
   static issue(identity: MachineIdentity, { expiresAt, audience }: MachineTokenIssueOptions = {}): string {
     const { privateKey } = MachineToken.#keyPair();
     if (!privateKey) throw new Error("MachineToken.issue needs AKAN_MACHINE_PRIVATE_KEY on the server that issues it");

package/server/mcp/McpAuth.ts

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import type { PromiseOrObject } from "akanjs/base";
-import { bearerTokenOf, decodeJwtPayload } from "akanjs/common";
+import { AppHosts, bearerTokenOf, decodeJwtPayload, IpLiteral } from "akanjs/common";
 import { SignalContext } from "../../signal/signalContext";
 import type { HttpRoutes } from "../types";
 
@@ -90,7 +90,7 @@ export class McpAuth {
 
     if (this.#props.authorizationServers?.length && !audience.length)
       return { status: 401, error: "invalid_token", description: "The access token names no resource." };
-    if (audience.length && !audience.includes(this.#resource(req)))
+    if (audience.length && !(this.answersTo(req) && audience.includes(this.#resource(req))))
       return { status: 401, error: "invalid_token", description: "The access token was issued for another resource." };
     const missing = this.#missingScopes(claims);
     
@@ -149,6 +149,14 @@ export class McpAuth {
     return McpAuth.origin(req);
   }
 
+  answersTo(req: Request): boolean {
+    if (this.#props.resource) return true;
+    const host = URL.parse(McpAuth.origin(req))?.host;
+    const name = host ? AppHosts.nameOf(host) : null;
+    if (!host || !name) return false;
+    return !!IpLiteral.parse(host) || name === "localhost" || name.endsWith(".localhost") || AppHosts.allows(host);
+  }
+
   static origin(req: Request) {
     const url = new URL(req.url);
     const forwarded = (header: string) => req.headers.get(header)?.split(",")[0]?.trim();
@@ -156,10 +164,10 @@ export class McpAuth {
     return `${forwarded("x-forwarded-proto") ?? url.protocol.replace(":", "")}://${host}`;
   }
 
-  static callerKey(req: Request): string {
+  callerKey(req: Request): string {
     const token = McpAuth.#bearer(req);
     
-    if (!token) return `ip:${SignalContext.clientIpOf(req) ?? "anonymous"}`;
+    if (!token || !this.#props.verify) return `ip:${SignalContext.clientIpOf(req) ?? "anonymous"}`;
     const claims = McpAuth.#claims(token);
     const id = [claims?.sid, claims?.jti, claims?.sub].find((value) => typeof value === "string" && value);
     return typeof id === "string" ? `token:${id}` : `token:${createHash("sha256").update(token).digest("base64url")}`;

package/server/mcp/McpExecutionContext.ts

@@ -19,6 +19,10 @@ export class McpExecutionContext extends HttpExecutionContext {
     this.#arguments = args;
   }
 
+  override defersBody(): boolean {
+    return false;
+  }
+
   override async readArgs(endpointInfo: EndpointInfo): Promise<unknown[]> {
     const declared = new Set(endpointInfo.args.filter(McpExecutionContext.#describable).map((arg) => arg.name));
     const undeclared = Object.keys(this.#arguments).find((name) => !declared.has(name));

package/server/mcp/McpRouter.ts

@@ -68,6 +68,7 @@ interface McpCall {
   era: McpEra;
   req: Request;
   ui: boolean;
+  inProcess?: boolean;
 }
 
 interface McpErrorOptions {
@@ -322,19 +323,19 @@ export class McpRouter {
           discoverCache,
         );
       case "tools/list":
-        return await this.#list(call, "tools", [
+        return await this.#list(call, "tools", async () => [
           ...document.tools,
           ...(await this.#pages.tools(call.ui, document, call.req)),
         ]);
       case "resources/list":
-        return await this.#list(call, "resources", [
+        return await this.#list(call, "resources", async () => [
           ...document.resources,
           ...(await this.#pages.resources(call.ui, call.req)),
         ]);
       case "resources/templates/list":
-        return await this.#list(call, "resourceTemplates", document.resourceTemplates);
+        return await this.#list(call, "resourceTemplates", () => document.resourceTemplates);
       case "prompts/list":
-        return await this.#list(call, "prompts", await this.#pages.prompts(call.req));
+        return await this.#list(call, "prompts", () => this.#pages.prompts(call.req));
       case "tools/call": {
         const slot = await this.#acquire(call);
         if ("refused" in slot) return slot.refused;
@@ -361,12 +362,15 @@ export class McpRouter {
     }
   }
 
-  async #list<T extends { name: string }>(call: McpCall, key: string, items: T[]) {
-    const visible = await this.#dispatcher.filterForAccount(items, call.req);
-    const page = McpRouter.#page(visible, call.params.cursor, this.#props.pageSize ?? defaultPageSize);
-    if (!page) return McpRouter.#error(call.id, McpErrorCode.invalidParams, "Invalid cursor.");
-    const result = { [key]: page.items, ...(page.nextCursor ? { nextCursor: page.nextCursor } : {}) };
-    return this.#result(call, result, listCache);
+  async #list<T extends { name: string }>(call: McpCall, key: string, itemsOf: () => Promise<T[]> | T[]) {
+    const list = async () => {
+      const visible = await this.#dispatcher.filterForAccount(await itemsOf(), call.req);
+      const page = McpRouter.#page(visible, call.params.cursor, this.#props.pageSize ?? defaultPageSize);
+      if (!page) return McpRouter.#error(call.id, McpErrorCode.invalidParams, "Invalid cursor.");
+      const result = { [key]: page.items, ...(page.nextCursor ? { nextCursor: page.nextCursor } : {}) };
+      return this.#result(call, result, listCache);
+    };
+    return call.inProcess ? await list() : await this.#limited(call, list);
   }
 
   /** The catalogue as built, before any caller filter: refusals, undescribed entries, `findTool`. */
@@ -394,7 +398,15 @@ export class McpRouter {
     const items: unknown[] = [];
     let cursor: string | undefined;
     do {
-      const call: McpCall = { id: 0, method, params: cursor ? { cursor } : {}, era: "legacy", req, ui };
+      const call: McpCall = {
+        id: 0,
+        method,
+        params: cursor ? { cursor } : {},
+        era: "legacy",
+        req,
+        ui,
+        inProcess: true,
+      };
       const body = (await (await this.#dispatch(call)).json()) as McpJsonRpcResponse;
       const result = body.result as Record<string, unknown> | undefined;
       if (!result) throw new Error(`MCP ${method} failed: ${body.error?.message ?? "no result"}`);
@@ -416,7 +428,7 @@ export class McpRouter {
 
   async #acquire(call: McpCall): Promise<{ refused: Response } | { release: () => void }> {
     if (!this.#limiter) return { release: () => {} };
-    const verdict = await this.#limiter.acquire(McpAuth.callerKey(call.req));
+    const verdict = await this.#limiter.acquire(this.#auth.callerKey(call.req));
     if (verdict.ok) return { release: verdict.release };
     const seconds = Math.max(1, Math.ceil(verdict.retryAfterMs / 1000));
     const message =
@@ -577,7 +589,7 @@ export class McpRouter {
     if ((this.#props.allowedOrigins ?? []).includes(origin)) return true;
     try {
       
-      return new URL(origin).host === new URL(this.#auth.publicOrigin(req)).host;
+      return new URL(origin).host === new URL(this.#auth.publicOrigin(req)).host && this.#auth.answersTo(req);
     } catch {
       return false;
     }

package/server/mcp/PagePromptComposer.ts

@@ -1,5 +1,5 @@
 import { PrimitiveRegistry } from "akanjs/base";
-import { Logger } from "akanjs/common";
+import { Logger, sliceNames } from "akanjs/common";
 import { agentRead, ConstantRegistry, type ConstantType, type MaskModel } from "akanjs/constant";
 import type { McpDocument } from "../../signal/mcp/McpDocument";
 import { Msg, type PromptMessage } from "../../signal/mcp/Msg";
@@ -151,14 +151,11 @@ export class PagePromptComposer {
     const refName = argName.replace(/Id$/, "");
     if (!refName || refName === argName) return undefined;
     const document = this.#props.document;
+    const rootList = sliceNames(refName).endpoint.list;
     const listTools = document.tools
       .map((tool) => tool.name)
-      .filter((name) => document.findTool(name)?.refName === refName && name.startsWith(`${refName}List`));
-    return (
-      listTools.find((name) => /Search/.test(name)) ??
-      listTools.find((name) => name === `${refName}List`) ??
-      listTools[0]
-    );
+      .filter((name) => document.findTool(name)?.refName === refName && name.startsWith(rootList));
+    return listTools.find((name) => /Search/.test(name)) ?? listTools.find((name) => name === rootList) ?? listTools[0];
   }
 
   static #resource(attachment: Attachment): PromptMessage {