fix(cli): adopt the login shell environment in the background service

A managed service elected by a GUI client (the desktop app, an editor, a
login item) inherits launchd's environment: PATH is /usr/bin:/bin:/usr/sbin:/sbin
and nothing exported from .zshrc or .bashrc exists. Every process the server
spawns extends process.env, so stdio MCP servers using #!/usr/bin/env node,
npx, uvx, formatters, and hooks fail with "Connection closed" while the bash
tool, which prefers the client's terminal environment, keeps working.

Resolve the user's interactive login shell once at service startup when the
inherited environment did not come from a shell, and adopt it before anything
reads process.env.

packages/cli/src/server-process.ts

@@ -13,6 +13,7 @@ import { HttpServer } from "effect/unstable/http"
 import { Env } from "./env"
 import { ServiceConfig } from "./services/service-config"
 import { ServiceRegistration } from "./services/service-registration"
+import { ShellEnvironment } from "./shell-environment"
 import { Updater } from "./services/updater"
 import { WebUi } from "./services/web-ui"
 import { databasePath } from "./database-path"
@@ -28,6 +29,9 @@ export type Options = {
 
 // The process effect lives until server shutdown; tracing it would parent every request to one process-lifetime trace.
 export const run = Effect.fnUntraced(function* (options: Options) {
+  // A managed service may have been started by a GUI client with launchd's environment. Adopt the
+  // login shell's before anything reads process.env, including the OPENCODE_* settings below.
+  if (options.mode === "service") yield* ShellEnvironment.adopt()
   return yield* processEffect(options).pipe(
     Effect.provide(
       LayerNode.compile(LayerNode.group([Global.node, AppProcess.node]), {
@@ -38,9 +42,8 @@ export const run = Effect.fnUntraced(function* (options: Options) {
         ],
       }),
     ),
-    Effect.provide(NodeServices.layer),
   )
-})
+}, Effect.provide(NodeServices.layer))
 
 const processEffect = Effect.fnUntraced(function* (options: Options) {
   const inherited = process.env.OPENCODE_PTY_HANDOFF

packages/cli/src/shell-environment.ts

@@ -0,0 +1,80 @@
+export * as ShellEnvironment from "./shell-environment"
+
+import { randomUUID } from "node:crypto"
+import { Effect } from "effect"
+import { ChildProcess } from "effect/unstable/process"
+import { ChildProcessSpawner } from "effect/unstable/process/ChildProcessSpawner"
+
+// Set on the probe shell so an rc file that itself starts opencode cannot recurse into another probe.
+export const RESOLVING = "OPENCODE_RESOLVING_SHELL_ENVIRONMENT"
+
+// Shell bookkeeping that describes the probe process, not the user's environment.
+const TRANSIENT = new Set([RESOLVING, "SHLVL", "PWD", "OLDPWD", "_"])
+
+export type Variables = Readonly<Record<string, string | undefined>>
+
+/**
+ * Resolve the environment of the user's interactive login shell when the current environment did
+ * not come from one.
+ *
+ * A background service elected by a GUI client (the desktop app, an editor, a login item) inherits
+ * launchd's environment: PATH is `/usr/bin:/bin:/usr/sbin:/sbin` and nothing exported from
+ * `.zshrc` or `.bashrc` exists. Every process the server spawns extends `process.env`, so stdio MCP
+ * servers using `#!/usr/bin/env node`, `npx`, `uvx`, formatters, and hooks fail with no useful error
+ * while the bash tool, which prefers the client's terminal environment, keeps working. Editors such
+ * as VS Code and Zed resolve the login shell at startup for the same reason.
+ *
+ * Returns `undefined` when there is nothing to adopt: Windows, an environment that already passed
+ * through a shell (`SHLVL`), a probe already in progress, or a shell that fails to report.
+ */
+export const resolve = Effect.fnUntraced(function* (env: Variables = process.env) {
+  if (process.platform === "win32") return undefined
+  if (env[RESOLVING] !== undefined || env.SHLVL !== undefined) return undefined
+  const spawner = yield* ChildProcessSpawner
+  const marker = randomUUID()
+  // Interactive and login: most PATH edits live in `.zshrc`/`.bashrc`, which only interactive shells read.
+  // `env -0` keeps values containing newlines intact.
+  const output = yield* spawner
+    .string(
+      ChildProcess.make(env.SHELL || "/bin/sh", ["-ilc", `printf '%s' '${marker}'; env -0; printf '%s' '${marker}'`], {
+        env: { ...env, [RESOLVING]: "1" },
+        stdin: "ignore",
+        // Interactive shells without a terminal warn on stderr; nothing reads it, so never let it fill.
+        stderr: "ignore",
+      }),
+    )
+    .pipe(
+      Effect.timeout("10 seconds"),
+      Effect.tapError((error) => Effect.logWarning("shell environment unavailable", { error })),
+      Effect.orElseSucceed(() => undefined),
+    )
+  if (output === undefined) return undefined
+  const start = output.indexOf(marker)
+  const end = output.lastIndexOf(marker)
+  if (start === -1 || end === start) {
+    yield* Effect.logWarning("shell environment unavailable", { shell: env.SHELL, reason: "missing markers" })
+    return undefined
+  }
+  return Object.fromEntries(
+    output
+      .slice(start + marker.length, end)
+      .split("\0")
+      .flatMap((entry) => {
+        const separator = entry.indexOf("=")
+        if (separator <= 0) return []
+        const key = entry.slice(0, separator)
+        return TRANSIENT.has(key) ? [] : [[key, entry.slice(separator + 1)] as const]
+      }),
+  )
+})
+
+/** Apply the resolved login-shell environment to this process before anything reads `process.env`. */
+export const adopt = Effect.fnUntraced(function* () {
+  const variables = yield* resolve()
+  if (variables === undefined) return
+  Object.assign(process.env, variables)
+  yield* Effect.logInfo("shell environment adopted", {
+    shell: process.env.SHELL,
+    variables: Object.keys(variables).length,
+  })
+})

packages/cli/test/shell-environment.test.ts

@@ -0,0 +1,68 @@
+import { NodeServices } from "@effect/platform-node"
+import { afterAll, beforeAll, expect, test } from "bun:test"
+import { Effect } from "effect"
+import fs from "node:fs/promises"
+import os from "node:os"
+import path from "node:path"
+import { ShellEnvironment } from "../src/shell-environment"
+
+// A stand-in login shell: it records every invocation, applies "rc file" exports, then runs the
+// probe script exactly as `$SHELL -ilc <script>` would.
+let root: string
+let shell: string
+let invocations: string
+
+beforeAll(async () => {
+  root = await fs.mkdtemp(path.join(os.tmpdir(), "opencode-shell-env-"))
+  shell = path.join(root, "login-shell")
+  invocations = path.join(root, "invocations")
+  await fs.writeFile(
+    shell,
+    [
+      "#!/bin/sh",
+      `printf '%s\\n' "$1" >> '${invocations}'`,
+      `[ "$1" = -ilc ] || exit 64`,
+      'export PATH="/rc/bin:$PATH"',
+      "export FROM_RC=yes",
+      "export MULTILINE='first",
+      "second'",
+      'export SAW_GUARD="${OPENCODE_RESOLVING_SHELL_ENVIRONMENT:-unset}"',
+      "export SHLVL=1 PWD=/rc OLDPWD=/rc",
+      'eval "$2"',
+    ].join("\n"),
+    { mode: 0o755 },
+  )
+})
+
+afterAll(() => fs.rm(root, { recursive: true, force: true }))
+
+const skip = process.platform === "win32"
+const launchd = { SHELL: "", HOME: "", PATH: "/usr/bin:/bin:/usr/sbin:/sbin" }
+const resolve = (env: Record<string, string | undefined>) =>
+  Effect.runPromise(
+    ShellEnvironment.resolve({ ...launchd, ...env, SHELL: env.SHELL ?? shell, HOME: root }).pipe(
+      Effect.provide(NodeServices.layer),
+    ),
+  )
+
+test.skipIf(skip)("adopts the login shell's exports over a launchd environment", async () => {
+  const variables = await resolve({})
+  expect(variables?.PATH).toBe("/rc/bin:/usr/bin:/bin:/usr/sbin:/sbin")
+  expect(variables?.FROM_RC).toBe("yes")
+  expect(variables?.MULTILINE).toBe("first\nsecond")
+  expect(variables?.SAW_GUARD).toBe("1")
+  for (const key of [ShellEnvironment.RESOLVING, "SHLVL", "PWD", "OLDPWD", "_"])
+    expect(variables).not.toHaveProperty(key)
+})
+
+test.skipIf(skip)("does not probe when the environment already came from a shell or a probe", async () => {
+  const before = await fs.readFile(invocations, "utf8").catch(() => "")
+  expect(await resolve({ SHLVL: "1" })).toBeUndefined()
+  expect(await resolve({ [ShellEnvironment.RESOLVING]: "1" })).toBeUndefined()
+  expect(await fs.readFile(invocations, "utf8").catch(() => "")).toBe(before)
+})
+
+test.skipIf(skip)("falls back to the inherited environment when the shell cannot report", async () => {
+  expect(await resolve({ SHELL: "/bin/false" })).toBeUndefined()
+  expect(await resolve({ SHELL: path.join(root, "missing-shell") })).toBeUndefined()
+})