fix(desktop): restore account shell PATH discovery

Author: rynfar

apps/desktop/src/shell/DesktopShellEnvironment.test.ts

@@ -100,11 +100,21 @@ function runShellEnvironment(input: {
 }
 
 describe("DesktopShellEnvironment", () => {
+  it("uses the OS account shell when a packaged GUI launch omits SHELL", () => {
+    assert.deepEqual(
+      DesktopShellEnvironment.resolveDesktopLoginShellCandidates(
+        { env: { PATH: "/usr/bin" }, platform: "darwin" },
+        "/opt/homebrew/bin/fish",
+      ),
+      ["/opt/homebrew/bin/fish", "/bin/zsh"],
+    );
+  });
+
   it.effect("hydrates PATH and missing SSH_AUTH_SOCK from the login shell on macOS", () =>
     Effect.gen(function* () {
       const env: NodeJS.ProcessEnv = {
         SHELL: "/bin/zsh",
-        PATH: "/Users/test/.local/bin:/usr/bin",
+        PATH: "/usr/bin",
       };
       const commands: ChildProcess.Command[] = [];
 
@@ -114,7 +124,7 @@ describe("DesktopShellEnvironment", () => {
         handler: (command) => {
           commands.push(command);
           return envOutput({
-            PATH: "/opt/homebrew/bin:/usr/bin",
+            PATH: "/Users/test/.local/bin:/opt/homebrew/bin:/usr/bin",
             SSH_AUTH_SOCK: "/tmp/secretive.sock",
             HOMEBREW_PREFIX: "/opt/homebrew",
           });
@@ -123,7 +133,7 @@ describe("DesktopShellEnvironment", () => {
 
       assert.equal(commands.length, 1);
       assert.equal(commands[0]?._tag === "StandardCommand" ? commands[0].command : "", "/bin/zsh");
-      assert.equal(env.PATH, "/opt/homebrew/bin:/usr/bin:/Users/test/.local/bin");
+      assert.equal(env.PATH, "/Users/test/.local/bin:/opt/homebrew/bin:/usr/bin");
       assert.equal(env.SSH_AUTH_SOCK, "/tmp/secretive.sock");
       assert.equal(env.HOMEBREW_PREFIX, "/opt/homebrew");
     }),
@@ -331,13 +341,13 @@ describe("DesktopShellEnvironment", () => {
           const errors = messages
             .flatMap((message) => (Array.isArray(message) ? message : [message]))
             .filter(isDesktopShellEnvironmentCommandError);
-          assert.lengthOf(errors, 1);
-          assert.equal(errors[0]?.probe, "login-shell");
-          assert.equal(errors[0]?.executable, "bash");
-          assert.equal(errors[0]?.argumentCount, 2);
-          assert.notProperty(errors[0] ?? {}, "args");
-          assert.equal(errors[0]?.cause, cause);
-          assert.notInclude(errors[0]?.message ?? "", cause.message);
+          const bashErrors = errors.filter((error) => error.executable === "bash");
+          assert.lengthOf(bashErrors, 1);
+          assert.equal(bashErrors[0]?.probe, "login-shell");
+          assert.equal(bashErrors[0]?.argumentCount, 2);
+          assert.notProperty(bashErrors[0] ?? {}, "args");
+          assert.equal(bashErrors[0]?.cause, cause);
+          assert.notInclude(bashErrors[0]?.message ?? "", cause.message);
         }),
       ),
       Effect.provide(Logger.layer([logger], { mergeWithExisting: false })),

apps/desktop/src/shell/DesktopShellEnvironment.ts

@@ -1,3 +1,4 @@
+import { listLoginShellCandidates } from "@t3tools/shared/shell";
 import * as Context from "effect/Context";
 import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
@@ -15,7 +16,6 @@ type EnvironmentPatch = Record<string, string>;
 interface ShellEnvironmentConfig {
   readonly env: NodeJS.ProcessEnv;
   readonly platform: NodeJS.Platform;
-  readonly userShell: Option.Option<string>;
 }
 
 interface WindowsProbeOptions {
@@ -172,24 +172,10 @@ const mergePaths = (
   return entries.length > 0 ? Option.some(entries.join(delimiter)) : Option.none();
 };
 
-const listLoginShellCandidates = (config: ShellEnvironmentConfig): ReadonlyArray<string> => {
-  const fallback =
-    config.platform === "darwin" ? "/bin/zsh" : config.platform === "linux" ? "/bin/bash" : "";
-  const seen = new Set<string>();
-  const candidates: string[] = [];
-
-  for (const candidate of [
-    trimNonEmpty(config.env.SHELL),
-    config.userShell,
-    trimNonEmpty(fallback),
-  ]) {
-    if (Option.isNone(candidate) || seen.has(candidate.value)) continue;
-    seen.add(candidate.value);
-    candidates.push(candidate.value);
-  }
-
-  return candidates;
-};
+export const resolveDesktopLoginShellCandidates = (
+  config: ShellEnvironmentConfig,
+  userShell?: string,
+): ReadonlyArray<string> => listLoginShellCandidates(config.platform, config.env.SHELL, userShell);
 
 const knownWindowsCliDirs = (env: NodeJS.ProcessEnv): ReadonlyArray<string> => [
   ...trimNonEmpty(env.APPDATA).pipe(
@@ -421,7 +407,7 @@ const installPosixEnvironment = Effect.fn("desktop.shellEnvironment.installPosix
     const fileSystem = yield* FileSystem.FileSystem;
     const shellEnvironment: EnvironmentPatch = {};
 
-    for (const shell of listLoginShellCandidates(config)) {
+    for (const shell of resolveDesktopLoginShellCandidates(config)) {
       Object.assign(
         shellEnvironment,
         yield* readLoginShellEnvironment(shell, LOGIN_SHELL_ENV_NAMES),
@@ -510,7 +496,6 @@ export const make = Effect.gen(function* () {
     installShellEnvironment({
       env: process.env,
       platform: environment.platform,
-      userShell: Option.none(),
     }).pipe(
       Effect.provideService(FileSystem.FileSystem, fileSystem),
       Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),

apps/server/src/provider/prime/PrimeAgentBackendSelection.test.ts

@@ -1,9 +1,13 @@
 // @effect-diagnostics nodeBuiltinImport:off
+import * as NodeFSP from "node:fs/promises";
+import * as NodeOS from "node:os";
 import * as NodePath from "node:path";
 
 import * as NodeServices from "@effect/platform-node/NodeServices";
 import { expect, it } from "@effect/vitest";
 import { ProviderInstanceId } from "@t3tools/contracts";
+import { HostProcessPlatform } from "@t3tools/shared/hostProcess";
+import { resolveCommandPath } from "@t3tools/shared/shell";
 import * as Effect from "effect/Effect";
 
 import {
@@ -28,6 +32,52 @@ const baseInput: PrimeAgentBackendNegotiationInput = {
 };
 
 it.layer(NodeServices.layer)("negotiatePrimeAgentBackend", (it) => {
+  it.effect("selects daemon with a PATH-resolved Prime Agent executable", () =>
+    Effect.scoped(
+      Effect.gen(function* () {
+        const tempDir = yield* Effect.acquireRelease(
+          Effect.promise(() =>
+            NodeFSP.mkdtemp(NodePath.join(NodeOS.tmpdir(), "prime-agent-backend-path-")),
+          ),
+          (directory) =>
+            Effect.promise(() => NodeFSP.rm(directory, { recursive: true, force: true })),
+        );
+        const platform = yield* HostProcessPlatform;
+        const executableName = platform === "win32" ? "prime-agent.cmd" : "prime-agent";
+        const executablePath = NodePath.join(tempDir, executableName);
+        yield* Effect.promise(() => NodeFSP.writeFile(executablePath, "", "utf8"));
+        if (platform !== "win32") {
+          yield* Effect.promise(() => NodeFSP.chmod(executablePath, 0o755));
+        }
+
+        const managerCalls: PrimeAgentDaemonManagerInput[] = [];
+        const manager = testManager("path-resolved");
+        const selected = yield* negotiatePrimeAgentBackend(
+          {
+            ...baseInput,
+            environment: {
+              PATH: tempDir,
+              ...(platform === "win32" ? { PATHEXT: ".CMD" } : {}),
+            },
+          },
+          {
+            resolveExecutable: (command, environment) =>
+              resolveCommandPath(command, { env: environment }),
+            makeManager: (input) =>
+              Effect.sync(() => {
+                managerCalls.push(input);
+                return manager;
+              }),
+          },
+        );
+
+        expect(selected).toEqual({ runtime: "daemon", manager });
+        expect(managerCalls).toHaveLength(1);
+        expect(managerCalls[0]?.executablePath).toBe(executablePath);
+      }),
+    ),
+  );
+
   it.effect(
     "resolves empty-launch-args binaries to absolute paths before one manager attempt",
     () =>