@zythum02/fello-server 0.1.32 → 0.1.39

package/out/renderer/index.html

@@ -2,10 +2,11 @@
 <html lang="en">
   <head>
     <meta charset="UTF-8" />
+    <link rel="icon" href="data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMDI0IiBoZWlnaHQ9IjEwMjQiIHZpZXdCb3g9IjAgMCAxMDI0IDEwMjQiPgoJPHJlY3QgeD0iMCIgeT0iMCIgd2lkdGg9IjEwMjQiIGhlaWdodD0iMTAyNCIgcng9IjIyMCIgZmlsbD0iI0ZGRkZGRiIvPgoJPHBhdGggZmlsbD0ibm9uZSIgZmlsbC1ydWxlPSJldmVub2RkIiBzdHJva2U9IiM0RDRENEQiIHN0cm9rZS13aWR0aD0iODAiIGQ9Ik03NzggNjMyLjY1OWMwIDI5LjQ4LTIzLjg2MyA1My4zOC01My4zIDUzLjM4SDM3My42NjZhNTMuMjYgNTMuMjYgMCAwIDAtMzcuNjgzIDE1LjY0TDI3Ny4zIDc2MC40NWExOC45IDE4LjkgMCAwIDEtMjAuNjIgNC4xMDdBMTguOTUgMTguOTUgMCAwIDEgMjQ1IDc0Ny4wNTJWMzEyLjM4YzAtMjkuNDgxIDIzLjg2My01My4zOCA1My4zLTUzLjM4aDQyNi40YzI5LjQzNyAwIDUzLjMgMjMuODk5IDUzLjMgNTMuMzh6Ii8+Cjwvc3ZnPg==" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Fello</title>
-    <script type="module" crossorigin src="./assets/index-B1oSpSBX.js"></script>
-    <link rel="stylesheet" crossorigin href="./assets/index-COLJTco3.css">
+    <script type="module" crossorigin src="./assets/index-l_WeGi7a.js"></script>
+    <link rel="stylesheet" crossorigin href="./assets/index-CTSkyk5N.css">
   </head>
   <body>
     <div id="root"></div>

package/out/scripts/mcp-search/server.mjs

@@ -0,0 +1,238 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import * as http from "http";
+const searchRequestSchema = z.object({
+  pattern: z.string().describe("Search pattern (literal text by default, set regex=true for regex)."),
+  path: z.string().describe(
+    "Directory or file(s) to search. Accepts: relative path (relative to project root), absolute path (POSIX or Windows), or file:// URI."
+  ),
+  ignoreCase: z.boolean().optional().describe("Case insensitive search (-i)."),
+  regex: z.boolean().optional().describe("Treat pattern as regex instead of literal text."),
+  type: z.string().optional().describe("File type filter: ts, js, py, rs, go, md, etc (-t)."),
+  glob: z.string().optional().describe("Glob filter: *.test.ts, *.spec.js (-g)."),
+  context: z.number().int().nonnegative().optional().describe("Lines of context before and after each match (-C)."),
+  maxResults: z.number().int().positive().optional().describe("Max number of matching lines to return (-m)."),
+  listFiles: z.boolean().optional().describe("Only list file paths with matches, not content (-l)."),
+  invertMatch: z.boolean().optional().describe("Show lines that do NOT match the pattern (-v)."),
+  wordMatch: z.boolean().optional().describe("Only match whole words (-w).")
+});
+const searchRespondSchema = z.object({
+  output: z.string(),
+  code: z.number()
+});
+const rgRequestSchema = z.object({
+  args: z.array(z.string()).describe(
+    "Raw ripgrep CLI arguments (e.g. ['-i', 'pattern', 'src/']). The pattern and path are included in this array."
+  )
+});
+const rgRespondSchema = z.object({
+  output: z.string(),
+  code: z.number(),
+  stderr: z.string().optional()
+});
+const fileOutlineRequestSchema = z.object({
+  path: z.string().describe(
+    "File path to analyze. Accepts: relative path (relative to project root), absolute path (POSIX or Windows), or file:// URI."
+  )
+});
+const fileOutlineRespondSchema = z.object({
+  outline: z.string().describe("Structural outline of the file in text format.")
+});
+function getArg(name) {
+  const idx = process.argv.indexOf(`--${name}`);
+  return idx !== -1 ? process.argv[idx + 1] : void 0;
+}
+const socketPath = getArg("socket-path");
+const projectDir = getArg("project-dir");
+if (!socketPath) {
+  console.error("[mcp-search] Missing required argument: --socket-path");
+  process.exit(1);
+}
+if (!projectDir) {
+  console.error("[mcp-search] Missing required argument: --project-dir");
+  process.exit(1);
+}
+const server = new McpServer({
+  name: "Search",
+  version: "1.0.0",
+  description: "Search file contents and inspect file structure. Provides search (common patterns), rg (raw ripgrep args), and file_outline (AST-based file structure preview)."
+});
+server.registerTool(
+  "search",
+  {
+    description: `Search file contents for common patterns using ripgrep.
+Fast, respects .gitignore, skips hidden/binary files by default.
+Pattern is treated as literal text by default. Set regex=true if you need regex.
+For advanced rg flags not covered here (multiline, PCRE2, --sort, --json, --stats, etc.), use the rg tool instead.
+
+Common examples:
+  search("TODO", ".")
+  search("function", "src/", { type: "ts" })
+  search("console.log", "src/", { ignoreCase: true, context: 2 })
+  search("import", ".", { glob: "*.tsx", maxResults: 20 })
+  search("useEffect", "src/", { listFiles: true })
+
+The path parameter accepts:
+- Relative path (relative to project root): "src/", "./lib"
+- Absolute path (POSIX or Windows): "/Users/me/project/src", "C:\\project\\src"
+- file:// URI: "file:///Users/me/project/src"`,
+    inputSchema: searchRequestSchema
+  },
+  async (input) => {
+    try {
+      const result = searchRespondSchema.parse(await postToSocket("/search/search", input));
+      return {
+        content: [
+          {
+            type: "text",
+            text: result.output || "(no matches)"
+          }
+        ]
+      };
+    } catch (err) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Search failed: ${err.message || String(err)}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+server.registerTool(
+  "rg",
+  {
+    description: `Run raw ripgrep (rg) with full CLI argument support.
+Use this when you need rg flags not covered by the search tool (multiline, PCRE2, --sort, --json, --stats, --no-ignore, --type-add, etc.).
+
+Full reference: https://github.com/BurntSushi/ripgrep/blob/master/GUIDE.md
+
+Common examples:
+  rg(["--multiline", "class\\n.*\\n\\{", "src/"])
+  rg(["-P", "pattern", "src/"])
+  rg(["--json", "pattern", "src/"])
+  rg(["--stats", "-l", "pattern", "src/"])
+  rg(["--type-add", "web:*.{html,css,js}", "-t", "web", "pattern"])
+  rg(["-u", "pattern", "src/"])
+
+Paths in args are automatically normalized:
+- Relative paths resolve against the project root
+- Absolute paths and file:// URIs are used as-is`,
+    inputSchema: rgRequestSchema
+  },
+  async (input) => {
+    try {
+      const result = rgRespondSchema.parse(await postToSocket("/search/rg", input));
+      const content = [];
+      if (result.output) content.push(result.output);
+      if (result.stderr) content.push(`[stderr]
+${result.stderr}`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: content.join("\n\n") || `(exit code: ${result.code})`
+          }
+        ]
+      };
+    } catch (err) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `rg failed: ${err.message || String(err)}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+server.registerTool(
+  "file_outline",
+  {
+    description: `Get a structural outline of a file WITHOUT reading its full content.
+Use this to understand a file's structure before reading it.
+Uses tree-sitter WASM parsing to extract function/class/interface/type/property signatures with line ranges and JSDoc comments.
+Returns tree-structured metadata only - no code body is included.
+Use this first before ReadFile to understand a file's structure.
+
+Supports: TypeScript (.ts), JavaScript/JSX (.js/.jsx/.mjs/.cjs), TSX (.tsx), Python (.py), Go (.go), C (.c/.h), C++ (.cpp/.cc/.cxx/.hpp/.hxx/.hh), Swift (.swift), Kotlin (.kt/.kts), Markdown (.md/.mdx/.markdown).
+
+The path parameter accepts:
+- Relative path (relative to project root): "src/app.ts", "./lib/utils.ts"
+- Absolute path (POSIX or Windows): "/Users/me/project/src/app.ts", "C:\\project\\src\\app.ts"
+- file:// URI: "file:///Users/me/project/src/app.ts"`,
+    inputSchema: fileOutlineRequestSchema
+  },
+  async (input) => {
+    try {
+      const result = fileOutlineRespondSchema.parse(
+        await postToSocket("/search/file_outline", input)
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: result.outline
+          }
+        ]
+      };
+    } catch (err) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: `file_outline failed: ${err.message || String(err)}`
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+function postToSocket(path, body) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const options = {
+      socketPath,
+      path,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(data)
+      }
+    };
+    const req = http.request(options, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => {
+        const raw = Buffer.concat(chunks).toString("utf8");
+        try {
+          const parsed = JSON.parse(raw);
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(parsed);
+          } else {
+            reject(new Error(parsed.error || `HTTP ${res.statusCode}: ${raw}`));
+          }
+        } catch {
+          reject(new Error(`Invalid response (${res.statusCode}): ${raw}`));
+        }
+      });
+    });
+    req.on("error", (err) => {
+      reject(new Error(`Socket request failed: ${err.message}`));
+    });
+    req.write(data);
+    req.end();
+  });
+}
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch(console.error);

package/out/scripts/mcp-share-to-user/server.mjs

@@ -0,0 +1,131 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import * as http from "http";
+const shareToUserRequestSchema = z.object({
+  type: z.enum(["link", "base64", "project"]).describe(
+    "How the file is provided: 'link' (file://, https://, or http:// URL), 'base64' (inline data), or 'project' (relative path within the project directory, zero-copy)."
+  ),
+  uri: z.string().optional().describe(
+    "File URI. Supports file:// (local file), https://, or http:// URLs. Required when type='link'. When type='project', this is the relative path within the project directory."
+  ),
+  data: z.string().optional().describe("Base64-encoded file data. Required when type='base64'."),
+  name: z.string().describe("Filename (e.g. 'diagram.png', 'report.pdf', 'output.csv')."),
+  mimeType: z.string().optional().describe(
+    "MIME type (e.g. 'image/png', 'application/pdf'). If omitted, inferred from filename extension."
+  )
+}).refine(
+  (data) => {
+    if (data.type === "link" || data.type === "project") return !!data.uri;
+    if (data.type === "base64") return !!data.data;
+    return false;
+  },
+  {
+    message: "uri is required when type='link' or type='project', data is required when type='base64'"
+  }
+);
+const shareToUserRespondSchema = z.object({
+  sharePath: z.string().optional().describe(
+    "Relative path in the session's share directory. Present when type is 'link' or 'base64'."
+  ),
+  projectPath: z.string().optional().describe("Relative path within the project directory. Present when type is 'project'."),
+  name: z.string().describe("Original filename of the shared file."),
+  mimeType: z.string().optional().describe("MIME type (e.g. 'image/png', 'application/pdf').")
+});
+function getArg(name) {
+  const idx = process.argv.indexOf(`--${name}`);
+  return idx !== -1 ? process.argv[idx + 1] : void 0;
+}
+const socketPath = getArg("socket-path");
+const projectDir = getArg("project-dir");
+if (!socketPath) {
+  console.error("[mcp-share-to-user] Missing required argument: --socket-path");
+  process.exit(1);
+}
+if (!projectDir) {
+  console.error("[mcp-share-to-user] Missing required argument: --project-dir");
+  process.exit(1);
+}
+const server = new McpServer({
+  name: "Share to User",
+  version: "1.0.0",
+  description: "Share files (images, documents, etc.) directly to the user's chat area. Supports image preview and file cards."
+});
+server.registerTool(
+  "share_to_user",
+  {
+    description: `Share a file to the user's chat area for them to see. Supports images (with preview), PDFs, documents, and any file type (shown as a file card).
+Provide the file as a file:// URI, https:// URL, base64-encoded data, or a project-relative path (zero-copy).`,
+    inputSchema: shareToUserRequestSchema
+  },
+  async (input) => {
+    try {
+      const result = shareToUserRespondSchema.parse(
+        await postToSocket("/share-to-user/share", input)
+      );
+      const respond = { name: result.name };
+      if (result.sharePath) respond.sharePath = result.sharePath;
+      if (result.projectPath) respond.projectPath = result.projectPath;
+      if (result.mimeType) respond.mimeType = result.mimeType;
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ ok: true, fello: { "share-to-user": respond } }, null, 2)
+          }
+        ]
+      };
+    } catch (err) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ ok: false, error: err.message || String(err) }, null, 2)
+          }
+        ],
+        isError: true
+      };
+    }
+  }
+);
+function postToSocket(path, body) {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const options = {
+      socketPath,
+      path,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(data)
+      }
+    };
+    const req = http.request(options, (res) => {
+      const chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => {
+        const raw = Buffer.concat(chunks).toString("utf8");
+        try {
+          const parsed = JSON.parse(raw);
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(parsed);
+          } else {
+            reject(new Error(parsed.error || `HTTP ${res.statusCode}: ${raw}`));
+          }
+        } catch {
+          reject(new Error(`Invalid response (${res.statusCode}): ${raw}`));
+        }
+      });
+    });
+    req.on("error", (err) => {
+      reject(new Error(`Socket request failed: ${err.message}`));
+    });
+    req.write(data);
+    req.end();
+  });
+}
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch(console.error);

package/out/scripts/worker-file-outline/worker.mjs

@@ -0,0 +1,235 @@
+import { existsSync, readFileSync } from "fs";
+import { Parser, Language } from "web-tree-sitter";
+function scanName(cursor, nameOf) {
+  if (!cursor.gotoFirstChild()) return "";
+  const idTypes = new Set(nameOf.identifierTypes || []);
+  const recTypes = new Set(nameOf.recurseTypes || []);
+  const rawTypes = new Set(nameOf.rawTextTypes || []);
+  let name = "";
+  do {
+    for (const field of nameOf.fieldPriority || []) {
+      if (cursor.currentFieldName === field) {
+        name = cursor.nodeText;
+        break;
+      }
+    }
+    if (name) break;
+    const t = cursor.nodeType;
+    if (!name && rawTypes.has(t)) {
+      name = cursor.nodeText;
+    }
+    if (!name && recTypes.has(t)) {
+      name = scanName(cursor, nameOf);
+    }
+    if (!name && idTypes.has(t)) {
+      if (t !== "type_identifier" || cursor.currentFieldName !== "type") {
+        name = cursor.nodeText;
+      }
+    }
+  } while (cursor.gotoNextSibling());
+  cursor.gotoParent();
+  return name;
+}
+function isPythonDocstring(cursor) {
+  if (cursor.nodeType !== "expression_statement") return false;
+  const text = cursor.nodeText.trim();
+  return text.startsWith('"""') || text.startsWith("'''");
+}
+function collectComments(tree) {
+  const comments = [];
+  const cursor = tree.walk();
+  let descend = true;
+  try {
+    while (true) {
+      if (cursor.currentDepth < 0) break;
+      const t = cursor.nodeType;
+      if (t === "comment" || t === "line_comment" || t === "multiline_comment" || isPythonDocstring(cursor)) {
+        comments.push({
+          text: cursor.nodeText.trim(),
+          startLine: cursor.startPosition.row + 1,
+          endLine: cursor.endPosition.row + 1
+        });
+      }
+      if (descend && cursor.gotoFirstChild()) continue;
+      if (cursor.gotoNextSibling()) {
+        descend = true;
+        continue;
+      }
+      if (cursor.currentDepth > 0 && cursor.gotoParent()) {
+        descend = false;
+        continue;
+      }
+      break;
+    }
+  } finally {
+    cursor.delete();
+  }
+  return comments;
+}
+function cleanComment(text) {
+  let cleaned = text.replace(/^\/\*\*?/, "").replace(/\*\/$/, "").replace(/^\s*\* ?/gm, "").replace(/^\/+/, "").replace(/^#/, "").replace(/^'''/, "").replace(/'''$/, "").replace(/^"""/, "").replace(/"""$/, "").trim();
+  const lines = cleaned.split("\n").map((l) => l.trim()).filter(Boolean);
+  return lines.length > 0 ? lines[0] : "";
+}
+function attachComments(symbols, comments) {
+  let ci = 0;
+  for (const sym of symbols) {
+    if (sym.depth > 0) continue;
+    while (ci < comments.length && comments[ci].endLine < sym.startLine - 2) ci++;
+    if (ci < comments.length) {
+      const c = comments[ci];
+      const gap = sym.startLine - c.endLine;
+      if (gap === 1 || gap === 2) {
+        sym.comment = cleanComment(c.text);
+        continue;
+      }
+    }
+    const inner = comments.find((c) => {
+      const startsAfter = c.startLine >= sym.startLine + 1;
+      const closeToStart = c.startLine <= sym.startLine + 3;
+      const inside = c.startLine < sym.endLine;
+      return startsAfter && closeToStart && inside;
+    });
+    if (inner) {
+      sym.comment = cleanComment(inner.text);
+    }
+  }
+}
+async function parse(req) {
+  await Parser.init();
+  if (!existsSync(req.wasmFile)) throw new Error(`Grammar not found: ${req.wasmFile}`);
+  const lang = await Language.load(req.wasmFile);
+  const parser = new Parser();
+  parser.setLanguage(lang);
+  const source = readFileSync(req.filePath, "utf8");
+  const totalLines = source.split("\n").length;
+  const tree = parser.parse(source);
+  if (!tree) throw new Error("Failed to parse");
+  let result = [];
+  const typeSet = new Set(req.symbols.flatMap((s) => s.types));
+  const cursor = tree.walk();
+  try {
+    let descend = true, declDepth = -1;
+    while (true) {
+      if (cursor.currentDepth < 0) break;
+      const t = cursor.nodeType;
+      const isDecl = typeSet.has(t);
+      if (descend && isDecl) declDepth++;
+      else if (!descend && isDecl) declDepth--;
+      if (descend && isDecl) {
+        for (const sym of req.symbols) {
+          if (sym.types.includes(t) && (sym.maxDepth === void 0 || declDepth <= sym.maxDepth)) {
+            let name = "";
+            if (sym.hasName) name = scanName(cursor, req.nameOf);
+            result.push({
+              kind: sym.label,
+              name: sym.hasName ? name || `(anonymous ${sym.label})` : "",
+              startLine: cursor.startPosition.row + 1,
+              endLine: cursor.endPosition.row + 1,
+              depth: declDepth
+            });
+            break;
+          }
+        }
+      }
+      if (descend && cursor.gotoFirstChild()) continue;
+      if (cursor.gotoNextSibling()) {
+        descend = true;
+        continue;
+      }
+      if (cursor.currentDepth > 0 && cursor.gotoParent()) {
+        descend = false;
+        continue;
+      }
+      break;
+    }
+    result.sort((a, b) => a.startLine - b.startLine);
+    if (req.wrappers?.length) {
+      const appliedPrefixes = /* @__PURE__ */ new Set();
+      for (const wrapper of req.wrappers) {
+        const wCursor = tree.walk();
+        try {
+          let descend2 = true;
+          while (true) {
+            if (wCursor.currentDepth < 0) break;
+            if (descend2 && wCursor.nodeType === wrapper.node) {
+              const wStart = wCursor.startPosition.row + 1;
+              const wEnd = wCursor.endPosition.row + 1;
+              const maxDepth = wrapper.maxDepth ?? Infinity;
+              const covered = result.some(
+                (r) => r.startLine >= wStart && r.endLine <= wEnd && r.depth <= maxDepth
+              );
+              if (covered) {
+                for (const r of result) {
+                  if (r.startLine >= wStart && r.endLine <= wEnd && r.depth <= maxDepth) {
+                    const isStandalone = req.wrappers.some(
+                      (w) => w.createStandaloneLabel && r.kind === w.createStandaloneLabel
+                    );
+                    if (isStandalone) {
+                      r.depth = 1;
+                      continue;
+                    }
+                    if (r.kind.startsWith(wrapper.prefix)) continue;
+                    let inserted = false;
+                    for (const existing of appliedPrefixes) {
+                      if (r.kind.startsWith(existing)) {
+                        r.kind = existing + wrapper.prefix + r.kind.slice(existing.length);
+                        inserted = true;
+                        break;
+                      }
+                    }
+                    if (!inserted) {
+                      r.kind = wrapper.prefix + r.kind;
+                    }
+                  }
+                }
+              } else if (wrapper.createStandaloneLabel) {
+                const exportName = scanName(wCursor, req.nameOf);
+                result.push({
+                  kind: wrapper.createStandaloneLabel,
+                  name: exportName || "{...}",
+                  startLine: wStart,
+                  endLine: wEnd,
+                  depth: 0
+                });
+              }
+            }
+            if (descend2 && wCursor.gotoFirstChild()) continue;
+            if (wCursor.gotoNextSibling()) {
+              descend2 = true;
+              continue;
+            }
+            if (wCursor.currentDepth > 0 && wCursor.gotoParent()) {
+              descend2 = false;
+              continue;
+            }
+            break;
+          }
+        } finally {
+          wCursor.delete();
+        }
+        appliedPrefixes.add(wrapper.prefix);
+      }
+    }
+    result.sort((a, b) => a.startLine - b.startLine);
+    const comments = collectComments(tree);
+    attachComments(result, comments);
+    return { symbols: result, totalLines };
+  } finally {
+    cursor.delete();
+    tree.delete();
+  }
+}
+process.once("message", async (msg) => {
+  try {
+    const { symbols, totalLines } = await parse(msg);
+    const response = { type: "result", symbols, totalLines };
+    process.send(response, () => process.exit(0));
+  } catch (e) {
+    const response = {
+      type: "error",
+      error: e instanceof Error ? e.message : String(e)
+    };
+    process.send(response, () => process.exit(1));
+  }
+});

package/out/scripts/worker-ripgrep/worker.mjs

@@ -0,0 +1,22 @@
+import { ripgrep } from "ripgrep";
+process.once("message", async (msg) => {
+  try {
+    const { code, stdout, stderr } = await ripgrep(msg.args, {
+      buffer: true,
+      preopens: { ".": msg.cwd }
+    });
+    const response = {
+      type: "result",
+      code,
+      stdout: stdout || "",
+      stderr: stderr || ""
+    };
+    process.send(response, () => process.exit(0));
+  } catch (e) {
+    const response = {
+      type: "error",
+      error: e instanceof Error ? e.message : String(e)
+    };
+    process.send(response, () => process.exit(1));
+  }
+});