ashlr-plugin 1.36.4

package/servers/_pro.ts

@@ -0,0 +1,381 @@
+/**
+ * _pro.ts — Pro token validation with 24h cache and 7-day offline grace.
+ *
+ * The token stored in ~/.ashlr/pro-token is a permanent API token (not a JWT)
+ * issued by POST /auth/verify on the server. Validation is done by calling
+ * GET /user/me with the Bearer token — the server returns { userId, email,
+ * tier, githubLogin, hasGitHub }. "Pro" status means tier === "pro" || "team".
+ *
+ * Cache semantics:
+ *   - Validated result is written to ~/.ashlr/pro-token-cache.json.
+ *   - Cache < 24h old → used directly, no network call.
+ *   - Cache 24h–7d old → used immediately (offline grace), background refresh
+ *     triggered via setImmediate.
+ *   - Cache > 7d old → treated as expired; forces synchronous re-validation.
+ *   - 401 from server → renames token to pro-token.invalid, returns invalid.
+ *   - Network error → falls back to cached result if < 7 days old.
+ */
+
+import { existsSync, renameSync, statSync } from "fs";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { homedir } from "os";
+import { join, dirname } from "path";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const CACHE_TTL_MS      = 24 * 60 * 60 * 1000;   // 24h
+const OFFLINE_GRACE_MS  = 7  * 24 * 60 * 60 * 1000; // 7d
+
+const API_URL = process.env["ASHLR_API_URL"] ?? "https://api.ashlr.ai";
+
+/**
+ * Offline / air-gapped escape hatch.
+ *
+ * Setting `ASHLR_PRO_ASSUME=true` (case-insensitive) forces `isProSync()`
+ * to return true regardless of cache state or the 7-day staleness gate.
+ * Use when you cannot reach api.ashlr.ai for an extended period (planes,
+ * air-gapped networks, conference Wi-Fi from hell) and need Pro features
+ * to keep working.
+ *
+ * Truthy values: any non-empty value other than "0", "false", "no", or
+ * "off" (case-insensitive after trim). Unset / empty → disabled.
+ */
+export function isProAssumeEnabled(env: NodeJS.ProcessEnv = process.env): boolean {
+  const raw = env["ASHLR_PRO_ASSUME"];
+  if (raw == null) return false;
+  const v = String(raw).trim().toLowerCase();
+  if (v === "" || v === "0" || v === "false" || v === "no" || v === "off") return false;
+  return true;
+}
+
+// ---------------------------------------------------------------------------
+// Paths
+// ---------------------------------------------------------------------------
+
+function ashlrDir(homeOverride?: string): string {
+  return join(homeOverride ?? process.env.HOME ?? homedir(), ".ashlr");
+}
+
+export function proTokenPath(homeOverride?: string): string {
+  return join(ashlrDir(homeOverride), "pro-token");
+}
+
+export function proTokenCachePath(homeOverride?: string): string {
+  return join(ashlrDir(homeOverride), "pro-token-cache.json");
+}
+
+// ---------------------------------------------------------------------------
+// Cache types
+// ---------------------------------------------------------------------------
+
+export interface ProTokenCache {
+  valid: boolean;
+  plan: string | null;
+  trialEndsAt: string | null;
+  validatedAt: string; // ISO
+}
+
+export interface ProValidationResult {
+  valid: boolean;
+  plan: string | null;
+  trialEndsAt: string | null;
+  validatedAt: string | null;
+  reason?: "no-token" | "expired-or-revoked" | "network-error" | "cached";
+}
+
+// ---------------------------------------------------------------------------
+// Cache I/O
+// ---------------------------------------------------------------------------
+
+async function readCache(homeOverride?: string): Promise<ProTokenCache | null> {
+  const p = proTokenCachePath(homeOverride);
+  try {
+    const raw = await readFile(p, "utf-8");
+    const parsed = JSON.parse(raw) as ProTokenCache;
+    if (
+      typeof parsed.valid === "boolean" &&
+      typeof parsed.validatedAt === "string"
+    ) {
+      return parsed;
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+async function writeCache(cache: ProTokenCache, homeOverride?: string): Promise<void> {
+  const p = proTokenCachePath(homeOverride);
+  try {
+    await mkdir(dirname(p), { recursive: true });
+    await writeFile(p, JSON.stringify(cache, null, 2), { encoding: "utf-8", mode: 0o600 });
+  } catch {
+    // best-effort — never block the hot path
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Token file I/O
+// ---------------------------------------------------------------------------
+
+function readTokenSync(homeOverride?: string): string | null {
+  const p = proTokenPath(homeOverride);
+  try {
+    const s = statSync(p);
+    if (!s.isFile() || s.size === 0) return null;
+    const { readFileSync } = require("fs") as typeof import("fs");
+    return readFileSync(p, "utf-8").trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+function invalidateToken(homeOverride?: string): void {
+  const p = proTokenPath(homeOverride);
+  const dest = p + ".invalid";
+  try {
+    renameSync(p, dest);
+  } catch {
+    // best-effort
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Network validation
+// ---------------------------------------------------------------------------
+
+interface UserMeResponse {
+  userId?: string;
+  email?: string;
+  tier?: string;
+  githubLogin?: string | null;
+  hasGitHub?: boolean;
+}
+
+type FetchLike = (input: Parameters<typeof fetch>[0], init?: Parameters<typeof fetch>[1]) => Promise<Response>;
+
+/**
+ * Calls GET /user/me with the given token.
+ * Returns null on network error (caller should fall back to cache).
+ * Returns { tier } on success, or throws with status 401 when revoked.
+ */
+async function fetchUserMe(
+  token: string,
+  fetchImpl: FetchLike = globalThis.fetch,
+  timeoutMs = 5000,
+): Promise<{ tier: string; trialEndsAt: string | null } | null> {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+
+  try {
+    const res = await fetchImpl(`${API_URL}/user/me`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+      },
+      signal: ctrl.signal,
+    });
+
+    if (res.status === 401) {
+      throw Object.assign(new Error("401"), { status: 401 });
+    }
+
+    if (!res.ok) {
+      // 5xx or unexpected — treat as network error (fallback to cache)
+      return null;
+    }
+
+    let body: UserMeResponse;
+    try {
+      body = (await res.json()) as UserMeResponse;
+    } catch {
+      return null;
+    }
+
+    return {
+      tier: body.tier ?? "free",
+      // trialEndsAt is always null: the server's GET /user/me response does not
+      // include a trial_end field (the DB user row has no trial_end column and
+      // Stripe trial_end is not fetched on this path). No UI in the plugin
+      // displays this value today, so null is correct and safe — it is NOT a
+      // countdown timer that could mislead users. Wire it when the server adds
+      // the field (requires a Stripe subscription lookup + DB migration).
+      trialEndsAt: null,
+    };
+  } catch (err: unknown) {
+    if (err instanceof Error && "status" in err && (err as { status: number }).status === 401) {
+      throw err; // propagate 401
+    }
+    // Timeout or network error → caller falls back
+    return null;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Background refresh
+// ---------------------------------------------------------------------------
+
+function spawnBackgroundRefresh(homeOverride?: string): void {
+  setImmediate(async () => {
+    try {
+      const token = readTokenSync(homeOverride);
+      if (!token) return;
+      const result = await fetchUserMe(token);
+      if (!result) return;
+      const isPro = result.tier === "pro" || result.tier === "team";
+      await writeCache(
+        {
+          valid: isPro,
+          plan: result.tier,
+          trialEndsAt: result.trialEndsAt,
+          validatedAt: new Date().toISOString(),
+        },
+        homeOverride,
+      );
+    } catch {
+      // background refresh — never throw
+    }
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Validate the Pro token in ~/.ashlr/pro-token.
+ *
+ * @param opts.homeOverride   Override home dir (for testing).
+ * @param opts.fetchImpl      Override fetch (for testing).
+ * @param opts.nowMs          Override Date.now() (for testing).
+ */
+export async function validateProToken(opts: {
+  homeOverride?: string;
+  fetchImpl?: FetchLike;
+  nowMs?: number;
+} = {}): Promise<ProValidationResult> {
+  const { homeOverride, fetchImpl = globalThis.fetch, nowMs = Date.now() } = opts;
+
+  // 1. Check token file
+  const token = readTokenSync(homeOverride);
+  if (!token) {
+    return { valid: false, plan: null, trialEndsAt: null, validatedAt: null, reason: "no-token" };
+  }
+
+  // 2. Read cache
+  const cached = await readCache(homeOverride);
+  const cacheAge = cached ? nowMs - new Date(cached.validatedAt).getTime() : Infinity;
+
+  // 3. Cache < 24h → use directly
+  if (cached && cacheAge < CACHE_TTL_MS) {
+    return {
+      valid: cached.valid,
+      plan: cached.plan,
+      trialEndsAt: cached.trialEndsAt,
+      validatedAt: cached.validatedAt,
+      reason: "cached",
+    };
+  }
+
+  // 4. Cache is stale (24h–7d) → return cached value, refresh in background
+  if (cached && cacheAge < OFFLINE_GRACE_MS) {
+    spawnBackgroundRefresh(homeOverride);
+    return {
+      valid: cached.valid,
+      plan: cached.plan,
+      trialEndsAt: cached.trialEndsAt,
+      validatedAt: cached.validatedAt,
+      reason: "cached",
+    };
+  }
+
+  // 5. No usable cache → do a synchronous network call
+  try {
+    const result = await fetchUserMe(token, fetchImpl);
+
+    if (result === null) {
+      // Network error — if we have a stale cache (> 7d), still use it
+      if (cached) {
+        return {
+          valid: cached.valid,
+          plan: cached.plan,
+          trialEndsAt: cached.trialEndsAt,
+          validatedAt: cached.validatedAt,
+          reason: "network-error",
+        };
+      }
+      return { valid: false, plan: null, trialEndsAt: null, validatedAt: null, reason: "network-error" };
+    }
+
+    const isPro = result.tier === "pro" || result.tier === "team";
+    const newCache: ProTokenCache = {
+      valid: isPro,
+      plan: result.tier,
+      trialEndsAt: result.trialEndsAt,
+      validatedAt: new Date(nowMs).toISOString(),
+    };
+    await writeCache(newCache, homeOverride);
+
+    return {
+      valid: isPro,
+      plan: result.tier,
+      trialEndsAt: result.trialEndsAt,
+      validatedAt: newCache.validatedAt,
+    };
+  } catch (err: unknown) {
+    // 401 → revoke token
+    if (err instanceof Error && "status" in err && (err as { status: number }).status === 401) {
+      invalidateToken(homeOverride);
+      return {
+        valid: false,
+        plan: null,
+        trialEndsAt: null,
+        validatedAt: null,
+        reason: "expired-or-revoked",
+      };
+    }
+
+    // Unexpected error → fallback to stale cache
+    if (cached) {
+      return {
+        valid: cached.valid,
+        plan: cached.plan,
+        trialEndsAt: cached.trialEndsAt,
+        validatedAt: cached.validatedAt,
+        reason: "network-error",
+      };
+    }
+    return { valid: false, plan: null, trialEndsAt: null, validatedAt: null, reason: "network-error" };
+  }
+}
+
+/**
+ * Synchronous best-effort Pro check — reads only the cache file.
+ * Returns false when no cache or cache is expired beyond 7d.
+ * Suitable for hot paths where we cannot await.
+ */
+export function isProSync(homeOverride?: string): boolean {
+  // Offline / air-gapped escape hatch — set ASHLR_PRO_ASSUME=true to bypass
+  // the 7-day cache-staleness gate (and the cache existence check).
+  if (isProAssumeEnabled()) return true;
+
+  const cached = (() => {
+    const p = proTokenCachePath(homeOverride);
+    try {
+      const { readFileSync } = require("fs") as typeof import("fs");
+      const raw = readFileSync(p, "utf-8");
+      return JSON.parse(raw) as ProTokenCache;
+    } catch {
+      return null;
+    }
+  })();
+
+  if (!cached) return false;
+  const age = Date.now() - new Date(cached.validatedAt).getTime();
+  return cached.valid && age < OFFLINE_GRACE_MS;
+}

package/servers/_read-cache.ts

@@ -0,0 +1,44 @@
+/**
+ * _read-cache — per-process content cache for ashlr__read.
+ *
+ * Keyed by absolute path; the cached result is only reused when the file's
+ * mtimeMs matches — any write (ours via ashlr__edit, or external) invalidates.
+ * Lives for the MCP server lifetime, which aligns with a single Claude Code
+ * session.
+ *
+ * Module-level singleton. All consumers (read-server, edit-server) import
+ * the same instance.
+ */
+
+export interface ReadCacheEntry {
+  mtimeMs: number;
+  /** The exact string we would have returned on a miss. */
+  result: string;
+  /** Bytes of the original file when cached — for correct savings math on reuse. */
+  sourceBytes: number;
+}
+
+const readCache: Map<string, ReadCacheEntry> = new Map();
+
+/** Return the cached entry for `abs`, or undefined if absent. */
+export function getCached(abs: string): ReadCacheEntry | undefined {
+  return readCache.get(abs);
+}
+
+/** Store a cache entry for `abs`. */
+export function setCached(abs: string, entry: ReadCacheEntry): void {
+  readCache.set(abs, entry);
+}
+
+/**
+ * Invalidate the cache entry for `abs` so the next read fetches fresh
+ * content. Called by edit-server immediately after a successful write.
+ *
+ * Sets mtimeMs to -1 (guaranteed mismatch against any real stat) rather than
+ * deleting so that a concurrent read that already looked up the entry will
+ * still see a miss when it compares mtimes.
+ */
+export function invalidateCached(abs: string): void {
+  const hit = readCache.get(abs);
+  if (hit) readCache.set(abs, { ...hit, mtimeMs: -1 });
+}

package/servers/_router-handlers.ts

@@ -0,0 +1,46 @@
+/**
+ * _router-handlers — side-effect aggregator.
+ *
+ * Importing this file registers all migrated tool handlers into the shared
+ * registry (_tool-base.ts). The router imports this once on startup; each
+ * per-server handlers module is a no-op if imported again (registerTool is
+ * idempotent — last write wins).
+ *
+ * Add one import per server as it completes Track A migration.
+ */
+
+import "./glob-server-handlers";
+import "./tree-server-handlers";
+import "./ls-server-handlers";
+import "./diff-server-handlers";
+import "./webfetch-server-handlers";
+// Track B (v1.21): efficiency-server decomposed into 5 per-tool servers.
+// The old composite efficiency-server-handlers is retired; each new
+// handler module side-effect-registers its tool below.
+import "./read-server-handlers";
+import "./grep-server-handlers";
+import "./edit-server-handlers";
+import "./flush-server-handlers";
+import "./savings-server-handlers";
+import "./orient-server-handlers";
+import "./http-server-handlers";
+import "./logs-server-handlers";
+import "./sql-server-handlers";
+import "./multi-edit-server-handlers";
+import "./diff-semantic-server-handlers";
+import "./github-server-handlers";
+import "./genome-server-handlers";
+import "./ask-server-handlers";
+import "./bash-server-handlers";
+import "./edit-structural-server-handlers";
+import "./test-server-handlers";
+import "./rename-file-server-handlers";
+import "./search-replace-regex-server-handlers";
+// v1.22 Track B
+import "./websearch-server-handlers";
+import "./task-server-handlers";
+// v1.22 Track C
+import "./notebook-edit-server-handlers";
+import "./write-server-handlers";
+// v1.34 Track 3 — flag-gated; no-op when ASHLR_PIPE_ENABLE != "1"
+import "./pipe-server-handlers";

package/servers/_router.ts

@@ -0,0 +1,55 @@
+#!/usr/bin/env bun
+/**
+ * ashlr-router — single long-lived MCP process hosting all 40 ashlr__* tools.
+ *
+ * One process replaces the old N-process architecture where each tool spawned
+ * its own child. Shared resources (SQLite embedding cache, summarizer pool,
+ * genome LRU) are initialized once and reused across every tool call.
+ *
+ * Architecture:
+ *   - `_router-handlers.ts` imports every handler module as a side-effect,
+ *     which registers all tools into the shared registry in `_tool-base.ts`.
+ *   - `runStandalone()` boots a single MCP stdio server that dispatches
+ *     `tools/list` and `tools/call` via the registry.
+ *   - Per-handler crash isolation: one handler throwing does NOT kill the
+ *     process — the dispatch boundary in `_tool-base.ts::runStandalone` wraps
+ *     each call in try/catch and returns `isError: true` with a crash-dump.
+ *   - `ASHLR_ROUTER_DISABLE=1` short-circuits and exits cleanly so legacy
+ *     per-server plugin.json entries can take over if needed.
+ *
+ * Legacy entrypoints (efficiency-server.ts, grep-server.ts, …) keep their
+ * `if (import.meta.main)` guards intact so they still work for direct
+ * invocation and for smoke tests.
+ */
+
+import { listTools, runStandalone } from "./_tool-base";
+import { detectMcpHost } from "./_mcp-host";
+import "./_router-handlers";
+
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+
+async function main(): Promise<void> {
+  if (process.env.ASHLR_ROUTER_DISABLE === "1") {
+    process.stderr.write(
+      "[ashlr-router] ASHLR_ROUTER_DISABLE=1 set; exiting so per-server entries run instead.\n",
+    );
+    process.exit(0);
+  }
+
+  const toolCount = listTools().length;
+  const host = detectMcpHost();
+  process.stderr.write(
+    `[ashlr-router] starting · ${toolCount} tools registered · version=${process.env.ASHLR_VERSION ?? "dev"} · host=${host}\n`,
+  );
+
+  await runStandalone("ashlr-router", process.env.ASHLR_VERSION ?? "dev");
+}
+
+if (import.meta.main) {
+  main().catch((err) => {
+    process.stderr.write(`[ashlr-router] fatal: ${err instanceof Error ? err.stack ?? err.message : String(err)}\n`);
+    process.exit(1);
+  });
+}

package/servers/_run-with-timeout.ts

@@ -0,0 +1,173 @@
+/**
+ * _run-with-timeout.ts — async subprocess wrapper with process-group cleanup.
+ *
+ * Mirrors the bash-server.ts `runRaw` pattern (spawn + on('close') + accumulator
+ * buffers + signal handling) but generalises it into a reusable utility for the
+ * server hot-paths that previously called spawnSync.
+ *
+ * Key behaviours:
+ *   - POSIX: `detached: true` creates a process group; on timeout we SIGKILL
+ *     the whole group (`-pid`) so grandchild processes don't leak.
+ *   - Windows: `taskkill /T /F /PID` cascades through the process tree.
+ *   - SIGTERM first, 250 ms grace, then SIGKILL.
+ *   - Never throws on subprocess error — returns `exitCode: -1` with the error
+ *     surfaced in `stderr`.
+ *   - Stdout and stderr are each capped at 10 MB to prevent OOM on runaway
+ *     output; excess bytes are silently dropped (the cap notice appears in
+ *     stderr so callers can detect truncation).
+ */
+
+import { spawn } from "child_process";
+
+/** Maximum bytes buffered per stream before we stop accumulating. */
+const STREAM_CAP = 10 * 1024 * 1024; // 10 MB
+
+export interface RunWithTimeoutOptions {
+  command: string;
+  args: string[];
+  cwd?: string;
+  env?: Record<string, string>;
+  timeoutMs: number;
+  /** Optional stdin to feed the child process (UTF-8 string). */
+  input?: string;
+}
+
+export interface RunWithTimeoutResult {
+  stdout: string;
+  stderr: string;
+  /** Process exit code, or -1 on spawn error. */
+  exitCode: number;
+  timedOut: boolean;
+}
+
+/**
+ * Spawn `command args` and collect stdout/stderr, killing the process (group)
+ * after `timeoutMs` milliseconds. Returns a resolved Promise — never rejects.
+ */
+export function runWithTimeout(opts: RunWithTimeoutOptions): Promise<RunWithTimeoutResult> {
+  return new Promise((resolveP) => {
+    const isWin = process.platform === "win32";
+
+    const child = spawn(opts.command, opts.args, {
+      cwd: opts.cwd,
+      env: opts.env ?? (process.env as Record<string, string>),
+      stdio: opts.input !== undefined ? ["pipe", "pipe", "pipe"] : ["ignore", "pipe", "pipe"],
+      // POSIX: own process group so timeout can kill the whole tree.
+      // Windows: detached:true spawns a new console window, so we skip it.
+      detached: !isWin,
+    });
+
+    let stdout = "";
+    let stderr = "";
+    let stdoutCapped = false;
+    let stderrCapped = false;
+    let timedOut = false;
+
+    child.stdout?.on("data", (b: Buffer) => {
+      if (stdout.length >= STREAM_CAP) {
+        if (!stdoutCapped) {
+          stdoutCapped = true;
+          stderr += `\n[_run-with-timeout: stdout capped at ${STREAM_CAP} bytes]\n`;
+        }
+        return;
+      }
+      const remaining = STREAM_CAP - stdout.length;
+      if (b.length <= remaining) {
+        stdout += b.toString("utf-8");
+      } else {
+        // Truncate the chunk so total stays at exactly STREAM_CAP.
+        stdout += b.subarray(0, remaining).toString("utf-8");
+        if (!stdoutCapped) {
+          stdoutCapped = true;
+          stderr += `\n[_run-with-timeout: stdout capped at ${STREAM_CAP} bytes]\n`;
+        }
+      }
+    });
+
+    child.stderr?.on("data", (b: Buffer) => {
+      if (stderr.length >= STREAM_CAP) {
+        if (!stderrCapped) {
+          stderrCapped = true;
+          stderr += `\n[_run-with-timeout: stderr capped at ${STREAM_CAP} bytes]\n`;
+        }
+        return;
+      }
+      const remaining = STREAM_CAP - stderr.length;
+      if (b.length <= remaining) {
+        stderr += b.toString("utf-8");
+      } else {
+        stderr += b.subarray(0, remaining).toString("utf-8");
+        if (!stderrCapped) {
+          stderrCapped = true;
+          stderr += `\n[_run-with-timeout: stderr capped at ${STREAM_CAP} bytes]\n`;
+        }
+      }
+    });
+
+    // Write stdin if provided, then close it.
+    if (opts.input !== undefined && child.stdin) {
+      try {
+        child.stdin.write(opts.input, "utf-8");
+        child.stdin.end();
+      } catch {
+        // stdin may already be closed if the child died immediately.
+      }
+    }
+
+    /** Kill the process tree and set timedOut flag. */
+    function killTree(): void {
+      timedOut = true;
+      if (isWin) {
+        // taskkill /T cascades through child processes on Windows.
+        if (child.pid != null) {
+          spawn("taskkill", ["/T", "/F", "/PID", String(child.pid)], {
+            stdio: "ignore",
+          }).on("error", () => {
+            // Ignore — process may already be gone.
+          });
+        } else {
+          try { child.kill("SIGKILL"); } catch { /* already dead */ }
+        }
+      } else if (child.pid != null) {
+        // SIGTERM first; escalate to SIGKILL after 250 ms grace period.
+        try {
+          process.kill(-child.pid, "SIGTERM");
+        } catch {
+          try { child.kill("SIGTERM"); } catch { /* already dead */ }
+        }
+        setTimeout(() => {
+          try {
+            // Negative pid => send to the whole process group.
+            process.kill(-child.pid!, "SIGKILL");
+          } catch {
+            try { child.kill("SIGKILL"); } catch { /* already dead */ }
+          }
+        }, 250);
+      } else {
+        try { child.kill("SIGKILL"); } catch { /* already dead */ }
+      }
+    }
+
+    const timer = setTimeout(killTree, opts.timeoutMs);
+
+    child.on("close", (code) => {
+      clearTimeout(timer);
+      resolveP({
+        stdout,
+        stderr,
+        exitCode: code ?? (timedOut ? -1 : -1),
+        timedOut,
+      });
+    });
+
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      resolveP({
+        stdout,
+        stderr: stderr + `\n[spawn error: ${err.message}]`,
+        exitCode: -1,
+        timedOut,
+      });
+    });
+  });
+}