agent-yes 1.68.0 → 1.68.2

package/dist/{SUPPORTED_CLIS-Cl2oCgKo.js → SUPPORTED_CLIS-lTQa7aYE.js}

@@ -1059,7 +1059,7 @@ function tryCatch(catchFn, fn) {
 //#endregion
 //#region package.json
 var name = "agent-yes";
-var version = "1.68.0";
+var version = "1.68.2";
 
 //#endregion
 //#region ts/pty-fix.ts
@@ -2139,4 +2139,4 @@ const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
 
 //#endregion
 export { AgentContext as a, PidStore as c, config as i, removeControlCharacters as l, CLIS_CONFIG as n, name as o, agentYes as r, version as s, SUPPORTED_CLIS as t };
-//# sourceMappingURL=SUPPORTED_CLIS-Cl2oCgKo.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-lTQa7aYE.js.map

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { c as PidStore, o as name, s as version, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-Cl2oCgKo.js";
+import { c as PidStore, o as name, s as version, t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-lTQa7aYE.js";
 import { t as logger } from "./logger-CX77vJDA.js";
 import { argv } from "process";
 import { spawn } from "child_process";
@@ -467,7 +467,7 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 	const rawRustArgs = argv.slice(2).filter((arg) => arg !== "--rust" && !arg.startsWith("--rust="));
 	const hasSwarmArg = rawRustArgs.some((arg) => arg === "--swarm" || arg.startsWith("--swarm="));
 	const hasCliArg = rawRustArgs.some((arg) => arg.startsWith("--cli=") || arg === "--cli") || rawRustArgs.some((arg) => supportedClis.includes(arg));
-	if (cliFromScript && !hasCliArg && !hasSwarmArg) return [...rawRustArgs, cliFromScript];
+	if (cliFromScript && !hasCliArg && !hasSwarmArg) return [`--cli=${cliFromScript}`, ...rawRustArgs];
 	return rawRustArgs;
 }
 
@@ -480,31 +480,35 @@ if (config.useRust) {
 	try {
 		rustBinary = await getRustBinary({ verbose: config.verbose });
 	} catch (err) {
-		console.error(err instanceof Error ? err.message : String(err));
-		process.exit(1);
+		if (config.verbose) {
+			console.error(`[rust] ${err instanceof Error ? err.message : String(err)}`);
+			console.error("[rust] Falling back to TypeScript implementation.");
+		}
 	}
-	const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
-	if (config.verbose) {
-		console.log(`[rust] Using binary: ${rustBinary}`);
-		console.log(`[rust] Args: ${rustArgs.join(" ")}`);
+	if (rustBinary) {
+		const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
+		if (config.verbose) {
+			console.log(`[rust] Using binary: ${rustBinary}`);
+			console.log(`[rust] Args: ${rustArgs.join(" ")}`);
+		}
+		const child = spawn(rustBinary, rustArgs, {
+			stdio: "inherit",
+			env: process.env,
+			cwd: process.cwd()
+		});
+		child.on("error", (err) => {
+			if (err.code === "ENOENT") console.error(`Rust binary '${rustBinary}' not found. Try: npx agent-yes --rust --verbose`);
+			else console.error(`Failed to spawn Rust binary: ${err.message}`);
+			process.exit(1);
+		});
+		child.on("exit", (code, signal) => {
+			if (signal) process.exit(128 + (signal === "SIGINT" ? 2 : signal === "SIGTERM" ? 15 : 1));
+			process.exit(code ?? 1);
+		});
+		process.on("SIGINT", () => child.kill("SIGINT"));
+		process.on("SIGTERM", () => child.kill("SIGTERM"));
+		await new Promise(() => {});
 	}
-	const child = spawn(rustBinary, rustArgs, {
-		stdio: "inherit",
-		env: process.env,
-		cwd: process.cwd()
-	});
-	child.on("error", (err) => {
-		if (err.code === "ENOENT") console.error(`Rust binary '${rustBinary}' not found. Try: npx agent-yes --rust --verbose`);
-		else console.error(`Failed to spawn Rust binary: ${err.message}`);
-		process.exit(1);
-	});
-	child.on("exit", (code, signal) => {
-		if (signal) process.exit(128 + (signal === "SIGINT" ? 2 : signal === "SIGTERM" ? 15 : 1));
-		process.exit(code ?? 1);
-	});
-	process.on("SIGINT", () => child.kill("SIGINT"));
-	process.on("SIGTERM", () => child.kill("SIGTERM"));
-	await new Promise(() => {});
 }
 if (config.showVersion) {
 	await displayVersion();

package/dist/index.js

@@ -1,4 +1,4 @@
-import { a as AgentContext, i as config, l as removeControlCharacters, n as CLIS_CONFIG, r as agentYes } from "./SUPPORTED_CLIS-Cl2oCgKo.js";
+import { a as AgentContext, i as config, l as removeControlCharacters, n as CLIS_CONFIG, r as agentYes } from "./SUPPORTED_CLIS-lTQa7aYE.js";
 import "./logger-CX77vJDA.js";
 
 export { AgentContext, CLIS_CONFIG, config, agentYes as default, removeControlCharacters };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.68.0",
+  "version": "1.68.2",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",

package/ts/buildRustArgs.spec.ts

@@ -21,70 +21,60 @@ function argv(...userArgs: string[]): string[] {
 }
 
 describe("buildRustArgs", () => {
-  // ─── Core: CLI name positioning ────────────────────────────────────
-  // The CLI name MUST appear after all flags to avoid clap's trailing_var_arg
-  // swallowing named flags as positional args.
+  // ─── Core: CLI name passed via --cli= flag ─────────────────────────
+  // The CLI name is passed via --cli= flag at the start, so it doesn't
+  // get mixed with trailing positional args (which are prompt text).
 
-  describe("CLI name is always appended at the end (not prepended)", () => {
-    it("appends CLI name after flags", () => {
+  describe("CLI name is passed via --cli= flag", () => {
+    it("prepends --cli= flag before other args", () => {
       const result = buildRustArgs(argv("--timeout", "1h"), "claude", SUPPORTED_CLIS);
-      expect(result).toEqual(["--timeout", "1h", "claude"]);
+      expect(result).toEqual(["--cli=claude", "--timeout", "1h"]);
     });
 
-    it("appends CLI name after multiple flags", () => {
+    it("prepends --cli= flag before multiple flags", () => {
       const result = buildRustArgs(
         argv("--timeout", "30s", "--verbose", "--robust", "true"),
         "claude",
         SUPPORTED_CLIS,
       );
-      expect(result).toEqual(["--timeout", "30s", "--verbose", "--robust", "true", "claude"]);
+      expect(result).toEqual(["--cli=claude", "--timeout", "30s", "--verbose", "--robust", "true"]);
     });
 
-    it("CLI name is the last element", () => {
+    it("--cli= is the first element", () => {
       const result = buildRustArgs(argv("--timeout", "5m"), "codex", SUPPORTED_CLIS);
-      expect(result[result.length - 1]).toBe("codex");
+      expect(result[0]).toBe("--cli=codex");
     });
   });
 
-  // ─── The original bug: --timeout swallowed by trailing_var_arg ─────
+  // ─── Regression: flags must not be swallowed ───────────────────────
 
-  describe("regression: flags must not be swallowed by CLI name position", () => {
-    it("--timeout is preserved before CLI name (the original bug)", () => {
+  describe("regression: flags are preserved alongside --cli=", () => {
+    it("--timeout is preserved", () => {
       const result = buildRustArgs(argv("--timeout", "1h"), "claude", SUPPORTED_CLIS);
-      const timeoutIdx = result.indexOf("--timeout");
-      const cliIdx = result.indexOf("claude");
-      expect(timeoutIdx).toBeGreaterThanOrEqual(0);
-      expect(cliIdx).toBeGreaterThan(timeoutIdx);
+      expect(result).toContain("--timeout");
+      expect(result).toContain("1h");
     });
 
-    it("--verbose is preserved before CLI name", () => {
+    it("--verbose is preserved", () => {
       const result = buildRustArgs(argv("--verbose"), "claude", SUPPORTED_CLIS);
-      const verboseIdx = result.indexOf("--verbose");
-      const cliIdx = result.indexOf("claude");
-      expect(verboseIdx).toBeGreaterThanOrEqual(0);
-      expect(cliIdx).toBeGreaterThan(verboseIdx);
+      expect(result).toContain("--verbose");
     });
 
-    it("-c (continue) flag is preserved before CLI name", () => {
+    it("-c (continue) flag is preserved", () => {
       const result = buildRustArgs(argv("-c"), "claude", SUPPORTED_CLIS);
-      expect(result.indexOf("-c")).toBeLessThan(result.indexOf("claude"));
-    });
-
-    it("--robust flag is preserved before CLI name", () => {
-      const result = buildRustArgs(argv("--robust", "true"), "gemini", SUPPORTED_CLIS);
-      expect(result.indexOf("--robust")).toBeLessThan(result.indexOf("gemini"));
+      expect(result).toContain("-c");
     });
 
-    it("all flags come before CLI name in complex invocation", () => {
+    it("all flags are preserved in complex invocation", () => {
       const result = buildRustArgs(
         argv("--timeout", "1h", "--verbose", "-c", "--robust", "true"),
         "claude",
         SUPPORTED_CLIS,
       );
-      const cliIdx = result.indexOf("claude");
       for (const flag of ["--timeout", "--verbose", "-c", "--robust"]) {
-        expect(result.indexOf(flag)).toBeLessThan(cliIdx);
+        expect(result).toContain(flag);
       }
+      expect(result[0]).toBe("--cli=claude");
     });
   });
 
@@ -110,43 +100,43 @@ describe("buildRustArgs", () => {
         SUPPORTED_CLIS,
       );
       expect(result).not.toContain("--rust");
-      expect(result).toEqual(["--verbose", "--timeout", "5m", "claude"]);
+      expect(result).toEqual(["--cli=claude", "--verbose", "--timeout", "5m"]);
     });
   });
 
   // ─── CLI name detection in args ────────────────────────────────────
 
   describe("does not duplicate CLI name if already in args", () => {
-    it("skips appending when CLI name is already a positional arg", () => {
+    it("skips --cli= when CLI name is already a positional arg", () => {
       const result = buildRustArgs(argv("--timeout", "30s", "claude"), "claude", SUPPORTED_CLIS);
       expect(result).toEqual(["--timeout", "30s", "claude"]);
-      expect(result.filter((a) => a === "claude")).toHaveLength(1);
+      expect(result.filter((a) => a.includes("claude"))).toHaveLength(1);
     });
 
-    it("skips appending when --cli= flag is used", () => {
+    it("skips --cli= when --cli= flag is already used", () => {
       const result = buildRustArgs(
         argv("--cli=gemini", "--timeout", "30s"),
         "claude",
         SUPPORTED_CLIS,
       );
       expect(result).toEqual(["--cli=gemini", "--timeout", "30s"]);
-      expect(result).not.toContain("claude");
+      expect(result).not.toContain("--cli=claude");
     });
 
-    it("skips appending when --cli flag is used (separate value)", () => {
+    it("skips --cli= when --cli flag is used (separate value)", () => {
       const result = buildRustArgs(
         argv("--cli", "gemini", "--timeout", "30s"),
         "claude",
         SUPPORTED_CLIS,
       );
       expect(result).toEqual(["--cli", "gemini", "--timeout", "30s"]);
-      expect(result).not.toContain("claude");
+      expect(result).not.toContain("--cli=claude");
     });
 
     it("detects any supported CLI name in args", () => {
       for (const cli of ["gemini", "codex", "copilot", "cursor", "grok"]) {
         const result = buildRustArgs(argv("--timeout", "1m", cli), "claude", SUPPORTED_CLIS);
-        expect(result).not.toContain("claude");
+        expect(result).not.toContain("--cli=claude");
         expect(result).toContain(cli);
       }
     });
@@ -155,22 +145,22 @@ describe("buildRustArgs", () => {
   // ─── Swarm mode ────────────────────────────────────────────────────
 
   describe("swarm mode skips CLI name", () => {
-    it("does not append CLI name when --swarm is present", () => {
+    it("does not add --cli= when --swarm is present", () => {
       const result = buildRustArgs(argv("--swarm", "my-topic"), "claude", SUPPORTED_CLIS);
       expect(result).toEqual(["--swarm", "my-topic"]);
-      expect(result).not.toContain("claude");
+      expect(result).not.toContain("--cli=claude");
     });
 
-    it("does not append CLI name when --swarm= is present", () => {
+    it("does not add --cli= when --swarm= is present", () => {
       const result = buildRustArgs(argv("--swarm=my-topic"), "claude", SUPPORTED_CLIS);
       expect(result).toEqual(["--swarm=my-topic"]);
-      expect(result).not.toContain("claude");
+      expect(result).not.toContain("--cli=claude");
     });
 
-    it("does not append CLI name for bare --swarm", () => {
+    it("does not add --cli= for bare --swarm", () => {
       const result = buildRustArgs(argv("--swarm"), "claude", SUPPORTED_CLIS);
       expect(result).toEqual(["--swarm"]);
-      expect(result).not.toContain("claude");
+      expect(result).not.toContain("--cli=claude");
     });
   });
 
@@ -193,7 +183,7 @@ describe("buildRustArgs", () => {
   describe("edge cases", () => {
     it("handles no user args at all", () => {
       const result = buildRustArgs(["node", "/path/to/claude-yes"], "claude", SUPPORTED_CLIS);
-      expect(result).toEqual(["claude"]);
+      expect(result).toEqual(["--cli=claude"]);
     });
 
     it("handles -- prompt separator correctly", () => {
@@ -202,38 +192,44 @@ describe("buildRustArgs", () => {
         "claude",
         SUPPORTED_CLIS,
       );
-      expect(result).toEqual(["--timeout", "1h", "--", "do", "the", "thing", "claude"]);
-      expect(result.indexOf("--timeout")).toBeLessThan(result.lastIndexOf("claude"));
+      expect(result).toEqual(["--cli=claude", "--timeout", "1h", "--", "do", "the", "thing"]);
     });
 
     it("handles -p prompt flag", () => {
       const result = buildRustArgs(argv("-p", "hello world"), "claude", SUPPORTED_CLIS);
-      expect(result).toEqual(["-p", "hello world", "claude"]);
+      expect(result).toEqual(["--cli=claude", "-p", "hello world"]);
     });
 
     it("preserves args with hyphen values (e.g. negative numbers)", () => {
       const result = buildRustArgs(argv("--some-flag", "-1"), "claude", SUPPORTED_CLIS);
-      expect(result).toEqual(["--some-flag", "-1", "claude"]);
+      expect(result).toEqual(["--cli=claude", "--some-flag", "-1"]);
     });
 
     it("handles multiple --rust flags (all filtered)", () => {
       const result = buildRustArgs(argv("--rust", "--rust", "--verbose"), "claude", SUPPORTED_CLIS);
-      expect(result).toEqual(["--verbose", "claude"]);
+      expect(result).toEqual(["--cli=claude", "--verbose"]);
     });
 
     it("does not treat --swarm-topic as --swarm", () => {
       const result = buildRustArgs(argv("--swarm-topic", "my-topic"), "claude", SUPPORTED_CLIS);
-      // --swarm-topic is NOT --swarm, so CLI name should still be appended
-      expect(result).toContain("claude");
+      // --swarm-topic is NOT --swarm, so --cli= should still be added
+      expect(result[0]).toBe("--cli=claude");
     });
 
     it("does not treat --cli-like strings inside values as CLI names", () => {
-      // e.g. --prompt "use claude to ..." should not detect "claude" as a CLI arg
-      // because "use claude to ..." is a value, not a standalone arg
       const result = buildRustArgs(argv("-p", "use claude to fix"), undefined, SUPPORTED_CLIS);
-      // "claude" appears inside a value, but since cliFromScript is undefined, nothing appended
+      // "claude" appears inside a value, but since cliFromScript is undefined, nothing added
       expect(result).toEqual(["-p", "use claude to fix"]);
     });
+
+    it("bare words (prompt without --) are passed through for Rust to handle", () => {
+      const result = buildRustArgs(
+        argv("rebuild", "and", "analyze", "problems"),
+        "claude",
+        SUPPORTED_CLIS,
+      );
+      expect(result).toEqual(["--cli=claude", "rebuild", "and", "analyze", "problems"]);
+    });
   });
 
   // ─── Real-world command scenarios ──────────────────────────────────
@@ -241,7 +237,7 @@ describe("buildRustArgs", () => {
   describe("real-world scenarios", () => {
     it("claude-yes --rust --timeout 1h (the original failing case)", () => {
       const result = buildRustArgs(argv("--rust", "--timeout", "1h"), "claude", SUPPORTED_CLIS);
-      expect(result).toEqual(["--timeout", "1h", "claude"]);
+      expect(result).toEqual(["--cli=claude", "--timeout", "1h"]);
     });
 
     it("claude-yes --rust --timeout 30s --verbose", () => {
@@ -250,12 +246,12 @@ describe("buildRustArgs", () => {
         "claude",
         SUPPORTED_CLIS,
       );
-      expect(result).toEqual(["--timeout", "30s", "--verbose", "claude"]);
+      expect(result).toEqual(["--cli=claude", "--timeout", "30s", "--verbose"]);
     });
 
     it("claude-yes --rust -c (continue session)", () => {
       const result = buildRustArgs(argv("--rust", "-c"), "claude", SUPPORTED_CLIS);
-      expect(result).toEqual(["-c", "claude"]);
+      expect(result).toEqual(["--cli=claude", "-c"]);
     });
 
     it("codex-yes --rust --timeout 5m -- fix all bugs", () => {
@@ -264,7 +260,7 @@ describe("buildRustArgs", () => {
         "codex",
         SUPPORTED_CLIS,
       );
-      expect(result).toEqual(["--timeout", "5m", "--", "fix", "all", "bugs", "codex"]);
+      expect(result).toEqual(["--cli=codex", "--timeout", "5m", "--", "fix", "all", "bugs"]);
     });
 
     it("agent-yes --rust claude --timeout 1h (explicit CLI in args)", () => {
@@ -283,9 +279,9 @@ describe("buildRustArgs", () => {
         "claude",
         SUPPORTED_CLIS,
       );
-      // Swarm mode: no CLI name appended
+      // Swarm mode: no CLI name added
       expect(result).toEqual(["--swarm", "my-project", "--timeout", "1h"]);
-      expect(result).not.toContain("claude");
+      expect(result).not.toContain("--cli=claude");
     });
 
     it("gemini-yes --rust --timeout 2m --verbose -p 'hello'", () => {
@@ -294,7 +290,7 @@ describe("buildRustArgs", () => {
         "gemini",
         SUPPORTED_CLIS,
       );
-      expect(result).toEqual(["--timeout", "2m", "--verbose", "-p", "hello", "gemini"]);
+      expect(result).toEqual(["--cli=gemini", "--timeout", "2m", "--verbose", "-p", "hello"]);
     });
 
     it("claude-yes --rust --auto=no --timeout 10m", () => {
@@ -303,7 +299,17 @@ describe("buildRustArgs", () => {
         "claude",
         SUPPORTED_CLIS,
       );
-      expect(result).toEqual(["--auto=no", "--timeout", "10m", "claude"]);
+      expect(result).toEqual(["--cli=claude", "--auto=no", "--timeout", "10m"]);
+    });
+
+    it("cy rebuild and analyze problems (bare prompt words)", () => {
+      const result = buildRustArgs(
+        argv("rebuild", "and", "analyze", "problems"),
+        "claude",
+        SUPPORTED_CLIS,
+      );
+      // CLI passed via --cli=, bare words passed through for Rust to interpret as prompt
+      expect(result).toEqual(["--cli=claude", "rebuild", "and", "analyze", "problems"]);
     });
   });
 });

package/ts/buildRustArgs.ts

@@ -23,10 +23,10 @@ export function buildRustArgs(
     rawRustArgs.some((arg) => arg.startsWith("--cli=") || arg === "--cli") ||
     rawRustArgs.some((arg) => supportedClis.includes(arg));
 
-  // Append CLI name at the end so it doesn't trigger trailing_var_arg in clap,
-  // which would cause all subsequent args (like --timeout) to be treated as positional
+  // Pass CLI name via --cli= flag so it doesn't get mixed with trailing positional args
+  // (which are treated as prompt text or cli args for the target tool)
   if (cliFromScript && !hasCliArg && !hasSwarmArg) {
-    return [...rawRustArgs, cliFromScript];
+    return [`--cli=${cliFromScript}`, ...rawRustArgs];
   }
 
   return rawRustArgs;

package/ts/cli.ts

@@ -15,55 +15,55 @@ const updateCheckPromise = checkAndAutoUpdate();
 // Parse CLI arguments
 const config = parseCliArgs(process.argv);
 
-// Handle --rust: spawn the Rust binary instead
+// Handle --rust: spawn the Rust binary instead, fall back to TypeScript if unavailable
 if (config.useRust) {
-  let rustBinary: string;
+  let rustBinary: string | undefined;
 
   try {
-    // Get or download the Rust binary for the current platform
     rustBinary = await getRustBinary({ verbose: config.verbose });
   } catch (err) {
-    console.error(err instanceof Error ? err.message : String(err));
-    process.exit(1);
-  }
-
-  // Build args for Rust binary
-  const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
-
-  if (config.verbose) {
-    console.log(`[rust] Using binary: ${rustBinary}`);
-    console.log(`[rust] Args: ${rustArgs.join(" ")}`);
+    // Rust binary unavailable (not yet released for this version, or network issue) — fall back to TypeScript
+    if (config.verbose) {
+      console.error(`[rust] ${err instanceof Error ? err.message : String(err)}`);
+      console.error("[rust] Falling back to TypeScript implementation.");
+    }
   }
 
-  // Spawn the Rust process with stdio inheritance
-  const child = spawn(rustBinary, rustArgs, {
-    stdio: "inherit",
-    env: process.env,
-    cwd: process.cwd(),
-  });
+  if (rustBinary) {
+    const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
 
-  child.on("error", (err) => {
-    if ((err as NodeJS.ErrnoException).code === "ENOENT") {
-      console.error(`Rust binary '${rustBinary}' not found. Try: npx agent-yes --rust --verbose`);
-    } else {
-      console.error(`Failed to spawn Rust binary: ${err.message}`);
+    if (config.verbose) {
+      console.log(`[rust] Using binary: ${rustBinary}`);
+      console.log(`[rust] Args: ${rustArgs.join(" ")}`);
     }
-    process.exit(1);
-  });
-
-  child.on("exit", (code, signal) => {
-    if (signal) {
-      process.exit(128 + (signal === "SIGINT" ? 2 : signal === "SIGTERM" ? 15 : 1));
-    }
-    process.exit(code ?? 1);
-  });
 
-  // Forward signals to child
-  process.on("SIGINT", () => child.kill("SIGINT"));
-  process.on("SIGTERM", () => child.kill("SIGTERM"));
-
-  // Keep the process alive while child is running
-  await new Promise(() => {}); // Never resolves, exits via child.on("exit")
+    const child = spawn(rustBinary, rustArgs, {
+      stdio: "inherit",
+      env: process.env,
+      cwd: process.cwd(),
+    });
+
+    child.on("error", (err) => {
+      if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+        console.error(`Rust binary '${rustBinary}' not found. Try: npx agent-yes --rust --verbose`);
+      } else {
+        console.error(`Failed to spawn Rust binary: ${err.message}`);
+      }
+      process.exit(1);
+    });
+
+    child.on("exit", (code, signal) => {
+      if (signal) {
+        process.exit(128 + (signal === "SIGINT" ? 2 : signal === "SIGTERM" ? 15 : 1));
+      }
+      process.exit(code ?? 1);
+    });
+
+    process.on("SIGINT", () => child.kill("SIGINT"));
+    process.on("SIGTERM", () => child.kill("SIGTERM"));
+
+    await new Promise(() => {}); // Never resolves, exits via child.on("exit")
+  }
 }
 
 // Handle --version: display version and exit