refactor: replace Bun shell execution with portable Process utilities

[thdxr]

Summary

• Replace Bun.spawn with Process.lines() in MCP child process tree discovery
• Replace Bun.$ template literal shell execution with Process.text() in session prompt shell commands
• Both changes use existing portable Process utilities, removing direct Bun API dependencies

[greptile-apps]

Greptile Summary

This PR removes two direct Bun API dependencies (Bun.spawn in MCP and Bun.$ in session prompt) and replaces them with the existing portable Process utility. The MCP change is a clean, equivalent refactor. The session prompt change introduces a subtle but impactful issue.

• MCP (index.ts): Bun.spawn + manual stdout parsing replaced by Process.lines(). Functionally identical; Process.lines splits on \r?\n and filters empty strings, which correctly handles pgrep -P's one-PID-per-line output. A minor style improvement (!pids.includes() over pids.indexOf() === -1) is also included.
• Session prompt (prompt.ts): Bun.$\${{ raw: cmd }}`replaced byProcess.text([cmd], { shell: sh, nothrow: true }). The shell is obtained via Shell.preferred(), but Shell.preferred()does not filter out POSIX-incompatible shells —fishandnuare both valid returns.Shell.acceptable()exists precisely to handle this and is already used by the bash tool for the same reason. On a system where$SHELL=fish`, every template shell substitution will silently produce an empty string, which is a user-visible regression.
• Error visibility: the old code surfaced spawn failures as a "Error executing command: …" string in the template. The new path returns an empty string on failure, losing that diagnostic signal.

Confidence Score: 3/5

• Safe to merge for most users, but will silently break template shell commands for users with fish or nu as their default shell.
• The MCP change is clean and correct. The prompt change has a real correctness issue: using Shell.preferred() instead of Shell.acceptable() means fish/nu users will get empty substitutions with no error message, which is a silent regression. The fix is a one-line change to Shell.acceptable().
• packages/opencode/src/session/prompt.ts — specifically the Shell.preferred() call at line 1817.

Important Files Changed

Filename	Overview
packages/opencode/src/session/prompt.ts	Replaces Bun.$ template-literal shell execution with Process.text(). Uses Shell.preferred() which can return fish/nu — shells incompatible with the POSIX commands expected here; Shell.acceptable() should be used instead. Also loses the explicit error message on spawn failure.
packages/opencode/src/mcp/index.ts	Replaces Bun.spawn with Process.lines() for pgrep -P child-process tree discovery. Clean, functionally equivalent refactor; Process.lines splits on newlines and filters empty strings, matching pgrep's one-PID-per-line output format. Also improves pids.indexOf === -1 to !pids.includes().

Sequence Diagram

sequenceDiagram
participant Template as Template Engine<br/>(prompt.ts)
participant CM as ConfigMarkdown
participant Shell as Shell.preferred()
participant Process as Process.text()
participant SH as System Shell<br/>(sh/bash/fish/nu)
Template->>CM: shell(template)
CM-->>Template: shellMatches (array of [match, cmd])
Template->>Shell: preferred()
Shell-->>Template: sh (e.g. /bin/bash or fish)
loop For each cmd
Template->>Process: text([cmd], { shell: sh, nothrow: true })
Process->>SH: spawn(sh -c cmd)
SH-->>Process: stdout
Process-->>Template: TextResult { text }
end
Template->>Template: replace !`cmd` placeholders with results
Note over Template,SH: ⚠️ If sh is fish/nu, POSIX syntax in cmd will fail silently

Loading

_{Last reviewed commit: "refactor: replace Bu..."}

[greptile-apps]

Shell.preferred() may return incompatible shell for POSIX commands

The template shell commands (matched by !cmd`` syntax) are expected to be POSIX shell code. Using Shell.preferred() can return `fish` or `nu` — both of which are explicitly blacklisted in `Shell.acceptable()` because they are incompatible with POSIX syntax. When a user's `$SHELL` is set to fish or nu, the spawned process will receive POSIX shell syntax it cannot parse, and the failure will be silently swallowed by `nothrow: true`, leaving the template substitution as an empty string with no feedback.

bash.ts uses Shell.acceptable() for exactly this reason. This call should too.

Suggested change

	constsh=Shell.preferred()
	constresults=awaitPromise.all(
	shell.map(async([,cmd])=>{
	try{
	returnawait$`${{raw: cmd}}`.quiet().nothrow().text()
	}catch(error){
	return`Error executing command: ${errorinstanceofError ? error.message : String(error)}`
	}
	shellMatches.map(async([,cmd])=>{
	constout=awaitProcess.text([cmd],{shell: sh,nothrow: true})
	constsh=Shell.acceptable()

[greptile-apps]

Silent error swallowing on spawn failure

The old code had an explicit catch that returned "Error executing command: ${message}", making it visible in the template output when a command could not even be spawned. With nothrow: true, Process.run absorbs spawn errors and returns an empty stdout buffer, so out.text is "". The error is now completely silent — no mention of it appears in the rendered template.

Consider returning a fallback string on failure to preserve debuggability:

shellMatches.map(async([,cmd])=>{constout=awaitProcess.text([cmd],{shell: sh,nothrow: true})returnout.text||(out.code!==0 ? `Error executing command (exit ${out.code})` : "")}),