@nifrajs/cli 3.3.0 → 4.0.0

package/src/mcp-run.ts

@@ -8,9 +8,25 @@
 import { existsSync, realpathSync } from "node:fs"
 import { isAbsolute, relative, resolve, sep } from "node:path"
 import { pathToFileURL } from "node:url"
-import { type AppLike, runApp } from "@nifrajs/runner"
+import { type AppLike, type RequestSpec, type RunResult, runApp } from "@nifrajs/runner"
+import {
+  captureInto,
+  createDevFeed,
+  type DevFeed,
+  type DevLogLevel,
+  runWithDevRequest,
+} from "@nifrajs/web/dev-feed"
+import type { Diagnostic } from "@nifrajs/web/diagnostic"
+import { BACKEND_APP_FILE } from "./app-files.ts"
+import {
+  CHILD_INPUT_MAX_BYTES,
+  CHILD_OUTPUT_MAX_BYTES,
+  readBoundedLines,
+  readBoundedStream,
+  serializeBoundedJson,
+} from "./mcp-io.ts"
 
-const ENTRY_CANDIDATES = ["backend.ts", "app.ts", "src/backend.ts", "src/app.ts"]
+const ENTRY_CANDIDATES = [BACKEND_APP_FILE, "app.ts", "src/app.ts"]
 
 const errString = (err: unknown): string =>
   err instanceof Error ? `${err.name}: ${err.message}` : String(err)
@@ -78,12 +94,75 @@ export async function runBackend(
   if ("error" in loaded) return loaded
 
   try {
-    return { results: await runApp(loaded.app, requests as Parameters<typeof runApp>[1]) }
+    return { results: await runCaptured(cwd, loaded.app, requests) }
   } catch (err) {
     return { error: errString(err) }
   }
 }
 
+/** What `nifra_run` adds to the runner's result: what the app printed, and what failed, structured. */
+export interface RunCapture {
+  readonly logs?: ReadonlyArray<{ readonly level: DevLogLevel; readonly message: string }>
+  readonly errors?: readonly Diagnostic[]
+}
+
+const MAX_LOGS_PER_REQUEST = 100
+
+/**
+ * Run `requests` one at a time, each inside its own request context, so what a handler logs - and
+ * core's `unhandled request error` line behind a bare 500 - lands on the result of the request that
+ * produced it, redacted, with the error as a Diagnostic (codeframe, cause, fix). Without this a 500 came
+ * back as `internal_error` and the reason only ever reached a stderr nobody reads.
+ */
+export async function runCaptured(
+  cwd: string,
+  app: AppLike,
+  requests: readonly unknown[],
+): Promise<Array<RunResult & RunCapture>> {
+  const feed = createDevFeed({ root: cwd, persist: false })
+  const detach = captureInto(feed)
+  const runs: Array<{ readonly requestId: string; readonly result: RunResult }> = []
+  try {
+    for (const [index, spec] of requests.entries()) {
+      const requestId = `run${index + 1}`
+      const [method, path] = describeSpec(spec)
+      const [result] = await runWithDevRequest(
+        { feedId: feed.id, requestId, method, path },
+        // biome-ignore lint/plugin/requireSafetyCommentForTypeAssertion: runApp validates each spec itself and reports a malformed one as that request's error.
+        () => runApp(app, [spec as RequestSpec]),
+      )
+      if (result !== undefined) runs.push({ requestId, result })
+    }
+    // A line a handler scheduled for later (a promise continuation, a 0 ms timer) still lands.
+    await new Promise((resolve) => setTimeout(resolve, 0))
+  } finally {
+    detach()
+  }
+  return runs.map(({ requestId, result }) => withCapture(feed, requestId, result))
+}
+
+function describeSpec(spec: unknown): [string, string] {
+  if (typeof spec !== "object" || spec === null) return ["GET", "/"]
+  const method = "method" in spec && typeof spec.method === "string" ? spec.method : "GET"
+  const path = "path" in spec && typeof spec.path === "string" ? spec.path : "/"
+  return [method, path]
+}
+
+function withCapture(feed: DevFeed, requestId: string, result: RunResult): RunResult & RunCapture {
+  if (result.error !== undefined) {
+    const thrown = new Error(result.error.message)
+    thrown.name = result.error.name
+    if (result.error.stack !== undefined) thrown.stack = result.error.stack
+    feed.recordError(thrown, { category: "api", requestId })
+  }
+  const capture: { -readonly [K in keyof RunCapture]: RunCapture[K] } = {}
+  const logs = feed.logs({ requestId, limit: MAX_LOGS_PER_REQUEST }).logs
+  if (logs.length > 0) capture.logs = logs.map(({ level, message }) => ({ level, message }))
+  const errors = feed.errors({ requestId }).errors
+  if (errors.length > 0) capture.errors = errors.map((entry) => entry.diagnostic)
+  return { ...result, ...capture }
+}
+
 interface WorkerMessage {
   readonly id?: unknown
   readonly input?: { readonly requests?: unknown; readonly entry?: string }
@@ -100,54 +179,95 @@ function redirectConsoleToStderr(): void {
   console.error = (...args: unknown[]) => write("error", args)
 }
 
-async function runWorker(cwd: string): Promise<void> {
+function safeResponseId(value: unknown): number | string | null {
+  if (typeof value === "number" && Number.isSafeInteger(value)) return value
+  if (typeof value === "string" && value.length <= 128) return value
+  return null
+}
+
+/**
+ * Keep stdout for the protocol. The app's console and any direct `process.stdout.write` go to stderr,
+ * or a stray `console.log` in a handler would corrupt the JSON the parent reads. Returns the writer
+ * that still reaches the real stdout.
+ */
+function reserveStdout(): (text: string) => void {
   redirectConsoleToStderr()
+  const original: unknown = Reflect.get(process.stdout, "write")
+  const write = typeof original === "function" ? original.bind(process.stdout) : undefined
+  // Bound now, before any capture patches stderr: a redirected stdout line is captured once, as stdout.
+  const toStderr = process.stderr.write.bind(process.stderr)
+  Reflect.set(process.stdout, "write", (chunk: unknown, ...rest: unknown[]) =>
+    Reflect.apply(toStderr, process.stderr, [chunk, ...rest]),
+  )
+  return (text) => {
+    write?.(text)
+  }
+}
+
+async function runWorker(cwd: string, protocol: (text: string) => void): Promise<void> {
   const apps = new Map<string, Promise<{ app: AppLike } | { error: string }>>()
-  const decoder = new TextDecoder()
-  let buffer = ""
   const send = (id: unknown, output: unknown): void => {
-    process.stdout.write(`${JSON.stringify({ id, output })}\n`)
+    const responseId = safeResponseId(id)
+    const encoded = serializeBoundedJson({ id: responseId, output }, CHILD_OUTPUT_MAX_BYTES - 1)
+    protocol(
+      `${encoded ?? JSON.stringify({ id: responseId, output: { error: "worker output exceeded the size limit" } })}\n`,
+    )
   }
-  for await (const chunk of Bun.stdin.stream()) {
-    buffer += decoder.decode(chunk as Uint8Array, { stream: true })
-    let nl = buffer.indexOf("\n")
-    while (nl !== -1) {
-      const line = buffer.slice(0, nl).trim()
-      buffer = buffer.slice(nl + 1)
-      nl = buffer.indexOf("\n")
-      if (line === "") continue
-
-      let message: WorkerMessage
-      try {
-        message = JSON.parse(line) as WorkerMessage
-      } catch {
-        send(null, { error: "invalid worker input: expected JSON line" })
-        continue
-      }
-      const requests = message.input?.requests
-      const entry = message.input?.entry
-      if (!Array.isArray(requests)) {
-        send(message.id, { error: "expected { requests: [...] }" })
-        continue
-      }
-      const key = entry ?? ""
-      let loaded = apps.get(key)
-      if (loaded === undefined) {
-        loaded = loadBackend(cwd, entry)
-        apps.set(key, loaded)
-      }
-      const app = await loaded
-      if ("error" in app) {
-        send(message.id, app)
-        continue
-      }
-      try {
-        send(message.id, {
-          results: await runApp(app.app, requests as Parameters<typeof runApp>[1]),
-        })
-      } catch (err) {
-        send(message.id, { error: errString(err) })
-      }
+  for await (const item of readBoundedLines(Bun.stdin.stream(), CHILD_INPUT_MAX_BYTES)) {
+    if (item.kind === "too-large") {
+      send(null, { error: `worker input exceeded ${CHILD_INPUT_MAX_BYTES} bytes` })
+      continue
+    }
+    const line = item.text.trim()
+    if (line === "") continue
+
+    let message: unknown
+    try {
+      message = JSON.parse(line) as unknown
+    } catch {
+      send(null, { error: "invalid worker input: expected JSON line" })
+      continue
+    }
+    const record =
+      message !== null && typeof message === "object" && !Array.isArray(message)
+        ? (message as WorkerMessage)
+        : undefined
+    const input =
+      record?.input !== null && typeof record?.input === "object" && !Array.isArray(record.input)
+        ? record.input
+        : undefined
+    const id = record?.id
+    const requests = input?.requests
+    const entry = input?.entry
+    if (!Array.isArray(requests)) {
+      send(id, { error: "expected { requests: [...] }" })
+      continue
+    }
+    if (entry !== undefined && typeof entry !== "string") {
+      send(id, { error: "entry must be a string" })
+      continue
+    }
+    const key = entry ?? ""
+    let loaded = apps.get(key)
+    if (loaded === undefined) {
+      loaded = loadBackend(cwd, entry)
+      apps.set(key, loaded)
+    }
+    let app: Awaited<typeof loaded>
+    try {
+      app = await loaded
+    } catch (err) {
+      send(id, { error: errString(err) })
+      continue
+    }
+    if ("error" in app) {
+      send(id, app)
+      continue
+    }
+    try {
+      send(id, { results: await runCaptured(cwd, app.app, requests) })
+    } catch (err) {
+      send(id, { error: errString(err) })
     }
   }
 }
@@ -156,19 +276,33 @@ async function runWorker(cwd: string): Promise<void> {
 // this only executes when run directly (not when imported by a test).
 if (import.meta.main) {
   const cwd = process.argv[2] ?? process.cwd()
+  const protocol = reserveStdout()
   if (process.argv.includes("--worker")) {
-    await runWorker(cwd)
+    await runWorker(cwd, protocol)
     process.exit(0)
   }
   let output: unknown
-  try {
-    const { requests, entry } = JSON.parse(await Bun.stdin.text()) as {
-      requests: unknown
-      entry?: string
+  const input = await readBoundedStream(Bun.stdin.stream(), CHILD_INPUT_MAX_BYTES)
+  if (input.truncated) {
+    output = { error: `input exceeded ${CHILD_INPUT_MAX_BYTES} bytes` }
+  } else {
+    try {
+      const { requests, entry } = JSON.parse(input.text) as {
+        requests: unknown
+        entry?: string
+      }
+      output = await runBackend(cwd, requests, entry)
+    } catch {
+      output = { error: "invalid input: expected JSON { requests: [...] }" }
     }
-    output = await runBackend(cwd, requests, entry)
-  } catch {
-    output = { error: "invalid input: expected JSON { requests: [...] }" }
   }
-  process.stdout.write(JSON.stringify(output, null, 2))
+  // `Bun.write` to the fd, not the patched `process.stdout.write`, so the answer is flushed when it
+  // resolves. Then exit: the app's own handles (a pool, an interval) would keep this single-use
+  // process alive until the parent's timeout, and the parent waits for it to exit.
+  await Bun.write(
+    Bun.stdout,
+    serializeBoundedJson(output, CHILD_OUTPUT_MAX_BYTES, 2) ??
+      JSON.stringify({ error: `output exceeded ${CHILD_OUTPUT_MAX_BYTES} bytes` }),
+  )
+  process.exit(0)
 }

package/src/mcp-ws.ts

@@ -324,5 +324,8 @@ if (import.meta.main) {
       error: 'invalid input: expected JSON { "path": "/..." }',
     } satisfies WebSocketVerificationResult
   }
-  process.stdout.write(JSON.stringify(output, null, 2))
+  // Flushed, then exit: the app's own handles would keep this single-use process alive until the
+  // parent's timeout, as in mcp-run and mcp-render.
+  await Bun.write(Bun.stdout, JSON.stringify(output, null, 2))
+  process.exit(0)
 }