fix(kernel): exec() falls back to node when sh is unavailable

Fixes #64 — exec() throws 'No shell available' when only NodeRuntime is
mounted (which registers 'node', not 'sh').

Before this change:
  createKernel() → mount(createNodeRuntime())
  kernel.exec('node -e "console.log(1)"')  // throws: No shell available

After this change:
  - If 'sh' is registered: routes through shell (existing behavior)
  - If only 'node' is registered: parses command string, strips 'node'
    prefix, spawns node directly with remaining args
  - If neither: throws improved error with actionable guidance

Added:
- #parseCommandArgs(): shell-like tokenizer (handles '...', "..." escapes)
- #collectExecResult(): extracted common stdout/stderr collection logic
- 3 new test cases in kernel-integration.test.ts

Author: aayushprsingh

packages/core/src/kernel/kernel.ts

@@ -303,14 +303,99 @@ class KernelImpl implements Kernel {
 
 		// Route through shell
 		const shell = this.commandRegistry.resolve("sh");
-		if (!shell) {
-			throw new Error(
-				"No shell available. Mount a WasmVM runtime to enable exec().",
-			);
+		if (shell) {
+			const proc = this.spawnInternal("sh", ["-c", command], options);
+			return this.#collectExecResult(proc, options);
 		}
 
-		const proc = this.spawnInternal("sh", ["-c", command], options);
+		// No shell available. If 'node' is registered (e.g. NodeRuntime mounted),
+		// fall back to direct node execution — parse command string into node args.
+		// This makes the README example work out-of-the-box:
+		//   kernel.exec("node -e \"console.log('hello')\"")
+		const nodeCmd = this.commandRegistry.resolve("node");
+		if (nodeCmd) {
+			// Parse command string into individual args (handles quotes)
+			const args = this.#parseCommandArgs(command);
+			if (args.length > 0 && args[0] === "node") {
+				args.shift(); // strip 'node' prefix, keep the rest
+				const proc = this.spawnInternal("node", args, options);
+				return this.#collectExecResult(proc, options);
+			}
+		}
+
+		throw new Error(
+			"No shell available. Mount a WasmVM runtime to enable exec(), " +
+			"or mount a runtime that registers the 'node' command and use " +
+			"`kernel.exec('node -e \"code\"')`.",
+		);
+	}
+
+	/**
+	 * Parse a command string into individual arguments.
+	 * Handles single quotes, double quotes, and basic shell tokenization.
+	 */
+	#parseCommandArgs(command: string): string[] {
+		const args: string[] = [];
+		let current = "";
+		let inSingle = false;
+		let inDouble = false;
+		let i = 0;
+
+		while (i < command.length) {
+			const ch = command[i];
+
+			if (inSingle) {
+				if (ch === "'") {
+					inSingle = false;
+				} else {
+					current += ch;
+				}
+				i++;
+			} else if (inDouble) {
+				if (ch === '"') {
+					inDouble = false;
+				} else if (ch === "\\" && i + 1 < command.length) {
+					// Handle escape sequences in double quotes
+					current += command[i + 1];
+					i += 2;
+				} else {
+					current += ch;
+					i++;
+				}
+			} else {
+				if (ch === "'") {
+					inSingle = true;
+					i++;
+				} else if (ch === '"') {
+					inDouble = true;
+					i++;
+				} else if (ch === " ") {
+					if (current.length > 0) {
+						args.push(current);
+						current = "";
+					}
+					i++;
+				} else {
+					current += ch;
+					i++;
+				}
+			}
+		}
+
+		if (current.length > 0) {
+			args.push(current);
+		}
+
+		return args;
+	}
 
+	/**
+	 * Collect stdout/stderr from a spawned process for exec().
+	 */
+	async #collectExecResult(
+		proc: InternalProcess,
+		options?: ExecOptions,
+	): Promise<ExecResult> {
 		// Write stdin if provided
 		if (options?.stdin) {
 			const data =
@@ -347,7 +432,7 @@ class KernelImpl implements Kernel {
 					new Promise<number>((_, reject) => {
 						timer = setTimeout(() => {
 							// Kill process and detach output callbacks
-							this.log.warn({ command, timeout: options.timeout }, "exec timeout, sending SIGTERM");
+							this.log.warn({ timeout: options.timeout }, "exec timeout, sending SIGTERM");
 							proc.onStdout = null;
 							proc.onStderr = null;
 							proc.kill(SIGTERM);

packages/core/test/kernel/kernel-integration.test.ts

@@ -71,6 +71,43 @@ describe("kernel + MockRuntimeDriver integration", () => {
 		expect(result.stderr).toBe("warn\n");
 	});
 
+	it("exec falls back to node when sh is not available", async () => {
+		// NodeRuntime only registers 'node', not 'sh'.
+		// exec() should detect this and route through node directly.
+		// This is the fix for: https://github.com/rivet-dev/secure-exec/issues/64
+		const driver = new MockRuntimeDriver(["node"], {
+			node: {
+				exitCode: 0,
+				stdout: "hello from node\n",
+				stderr: "",
+				// args are passed as-is; for node -e "code", args = ["-e", "code"]
+			},
+		});
+		({ kernel } = await createTestKernel({ drivers: [driver] }));
+
+		const result = await kernel.exec("node -e \"console.log('hello from node')\"");
+		expect(result.exitCode).toBe(0);
+		expect(result.stdout).toBe("hello from node\n");
+	});
+
+	it("exec of node command with single-quoted code", async () => {
+		const driver = new MockRuntimeDriver(["node"], {
+			node: { exitCode: 0, stdout: "42\n" },
+		});
+		({ kernel } = await createTestKernel({ drivers: [driver] }));
+
+		const result = await kernel.exec("node -e 'console.log(42)'");
+		expect(result.exitCode).toBe(0);
+		expect(result.stdout).toBe("42\n");
+	});
+
+	it("exec throws descriptive error when neither sh nor node is available", async () => {
+		// No drivers registered — neither sh nor node
+		({ kernel } = await createTestKernel({ drivers: [] }));
+
+		await expect(kernel.exec("echo hello")).rejects.toThrow("No shell available");
+	});
+
 	it("exec of unknown command throws ENOENT", async () => {
 		const driver = new MockRuntimeDriver(["sh"], { sh: { exitCode: 0 } });
 		({ kernel } = await createTestKernel({ drivers: [driver] }));