fix(opencode): inherit user shell PATH when spawning opencode serve

macOS GUI launches inherit launchd's minimal PATH
(/usr/bin:/bin:/usr/sbin:/sbin), which prevents opencode serve and any
tool it spawns (e.g. rust-analyzer for the oh-my-opencode plugin's
lsp_diagnostics tool) from finding user-installed binaries. The fork
already has this exact problem solved for the extension host via
getResolvedShellEnv(); we just weren't using it for the OpenCode backend.

Inject IEnvironmentMainService into OpencodeServeManager and call
getResolvedShellEnv() before spawning. The result is cached at module
level so subsequent restarts (respawn) reuse it without re-spawning the
shell. Windows and CLI launches short-circuit inside getResolvedShellEnv,
so they keep their existing behavior.

Also thread the merged env into findBinaryOnPath()'s 'which opencode'
execSync so binary discovery sees the same PATH the spawn will use.

Author: cpkt9762

src/vs/workbench/contrib/opencode/electron-main/opencodeServeManager.ts

@@ -21,12 +21,14 @@ import {
 	type IDisposable,
 } from "../../../../base/common/lifecycle.js";
 import { IConfigurationService } from "../../../../platform/configuration/common/configuration.js";
+import { IEnvironmentMainService } from "../../../../platform/environment/electron-main/environmentMainService.js";
 import {
 	InstantiationType,
 	registerSingleton,
 } from "../../../../platform/instantiation/common/extensions.js";
 import { createDecorator } from "../../../../platform/instantiation/common/instantiation.js";
 import { ILogService } from "../../../../platform/log/common/log.js";
+import { getResolvedShellEnv } from "../../../../platform/shell/node/shellEnv.js";
 
 const STARTUP_TIMEOUT = 15_000;
 const HEALTH_TIMEOUT = 2_000;
@@ -96,6 +98,7 @@ export class OpencodeServeManager
 	constructor(
 		private readonly configurationService: IConfigurationService,
 		private readonly logService: ILogService,
+		private readonly environmentMainService: IEnvironmentMainService,
 	) {
 		super();
 
@@ -197,15 +200,20 @@ export class OpencodeServeManager
 
 		await this.killStaleServer(port);
 
-		const binaryPath = this.findBinaryPath();
+		// macOS GUI launches inherit launchd's minimal PATH; resolve the user's login-shell
+		// env so opencode serve and its child processes (e.g. rust-analyzer spawned by the
+		// oh-my-opencode plugin) see the same PATH the user has in their terminal.
+		const mergedEnv = await this.getMergedEnv();
+
+		const binaryPath = this.findBinaryPath(mergedEnv);
 		if (!binaryPath) {
 			throw new Error(
 				"Failed to find an opencode binary. Configure opencode.binaryPath or add opencode to PATH.",
 			);
 		}
 
 		const deadline = Date.now() + STARTUP_TIMEOUT;
-		const env = { ...process.env };
+		const env = { ...mergedEnv };
 		delete env.OPENCODE_SERVER_PASSWORD;
 		env.OPENCODE_SERVER_PASSWORD = this.password;
 		const proc = this.spawnProcess(
@@ -464,7 +472,7 @@ export class OpencodeServeManager
 		});
 	}
 
-	private findBinaryPath(): string | undefined {
+	private findBinaryPath(env: NodeJS.ProcessEnv = process.env): string | undefined {
 		const configuredPath = this.getBinaryPath();
 		if (configuredPath) {
 			const resolvedPath = this.resolveConfiguredBinaryPath(configuredPath);
@@ -478,7 +486,7 @@ export class OpencodeServeManager
 			);
 		}
 
-		const pathBinary = this.findBinaryOnPath();
+		const pathBinary = this.findBinaryOnPath(env);
 		if (pathBinary) {
 			return pathBinary;
 		}
@@ -495,6 +503,24 @@ export class OpencodeServeManager
 		return undefined;
 	}
 
+	protected async getMergedEnv(): Promise<NodeJS.ProcessEnv> {
+		let shellEnv: typeof process.env = {};
+		try {
+			shellEnv = await getResolvedShellEnv(
+				this.configurationService,
+				this.logService,
+				this.environmentMainService.args,
+				process.env,
+			);
+		} catch (error) {
+			this.logService.error(
+				"[opencode] failed to resolve shell environment for opencode serve",
+				error,
+			);
+		}
+		return { ...process.env, ...shellEnv };
+	}
+
 	protected async killStaleServer(port: number): Promise<void> {
 		const url = `http://127.0.0.1:${port}/`;
 
@@ -579,14 +605,15 @@ export class OpencodeServeManager
 		return undefined;
 	}
 
-	private findBinaryOnPath(): string | undefined {
+	private findBinaryOnPath(env: NodeJS.ProcessEnv = process.env): string | undefined {
 		const command =
 			platform() === "win32" ? "where opencode" : "which opencode";
 
 		try {
 			const output = execSync(command, {
 				encoding: "utf8",
 				stdio: ["ignore", "pipe", "ignore"],
+				env,
 			}).trim();
 			const path = output
 				.split(/\r?\n/)
@@ -721,6 +748,7 @@ function isHealthResponse(value: unknown): value is { healthy: true } {
 
 IConfigurationService(OpencodeServeManager, "", 0);
 ILogService(OpencodeServeManager, "", 1);
+IEnvironmentMainService(OpencodeServeManager, "", 2);
 
 registerSingleton(
 	IOpencodeServeManager,

src/vs/workbench/contrib/opencode/test/electron-main/opencodeServeManager.test.ts

@@ -19,6 +19,7 @@ import { tmpdir } from 'os';
 import { join } from 'path';
 import { OpencodeServeManager } from '../../electron-main/opencodeServeManager.js';
 import { TestConfigurationService } from '../../../../../platform/configuration/test/common/testConfigurationService.js';
+import type { IEnvironmentMainService } from '../../../../../platform/environment/electron-main/environmentMainService.js';
 import { NullLogService } from '../../../../../platform/log/common/log.js';
 
 type MockBackend = { port: number; close: () => Promise<void>; getRequests: () => number };
@@ -137,9 +138,18 @@ function fakeSpawn(opts: { exitOnSigterm?: boolean } = {}) {
 	};
 }
 
+const stubEnvironmentMainService: IEnvironmentMainService = { args: {} } as IEnvironmentMainService;
+
 class TestableOpencodeServeManager extends OpencodeServeManager {
 	spawnCalls: { command: string; args: readonly string[]; options: SpawnOptions }[] = [];
 	nextProcess: ChildProcess | FakeChildProcess | undefined;
+	constructor(
+		configurationService: TestConfigurationService,
+		logService: NullLogService,
+		environmentMainService: IEnvironmentMainService = stubEnvironmentMainService,
+	) {
+		super(configurationService, logService, environmentMainService);
+	}
 	protected override spawnProcess(command: string, args: readonly string[], options: SpawnOptions): ChildProcess {
 		this.spawnCalls.push({ command, args, options });
 		if (!this.nextProcess) {
@@ -154,6 +164,11 @@ class TestableOpencodeServeManager extends OpencodeServeManager {
 	protected override async findProcessOnPort(_port: number): Promise<number | undefined> {
 		return undefined;
 	}
+	protected override async getMergedEnv(): Promise<NodeJS.ProcessEnv> {
+		// Tests must not spawn the user's login shell; reuse the test process env so
+		// findBinaryPath() PATH-lookup tests still see the env they manipulate directly.
+		return { ...process.env };
+	}
 	get testState() { return this._testState; }
 	get testWeStarted() { return this._testWeStarted; }
 }