mothership: the embedded CLI answers v2 in-process; grep memoizes both platform catalogs

The embedded CLI and the agent-cli engines were typed v2 clients pointed at the
server's own URL: every tool call was a network round trip through the proxy,
API-key auth, the abuse rate limits, and the proxy body ceiling. A grep over one
block definition cost 8-34s and tripped the per-key limit (dev 2026-09-03).

- sim-cli: ResolvedProfile / EmbeddedCliIdentity take an optional transport; the
  client sends through it instead of fetch. The installed CLI never sets it.
- sim: an in-process transport resolves a v2 path against a generated route table
  (scripts/generate-v2-route-table.ts, check:v2-route-table in check:audits) and
  invokes the route handler directly. The request is marked internal through a
  WeakSet — not a header — so admission still authenticates it but skips the
  pre-auth IP bucket and the per-key rate limits, which exist for callers on the
  wire. Contracts, use cases, presenters, and error envelopes are the ones the
  network path runs. Anything outside the v2 table falls through to fetch.
- grep engine: blocks and tools (5,000 built-ins at 100 a page) are memoized per
  workspace; an exact block or tool id (--in file_v5) resolves from that corpus
  without listing any workspace world; name fragments still index every world
  and fetch only the matches.

Author: Sg312

apps/sim/lib/api/server/routes/in-process-transport.test.ts

@@ -0,0 +1,82 @@
+/**
+ * @vitest-environment node
+ */
+import { NextResponse } from 'next/server'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+const { handlers } = vi.hoisted(() => ({
+  handlers: {
+    listBlocks: vi.fn(),
+    getBlock: vi.fn(),
+    latestVersion: vi.fn(),
+  },
+}))
+
+vi.mock('@/lib/api/server/routes/v2-route-table.generated', () => ({
+  V2_ROUTES: [
+    { pattern: '/api/v2/blocks', load: async () => ({ GET: handlers.listBlocks }) },
+    { pattern: '/api/v2/blocks/{blockId}', load: async () => ({ GET: handlers.getBlock }) },
+    {
+      pattern: '/api/v2/blocks/latest',
+      load: async () => ({ GET: handlers.latestVersion }),
+    },
+  ],
+}))
+
+import {
+  createInProcessTransport,
+  matchV2Route,
+} from '@/lib/api/server/routes/in-process-transport'
+import { isInternalRequest } from '@/lib/api/server/routes/internal-request'
+
+describe('in-process transport', () => {
+  afterEach(() => {
+    vi.restoreAllMocks()
+    vi.clearAllMocks()
+  })
+
+  it('prefers the more literal pattern and decodes dynamic segments', async () => {
+    expect(matchV2Route('/api/v2/blocks/latest')?.params).toEqual({})
+    const dynamic = matchV2Route('/api/v2/blocks/slack%20v2')
+    expect(dynamic?.params).toEqual({ blockId: 'slack v2' })
+    expect(matchV2Route('/api/v2/nowhere')).toBeNull()
+  })
+
+  it('dispatches a v2 request to its route handler in-process, marked internal', async () => {
+    handlers.getBlock.mockImplementation(
+      async (request: Request, context: { params: Promise<Record<string, string>> }) =>
+        NextResponse.json({
+          internal: isInternalRequest(request),
+          key: request.headers.get('x-api-key'),
+          query: new URL(request.url).searchParams.get('workspaceId'),
+          params: await context.params,
+        })
+    )
+    const transport = createInProcessTransport()
+
+    const response = await transport('http://internal/api/v2/blocks/agent?workspaceId=ws-1', {
+      method: 'GET',
+      headers: { 'x-api-key': 'secret' },
+    })
+
+    expect(response.status).toBe(200)
+    expect(await response.json()).toEqual({
+      internal: true,
+      key: 'secret',
+      query: 'ws-1',
+      params: { blockId: 'agent' },
+    })
+    expect(handlers.listBlocks).not.toHaveBeenCalled()
+  })
+
+  it('falls through to fetch for anything outside the v2 table', async () => {
+    const network = vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response('elsewhere'))
+    const transport = createInProcessTransport()
+
+    const response = await transport('http://internal/api/files/serve/abc', { method: 'GET' })
+
+    expect(await response.text()).toBe('elsewhere')
+    expect(network).toHaveBeenCalledTimes(1)
+    expect(handlers.getBlock).not.toHaveBeenCalled()
+  })
+})

apps/sim/lib/api/server/routes/in-process-transport.ts

@@ -0,0 +1,96 @@
+import { NextRequest } from 'next/server'
+import { markInternalRequest } from '@/lib/api/server/routes/internal-request'
+import { V2_ROUTES } from '@/lib/api/server/routes/v2-route-table.generated'
+
+/**
+ * A `fetch` that answers the server's own v2 requests in-process.
+ *
+ * The embedded CLI and the agent-cli engines are typed v2 clients. Pointing them at
+ * the server's URL made every tool call a network round trip through the proxy,
+ * API-key authentication, the abuse rate limits, and the proxy body ceiling — a
+ * grep over one block definition cost seconds and tripped the per-key limit. This
+ * transport resolves the request's path against the generated route table and
+ * invokes the route handler directly, with the request marked internal so
+ * admission authenticates it but does not rate-limit it. Contracts, use cases,
+ * presenters, and error envelopes are untouched: the handler that runs is the one
+ * the network path would run.
+ *
+ * Anything outside the v2 table falls through to real `fetch`.
+ */
+
+type RouteHandler = (
+  request: NextRequest,
+  context: { params: Promise<Record<string, string>> }
+) => Promise<Response>
+
+interface CompiledRoute {
+  regex: RegExp
+  params: string[]
+  /** Literal segments — a more specific pattern wins over a parameterized one. */
+  literals: number
+  load: () => Promise<object>
+}
+
+interface MatchedRoute {
+  params: Record<string, string>
+  literals: number
+  load: () => Promise<object>
+}
+
+const COMPILED: CompiledRoute[] = V2_ROUTES.map((route) => {
+  const params: string[] = []
+  let literals = 0
+  const source = route.pattern
+    .split('/')
+    .map((segment) => {
+      const param = /^\{(.+)\}$/.exec(segment)
+      if (!param?.[1]) {
+        literals += 1
+        return segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+      }
+      params.push(param[1])
+      return '([^/]+)'
+    })
+    .join('/')
+  return { regex: new RegExp(`^${source}$`), params, literals, load: route.load }
+})
+
+export function matchV2Route(pathname: string): MatchedRoute | null {
+  let best: MatchedRoute | null = null
+  for (const route of COMPILED) {
+    const match = route.regex.exec(pathname)
+    if (!match) continue
+    if (best && best.literals >= route.literals) continue
+    const params: Record<string, string> = {}
+    route.params.forEach((name, index) => {
+      params[name] = decodeURIComponent(match[index + 1] ?? '')
+    })
+    best = { params, literals: route.literals, load: route.load }
+  }
+  return best
+}
+
+function requestUrl(input: RequestInfo | URL): URL {
+  if (typeof input === 'string') return new URL(input)
+  if (input instanceof URL) return input
+  return new URL(input.url)
+}
+
+export function createInProcessTransport(): typeof fetch {
+  return async (input, init) => {
+    const url = requestUrl(input)
+    const method = (init?.method ?? 'GET').toUpperCase()
+    const matched = url.pathname.startsWith('/api/v2/') ? matchV2Route(url.pathname) : null
+    if (!matched) return fetch(input, init)
+    const handler = Reflect.get(await matched.load(), method)
+    if (typeof handler !== 'function') return fetch(input, init)
+    const request = new NextRequest(url, {
+      method,
+      headers: init?.headers,
+      body: init?.body ?? null,
+      signal: init?.signal ?? undefined,
+    })
+    markInternalRequest(request)
+    return (handler as RouteHandler)(request, { params: Promise.resolve(matched.params) })
+  }
+}

apps/sim/lib/api/server/routes/internal-request.ts

@@ -0,0 +1,22 @@
+/**
+ * Requests the server makes to itself.
+ *
+ * The embedded CLI and the agent-cli engines dispatch to the v2 route handlers
+ * in-process (see `in-process-transport.ts`). Those requests are marked here so
+ * admission can skip the abuse controls that exist for callers arriving over the
+ * network: the pre-auth IP bucket and the per-key rate limits. Authentication is
+ * not skipped — an internal request still carries the caller's key and resolves
+ * to the same principal the network path would.
+ *
+ * A WeakSet keyed by the Request object, not a header: any client on the wire
+ * can set a header; nothing outside this process can reach the set.
+ */
+const INTERNAL_REQUESTS = new WeakSet<Request>()
+
+export function markInternalRequest(request: Request): void {
+  INTERNAL_REQUESTS.add(request)
+}
+
+export function isInternalRequest(request: Request): boolean {
+  return INTERNAL_REQUESTS.has(request)
+}

apps/sim/lib/api/server/routes/v2-json-route.test.ts

@@ -28,6 +28,7 @@ class TestLockedError extends HttpError {
 vi.mock('@/lib/api/server/routes/v2-api-key-auth', () => v2ApiKeyAuthModuleMock)
 vi.mock('@/lib/core/rate-limiter', () => v2RateLimiterModuleMock)
 
+import { markInternalRequest } from '@/lib/api/server/routes/internal-request'
 import type { V2ApiKeyAuthContext } from '@/lib/api/server/routes/v2-api-key-auth'
 import {
   defineV2JsonRoute,
@@ -204,6 +205,21 @@ describe('defineV2JsonRoute', () => {
     expect(response.headers.get('Cache-Control')).toBe('private, no-store')
   })
 
+  it('authenticates but never rate-limits a request the server marked as its own', async () => {
+    // The embedded CLI and the agent-cli engines dispatch to these handlers in-process;
+    // the IP bucket and the per-key limits exist for callers on the wire, and a chat
+    // turn's tool calls all land on one key (dev 2026-09-03: grep hit the limit).
+    const internal = request()
+    markInternalRequest(internal)
+
+    const response = await createHandler()(internal)
+
+    expect(response.status).toBe(201)
+    expect(v2RouteMocks.authenticate).toHaveBeenCalledTimes(1)
+    expect(v2RouteMocks.preauthRate).not.toHaveBeenCalled()
+    expect(v2RouteMocks.operationRate).not.toHaveBeenCalled()
+  })
+
   it('fails closed before authentication when the IP bucket cannot admit the request', async () => {
     v2RouteMocks.preauthRate.mockResolvedValueOnce({
       allowed: false,

apps/sim/lib/api/server/routes/v2-json-route.ts

@@ -5,6 +5,7 @@ import {
   methodMatchesContract,
   requireJsonRouteDefinition,
 } from '@/lib/api/server/routes/definition'
+import { isInternalRequest } from '@/lib/api/server/routes/internal-request'
 import type {
   JsonApiRouteContract,
   JsonNextRouteHandler,
@@ -318,7 +319,12 @@ async function admitAuthenticatedV2Request(
     throw new V2RouteInfrastructureError('authentication', error)
   }
 
-  const limited = await rateLimitPolicy.enforce(request, auth, operation)
+  // The server's own requests (embedded CLI, agent-cli engines) are authenticated like
+  // any other but never rate limited: the buckets exist for callers on the wire, and a
+  // chat turn's tool calls all land on one key. See `internal-request.ts`.
+  const limited = isInternalRequest(request)
+    ? null
+    : await rateLimitPolicy.enforce(request, auth, operation)
   return limited ? { success: false, response: limited } : { success: true, auth }
 }
 
@@ -330,7 +336,7 @@ async function admitRateLimitedV2Request(
 ): Promise<
   { success: true; auth: V2ApiKeyAuthContext } | { success: false; response: NextResponse }
 > {
-  const preAuthResponse = await enforceV2PreAuthIpLimit(request)
+  const preAuthResponse = isInternalRequest(request) ? null : await enforceV2PreAuthIpLimit(request)
   if (preAuthResponse) return { success: false, response: preAuthResponse }
   return admitAuthenticatedV2Request(request, operation, authPolicy, rateLimitPolicy)
 }
@@ -355,7 +361,7 @@ export async function admitOptionalV2Request(
 ): Promise<
   { success: true; auth?: V2ApiKeyAuthContext } | { success: false; response: NextResponse }
 > {
-  const preAuthResponse = await enforceV2PreAuthIpLimit(request)
+  const preAuthResponse = isInternalRequest(request) ? null : await enforceV2PreAuthIpLimit(request)
   if (preAuthResponse) return { success: false, response: preAuthResponse }
   if (!request.headers.has('x-api-key')) return { success: true }
   return admitAuthenticatedV2Request(request, operation, authPolicy, rateLimitPolicy)