agent-yes 1.95.0 → 1.97.0

package/dist/{ts-BvWaEGsr.js → ts-BAc4Jcrw.js}

@@ -1,7 +1,7 @@
 import { n as logger, t as addTransport } from "./logger-B9h0djqx.js";
-import { r as getInstalledPackage } from "./versionChecker-DfIPG9ui.js";
-import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-C22d9SRJ.js";
-import { t as PidStore } from "./pidStore-DTzl6zeh.js";
+import { r as getInstalledPackage } from "./versionChecker-MNvA73o9.js";
+import { n as agentYesHome, t as PidStore } from "./pidStore-DBjlqzo8.js";
+import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-CJxsoGdb.js";
 import { i as readGlobalPids } from "./globalPidIndex-yVd3mbsV.js";
 import { arch, platform } from "process";
 import { execSync } from "child_process";
@@ -1423,10 +1423,19 @@ async function agentYes({ cli, cliArgs = [], prompt, robust = true, cwd, env, ex
 		notifyWebhook("EXIT", `${exitReason} exitCode=${exitCode ?? "?"}`, workingDir).catch(() => null);
 		return pendingExitCode.resolve(exitCode);
 	});
+	const writeCurrentPtysize = (cols, rows) => {
+		const dir = path.join(agentYesHome(), "ptysize");
+		mkdir(dir, { recursive: true }).then(() => writeFile(path.join(dir, String(process.pid)), `${cols} ${rows}\n`)).catch(() => null);
+	};
+	{
+		const { cols, rows } = getTerminalDimensions();
+		writeCurrentPtysize(cols, rows);
+	}
 	process.stdout.on("resize", () => {
 		const { cols, rows } = getTerminalDimensions();
 		shell.resize(cols, rows);
 		xtermProxy.resize(cols, rows);
+		writeCurrentPtysize(cols, rows);
 	});
 	const isStillWorkingQ = () => {
 		const rendered = xtermProxy.tail(24).replace(/\s+/g, " ");
@@ -1705,4 +1714,4 @@ function sleep(ms) {
 
 //#endregion
 export { removeControlCharacters as a, AgentContext as i, agentYes as n, config as r, CLIS_CONFIG as t };
-//# sourceMappingURL=ts-BvWaEGsr.js.map
+//# sourceMappingURL=ts-BAc4Jcrw.js.map

package/dist/{versionChecker-DfIPG9ui.js → versionChecker-MNvA73o9.js}

@@ -7,7 +7,7 @@ import { fileURLToPath } from "url";
 
 //#region package.json
 var name = "agent-yes";
-var version = "1.95.0";
+var version = "1.97.0";
 
 //#endregion
 //#region ts/versionChecker.ts
@@ -221,4 +221,4 @@ async function displayVersion() {
 
 //#endregion
 export { versionString as i, displayVersion as n, getInstalledPackage as r, checkAndAutoUpdate as t };
-//# sourceMappingURL=versionChecker-DfIPG9ui.js.map
+//# sourceMappingURL=versionChecker-MNvA73o9.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.95.0",
+  "version": "1.97.0",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",
@@ -69,6 +69,7 @@
   },
   "scripts": {
     "build": "tsdown",
+    "cf": "bun scripts/cf.ts",
     "build:rs": "cargo install --path rs --features swarm",
     "postbuild": "bun ./ts/postbuild.ts",
     "demo": "bun run build && bun link && claude-yes -- demo",
@@ -92,6 +93,7 @@
     "execa": "^9.6.1",
     "from-node-stream": "^0.2.0",
     "ms": "^2.1.3",
+    "node-datachannel": "^0.32.3",
     "phpdie": "^1.7.0",
     "proper-lockfile": "^4.1.2",
     "sflow": "^1.27.0",
@@ -142,5 +144,7 @@
   "engines": {
     "node": ">=22.0.0"
   },
-  "trustedDependencies": []
+  "trustedDependencies": [
+    "node-datachannel"
+  ]
 }

package/scripts/cf.ts

@@ -0,0 +1,51 @@
+#!/usr/bin/env bun
+// Thin wrapper that runs `wrangler` against the SNOLAB Cloudflare account using
+// the API token saved in .env.local — so we never depend on `wrangler login`
+// state (which points at a different account) and never pass the token on the
+// CLI. Usage:  bun scripts/cf.ts <wrangler args...>
+//   e.g.  bun scripts/cf.ts whoami
+//         bun scripts/cf.ts pages deploy ./dist --project-name agent-yes
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync, renameSync, rmSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+
+// SNOLAB account — agent-yes.com lives here. Account id is not a secret.
+const SNOLAB_ACCOUNT_ID = "0beef4cd2d2da6befa47d8d149d6e157";
+
+const root = path.join(import.meta.dir, "..");
+const env: Record<string, string | undefined> = { ...process.env };
+
+// Load .env.local (bun also auto-loads it, but be explicit so this works from
+// any cwd and is obvious to a reader).
+try {
+  for (const line of readFileSync(path.join(root, ".env.local"), "utf8").split("\n")) {
+    const m = line.match(/^\s*([A-Z0-9_]+)\s*=\s*(.*?)\s*$/);
+    if (m && !(m[1] in env)) env[m[1]] = m[2];
+  }
+} catch {
+  /* no .env.local — fall through to the check below */
+}
+
+if (!env.CLOUDFLARE_API_TOKEN) {
+  console.error("CLOUDFLARE_API_TOKEN is missing — add it to .env.local (see scripts/cf.ts).");
+  process.exit(1);
+}
+env.CLOUDFLARE_ACCOUNT_ID = SNOLAB_ACCOUNT_ID;
+
+// wrangler otherwise prefers a stored OAuth login over CLOUDFLARE_API_TOKEN and
+// pins the OAuth account (Axon), ignoring CLOUDFLARE_ACCOUNT_ID. Two sources to
+// neutralise: the global OAuth config (~/.wrangler) and a project-level account
+// cache (.wrangler/wrangler-account.json) that pins whatever account first
+// deployed. Drop the cache, move the OAuth config aside for the run, restore it.
+rmSync(path.join(root, ".wrangler/wrangler-account.json"), { force: true });
+const oauthCfg = path.join(homedir(), ".wrangler/config/default.toml");
+const oauthBak = oauthCfg + ".cf-bak";
+const hadOauth = existsSync(oauthCfg);
+if (hadOauth) renameSync(oauthCfg, oauthBak);
+try {
+  const r = spawnSync("bunx", ["wrangler", ...process.argv.slice(2)], { stdio: "inherit", env });
+  process.exitCode = r.status ?? 1;
+} finally {
+  if (hadOauth && existsSync(oauthBak)) renameSync(oauthBak, oauthCfg);
+}

package/ts/index.ts

@@ -5,6 +5,7 @@ import path from "path";
 import DIE from "phpdie";
 import sflow from "sflow";
 import { XtermProxy } from "./xterm-proxy.ts";
+import { agentYesHome } from "./agentYesHome.ts";
 import {
   extractSessionId,
   getSessionForCwd,
@@ -643,11 +644,26 @@ export default async function agentYes({
     return pendingExitCode.resolve(exitCode);
   });
 
+  // Record the agent's current PTY size to ~/.agent-yes/ptysize/<pid> so `ay serve`
+  // / the web console can render the existing buffer at the agent's real width
+  // before adapting. Mirrors the Rust runtime (rs/src/pty_spawner.rs).
+  const writeCurrentPtysize = (cols: number, rows: number) => {
+    const dir = path.join(agentYesHome(), "ptysize");
+    void mkdir(dir, { recursive: true })
+      .then(() => writeFile(path.join(dir, String(process.pid)), `${cols} ${rows}\n`))
+      .catch(() => null);
+  };
+  {
+    const { cols, rows } = getTerminalDimensions();
+    writeCurrentPtysize(cols, rows);
+  }
+
   // when current tty resized, resize both pty and xterm proxy
   process.stdout.on("resize", () => {
     const { cols, rows } = getTerminalDimensions();
     shell.resize(cols, rows);
     xtermProxy.resize(cols, rows);
+    writeCurrentPtysize(cols, rows);
   });
 
   const isStillWorkingQ = () => {

package/ts/rustBinary.ts

@@ -41,10 +41,7 @@ export function getBinaryName(): string {
  */
 export function getBinDir(): string {
   // First check for binaries in the npm package
-  const packageBinDir = path.resolve(
-    import.meta.dirname ?? import.meta.dir,
-    "../bin",
-  );
+  const packageBinDir = path.resolve(import.meta.dirname ?? import.meta.dir, "../bin");
   if (existsSync(packageBinDir)) {
     return packageBinDir;
   }
@@ -61,8 +58,7 @@ export function getBinDir(): string {
   const cacheDir =
     process.env.AGENT_YES_CACHE_DIR ||
     path.join(
-      process.env.XDG_CACHE_HOME ||
-        path.join(process.env.HOME || "/tmp", ".cache"),
+      process.env.XDG_CACHE_HOME || path.join(process.env.HOME || "/tmp", ".cache"),
       "agent-yes",
     );
 
@@ -78,14 +74,8 @@ export function findRustBinary(verbose = false): string | undefined {
   const ext = process.platform === "win32" ? ".exe" : "";
   const searchPaths = [
     // 1. Check relative to this script (in the repo during development)
-    path.resolve(
-      import.meta.dirname ?? import.meta.dir,
-      `../rs/target/release/agent-yes${ext}`,
-    ),
-    path.resolve(
-      import.meta.dirname ?? import.meta.dir,
-      `../rs/target/debug/agent-yes${ext}`,
-    ),
+    path.resolve(import.meta.dirname ?? import.meta.dir, `../rs/target/release/agent-yes${ext}`),
+    path.resolve(import.meta.dirname ?? import.meta.dir, `../rs/target/debug/agent-yes${ext}`),
 
     // 2. Check in npm package bin directory
     path.join(getBinDir(), binaryName),
@@ -149,9 +139,7 @@ export async function downloadBinary(verbose = false): Promise<string> {
 
   const response = await fetch(url);
   if (!response.ok) {
-    throw new Error(
-      `Failed to download binary: ${response.status} ${response.statusText}`,
-    );
+    throw new Error(`Failed to download binary: ${response.status} ${response.statusText}`);
   }
 
   const isWindows = process.platform === "win32";
@@ -243,19 +231,14 @@ function getRustBinaryVersion(binaryPath: string): string | null {
  */
 function autoRebuildIfOutdated(binaryPath: string, verbose: boolean): boolean {
   // Only auto-rebuild for local dev builds (target/release or target/debug)
-  if (
-    !binaryPath.includes("/target/release") &&
-    !binaryPath.includes("/target/debug")
-  ) {
+  if (!binaryPath.includes("/target/release") && !binaryPath.includes("/target/debug")) {
     return true; // not a dev build, skip
   }
 
   const binaryVersion = getRustBinaryVersion(binaryPath);
   const pkgVersion = getInstalledPackage().version;
   if (verbose) {
-    console.log(
-      `[rust] Binary version: ${binaryVersion}, package version: ${pkgVersion}`,
-    );
+    console.log(`[rust] Binary version: ${binaryVersion}, package version: ${pkgVersion}`);
   }
 
   if (binaryVersion === pkgVersion) {
@@ -263,15 +246,9 @@ function autoRebuildIfOutdated(binaryPath: string, verbose: boolean): boolean {
   }
 
   // Find the rs/ directory relative to the binary (binary is at rs/target/release/agent-yes)
-  const rsDir = binaryPath.replace(
-    /\/target\/(release|debug)\/agent-yes.*$/,
-    "",
-  );
+  const rsDir = binaryPath.replace(/\/target\/(release|debug)\/agent-yes.*$/, "");
   if (!existsSync(path.join(rsDir, "Cargo.toml"))) {
-    if (verbose)
-      console.log(
-        `[rust] Cannot find Cargo.toml at ${rsDir}, skipping rebuild`,
-      );
+    if (verbose) console.log(`[rust] Cannot find Cargo.toml at ${rsDir}, skipping rebuild`);
     return true; // can't rebuild, use as-is
   }
 
@@ -299,9 +276,7 @@ function autoRebuildIfOutdated(binaryPath: string, verbose: boolean): boolean {
     process.stderr.write(`\x1b[32m[rust] Rebuild complete\x1b[0m\n`);
     return true;
   } catch {
-    process.stderr.write(
-      `\x1b[31m[rust] Auto-rebuild failed, using outdated binary\x1b[0m\n`,
-    );
+    process.stderr.write(`\x1b[31m[rust] Auto-rebuild failed, using outdated binary\x1b[0m\n`);
     return true; // still usable, just old
   }
 }

package/ts/serve.ts

@@ -1,4 +1,5 @@
-import { mkdir, readFile, writeFile } from "fs/promises";
+import { mkdir, open, readFile, writeFile } from "fs/promises";
+import { watch } from "node:fs";
 import { createHash, randomBytes, timingSafeEqual } from "crypto";
 import { homedir } from "os";
 import path from "path";
@@ -13,6 +14,7 @@ import {
   writeToIpc,
   type CommonOpts,
 } from "./subcommands.ts";
+import { SUPPORTED_CLIS } from "./SUPPORTED_CLIS.ts";
 
 const DEFAULT_PORT = 7432;
 
@@ -123,6 +125,8 @@ export async function cmdServe(rest: string[]): Promise<number> {
         `  --port N          Port to listen on (default: ${DEFAULT_PORT})\n` +
         `  --host HOST       Interface to bind (default: 127.0.0.1; use 0.0.0.0 to expose)\n` +
         `  --token TOKEN     Auth token (auto-generated and saved if omitted)\n` +
+        `  --share [URL]     Share over WebRTC to agent-yes.com (bare flag mints a room+link)\n` +
+        `  --allow-spawn     Deprecated no-op — the console can always spawn agents\n` +
         `  --tls-cert FILE   TLS certificate PEM\n` +
         `  --tls-key  FILE   TLS private key PEM\n\n` +
         `Subcommands:\n` +
@@ -153,6 +157,16 @@ export async function cmdServe(rest: string[]): Promise<number> {
     .option("token", { type: "string", description: "Auth token (auto-generated if omitted)" })
     .option("tls-cert", { type: "string", description: "TLS certificate file (PEM)" })
     .option("tls-key", { type: "string", description: "TLS private key file (PEM)" })
+    .option("share", {
+      type: "string",
+      description:
+        "Share over WebRTC: bare flag mints a room+link, or pass webrtc://room:token@host",
+    })
+    .option("allow-spawn", {
+      type: "boolean",
+      default: false,
+      description: "Deprecated no-op — the console can always spawn agents",
+    })
     .help(false)
     .version(false)
     .exitProcess(false);
@@ -178,6 +192,11 @@ export async function cmdServe(rest: string[]): Promise<number> {
   }
 
   const token = await loadOrCreateToken(tokenFlag);
+  // Spawning is always allowed: a connected console already has full read-write
+  // control over every running agent (it writes straight to their stdin), so it
+  // can already make an agent do anything — gating /api/spawn behind a flag or a
+  // y/N prompt bought no real safety. We just log each spawn so the host sees it.
+  // (--allow-spawn is still accepted as a no-op for older invocations.)
 
   const serverOpts: any = {
     hostname: host,
@@ -242,10 +261,39 @@ export async function cmdServe(rest: string[]): Promise<number> {
         }
       }
 
+      // GET /api/size/:keyword — the agent's current PTY size, so the console can
+      // render the existing buffer at the agent's real width before adapting.
+      const sizeM = /^\/api\/size\/(.+)$/.exec(p);
+      if (req.method === "GET" && sizeM) {
+        const keyword = decodeURIComponent(sizeM[1]!);
+        try {
+          const record = await resolveOne(keyword, defaultOpts());
+          const ayHome = process.env.AGENT_YES_HOME ?? path.join(homedir(), ".agent-yes");
+          let cols: number | null = null;
+          let rows: number | null = null;
+          try {
+            const txt = await readFile(path.join(ayHome, "ptysize", String(record.pid)), "utf-8");
+            const [c, r] = txt.trim().split(/\s+/).map(Number);
+            if (c > 0 && r > 0) {
+              cols = c;
+              rows = r;
+            }
+          } catch {
+            /* no ptysize sidecar (older agent or not yet written) */
+          }
+          return Response.json({ pid: record.pid, cols, rows });
+        } catch (e) {
+          return new Response((e as Error).message, { status: 404 });
+        }
+      }
+
       // GET /api/tail/:keyword  — SSE streaming
       const tailM = /^\/api\/tail\/(.+)$/.exec(p);
       if (req.method === "GET" && tailM) {
         const keyword = decodeURIComponent(tailM[1]!);
+        // raw=1 streams the unmodified PTY bytes (ANSI/cursor control intact) so a
+        // browser xterm.js can render the real terminal; default stays ANSI-stripped.
+        const raw = url.searchParams.get("raw") === "1";
         try {
           const record = await resolveOne(keyword, defaultOpts());
           if (!record.log_file)
@@ -259,10 +307,12 @@ export async function cmdServe(rest: string[]): Promise<number> {
                 ctrl.enqueue(enc.encode(`data: ${JSON.stringify(text)}\n\n`));
               const ping = () => ctrl.enqueue(enc.encode(": ping\n\n"));
 
-              // Initial tail
+              // Initial tail. Raw: replay the last ~64 KB of PTY bytes (enough to
+              // contain a recent full-screen redraw so xterm converges fast).
               const initBuf = await readFile(logPath).catch(() => Buffer.alloc(0));
-              const initText = await renderRawLog(initBuf, { mode: "tail", n: 96 });
-              send(initText);
+              if (raw)
+                send(new TextDecoder().decode(initBuf.slice(Math.max(0, initBuf.length - 65536))));
+              else send(await renderRawLog(initBuf, { mode: "tail", n: 96 }));
 
               let offset = initBuf.length;
               let closed = false;
@@ -281,30 +331,59 @@ export async function cmdServe(rest: string[]): Promise<number> {
               // eslint-disable-next-line no-control-regex
               const ctrlRe = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g;
 
-              const poller = setInterval(async () => {
-                if (closed) {
-                  clearInterval(poller);
-                  return;
-                }
+              // Stream only the bytes appended since `offset` (incremental read,
+              // not a full re-read), driven by fs.watch for near-instant echo with
+              // a short fallback poll in case the watcher misses an event. The old
+              // 300 ms full-file poll was the dominant typing-echo latency.
+              const fh = await open(logPath, "r").catch(() => null);
+              let reading = false;
+              const flush = async () => {
+                if (closed || reading || !fh) return;
+                reading = true;
                 try {
-                  const full = await readFile(logPath);
-                  if (full.length <= offset) return;
-                  const chunk = full.slice(offset);
-                  offset = full.length;
-                  const text = new TextDecoder()
-                    .decode(chunk)
-                    .replace(ansiRe, "")
-                    .replace(ctrlRe, "");
-                  if (text.trim()) send(text.trimStart());
+                  const { size } = await fh.stat();
+                  if (size < offset) offset = size; // truncated/rotated
+                  if (size > offset) {
+                    const len = size - offset;
+                    const buf = Buffer.allocUnsafe(len);
+                    const { bytesRead } = await fh.read(buf, 0, len, offset);
+                    offset += bytesRead;
+                    const chunk = buf.subarray(0, bytesRead);
+                    if (raw) {
+                      send(new TextDecoder().decode(chunk));
+                    } else {
+                      const text = new TextDecoder()
+                        .decode(chunk)
+                        .replace(ansiRe, "")
+                        .replace(ctrlRe, "");
+                      if (text.trim()) send(text.trimStart());
+                    }
+                  }
                 } catch {
                   /* log gone */
+                } finally {
+                  reading = false;
                 }
-              }, 300);
+              };
+
+              let watcher: ReturnType<typeof watch> | null = null;
+              try {
+                watcher = watch(logPath, () => void flush());
+              } catch {
+                /* fs.watch unsupported — the fallback poll below still works */
+              }
+              const poller = setInterval(() => void flush(), 60);
 
               req.signal.addEventListener("abort", () => {
                 closed = true;
                 clearInterval(heartbeat);
                 clearInterval(poller);
+                try {
+                  watcher?.close();
+                } catch {
+                  /* already closed */
+                }
+                void fh?.close().catch(() => {});
                 try {
                   ctrl.close();
                 } catch {
@@ -356,6 +435,71 @@ export async function cmdServe(rest: string[]): Promise<number> {
         }
       }
 
+      // POST /api/resize/:keyword  body {cols, rows} — drive the agent's PTY size.
+      // Mirrors `ay attach`: write ~/.agent-yes/winsize/<pid> then SIGWINCH; the
+      // agent's resize listener picks it up and reflows its TUI to that width.
+      const resizeM = /^\/api\/resize\/(.+)$/.exec(p);
+      if (req.method === "POST" && resizeM) {
+        const keyword = decodeURIComponent(resizeM[1]!);
+        let body: { cols?: number; rows?: number };
+        try {
+          body = await req.json();
+        } catch {
+          return new Response("invalid JSON body", { status: 400 });
+        }
+        const cols = Math.max(1, Math.floor(Number(body.cols) || 0));
+        const rows = Math.max(1, Math.floor(Number(body.rows) || 0));
+        if (!cols || !rows) return new Response("missing cols/rows", { status: 400 });
+        try {
+          const record = await resolveOne(keyword, defaultOpts());
+          const ayHome = process.env.AGENT_YES_HOME ?? path.join(homedir(), ".agent-yes");
+          const winsizeDir = path.join(ayHome, "winsize");
+          await mkdir(winsizeDir, { recursive: true });
+          await writeFile(
+            path.join(winsizeDir, String(record.pid)),
+            `${cols} ${rows} ${Date.now()}\n`,
+          );
+          try {
+            process.kill(record.pid, "SIGWINCH");
+          } catch {
+            /* agent gone */
+          }
+          return Response.json({ ok: true, pid: record.pid, cols, rows });
+        } catch (e) {
+          return new Response((e as Error).message, { status: 404 });
+        }
+      }
+
+      // POST /api/spawn  body {cli, cwd, prompt} — launch a new agent
+      if (req.method === "POST" && p === "/api/spawn") {
+        let body: { cli?: string; cwd?: string; prompt?: string };
+        try {
+          body = await req.json();
+        } catch {
+          return new Response("invalid JSON body", { status: 400 });
+        }
+        const cli = String(body.cli ?? "claude");
+        if (!SUPPORTED_CLIS.includes(cli as never))
+          return new Response(`unsupported cli: ${cli}`, { status: 400 });
+        const cwd = typeof body.cwd === "string" && body.cwd ? body.cwd : process.cwd();
+        const prompt = String(body.prompt ?? "");
+        process.stderr.write(
+          `→ console spawned:  ay ${cli}${prompt ? ` -- "${prompt.slice(0, 60)}"` : ""}  (cwd: ${cwd})\n`,
+        );
+        try {
+          const child = Bun.spawn(["ay", cli, ...(prompt ? ["--", prompt] : [])], {
+            cwd,
+            stdin: "ignore",
+            stdout: "ignore",
+            stderr: "ignore",
+          });
+          child.unref();
+          return Response.json({ ok: true, pid: child.pid, cli, cwd });
+        } catch (e) {
+          return new Response((e as Error).message, { status: 500 });
+        }
+      }
+
       return new Response("Not Found", { status: 404 });
     },
   };
@@ -380,6 +524,27 @@ export async function cmdServe(rest: string[]): Promise<number> {
         `  openssl req -x509 -newkey rsa:2048 -keyout key.pem -out cert.pem -days 365 -nodes -subj '/CN=localhost'\n\n`,
     );
   }
+  // --share: bridge this local server to a WebRTC room so the agent-yes.com
+  // console can reach it peer-to-peer. Bare flag mints a room; a webrtc:// value
+  // joins an explicit one.
+  if (argv.share !== undefined) {
+    const shareUrl =
+      typeof argv.share === "string" && argv.share.startsWith("webrtc://") ? argv.share : undefined;
+    try {
+      const { startShare } = await import("./share.ts");
+      const { link } = await startShare({
+        url: shareUrl,
+        apiUrl: `http://127.0.0.1:${port}`,
+        apiToken: token,
+      });
+      process.stdout.write(
+        `\nshared over WebRTC — open this link (the token is eaten from the URL on open):\n  ${link}\n\n`,
+      );
+    } catch (e) {
+      process.stderr.write(`ay serve --share failed: ${(e as Error).message}\n`);
+    }
+  }
+
   process.stdout.write(`(Ctrl-C to stop)\n`);
 
   await new Promise<void>((resolve) => {