sync(upstream): 2026-04-27 (superseded)

apps/desktop/src/syncShellEnvironment.test.ts

@@ -6,21 +6,31 @@ describe("syncShellEnvironment", () => {
   it("hydrates PATH and missing SSH_AUTH_SOCK from the login shell on macOS", () => {
     const env: NodeJS.ProcessEnv = {
       SHELL: "/bin/zsh",
-      PATH: "/usr/bin",
+      PATH: "/Users/test/.local/bin:/usr/bin",
     };
     const readEnvironment = vi.fn(() => ({
       PATH: "/opt/homebrew/bin:/usr/bin",
       SSH_AUTH_SOCK: "/tmp/secretive.sock",
+      HOMEBREW_PREFIX: "/opt/homebrew",
     }));
 
     syncShellEnvironment(env, {
       platform: "darwin",
       readEnvironment,
     });
 
-    expect(readEnvironment).toHaveBeenCalledWith("/bin/zsh", ["PATH", "SSH_AUTH_SOCK"]);
-    expect(env.PATH).toBe("/opt/homebrew/bin:/usr/bin");
+    expect(readEnvironment).toHaveBeenCalledWith("/bin/zsh", [
+      "PATH",
+      "SSH_AUTH_SOCK",
+      "HOMEBREW_PREFIX",
+      "HOMEBREW_CELLAR",
+      "HOMEBREW_REPOSITORY",
+      "XDG_CONFIG_HOME",
+      "XDG_DATA_HOME",
+    ]);
+    expect(env.PATH).toBe("/opt/homebrew/bin:/usr/bin:/Users/test/.local/bin");
     expect(env.SSH_AUTH_SOCK).toBe("/tmp/secretive.sock");
+    expect(env.HOMEBREW_PREFIX).toBe("/opt/homebrew");
   });
 
   it("preserves an inherited SSH_AUTH_SOCK value", () => {
@@ -77,11 +87,67 @@ describe("syncShellEnvironment", () => {
       readEnvironment,
     });
 
-    expect(readEnvironment).toHaveBeenCalledWith("/bin/zsh", ["PATH", "SSH_AUTH_SOCK"]);
+    expect(readEnvironment).toHaveBeenCalledWith("/bin/zsh", [
+      "PATH",
+      "SSH_AUTH_SOCK",
+      "HOMEBREW_PREFIX",
+      "HOMEBREW_CELLAR",
+      "HOMEBREW_REPOSITORY",
+      "XDG_CONFIG_HOME",
+      "XDG_DATA_HOME",
+    ]);
     expect(env.PATH).toBe("/home/linuxbrew/.linuxbrew/bin:/usr/bin");
     expect(env.SSH_AUTH_SOCK).toBe("/tmp/secretive.sock");
   });
 
+  it("falls back to launchctl PATH on macOS when shell probing does not return one", () => {
+    const env: NodeJS.ProcessEnv = {
+      SHELL: "/opt/homebrew/bin/nu",
+      PATH: "/usr/bin",
+    };
+    const readEnvironment = vi
+      .fn()
+      .mockImplementationOnce(() => {
+        throw new Error("unknown flag");
+      })
+      .mockImplementationOnce(() => ({}));
+    const readLaunchctlPath = vi.fn(() => "/opt/homebrew/bin:/usr/bin");
+    const logWarning = vi.fn();
+
+    syncShellEnvironment(env, {
+      platform: "darwin",
+      readEnvironment,
+      readLaunchctlPath,
+      userShell: "/bin/zsh",
+      logWarning,
+    });
+
+    expect(readEnvironment).toHaveBeenNthCalledWith(1, "/opt/homebrew/bin/nu", [
+      "PATH",
+      "SSH_AUTH_SOCK",
+      "HOMEBREW_PREFIX",
+      "HOMEBREW_CELLAR",
+      "HOMEBREW_REPOSITORY",
+      "XDG_CONFIG_HOME",
+      "XDG_DATA_HOME",
+    ]);
+    expect(readEnvironment).toHaveBeenNthCalledWith(2, "/bin/zsh", [
+      "PATH",
+      "SSH_AUTH_SOCK",
+      "HOMEBREW_PREFIX",
+      "HOMEBREW_CELLAR",
+      "HOMEBREW_REPOSITORY",
+      "XDG_CONFIG_HOME",
+      "XDG_DATA_HOME",
+    ]);
+    expect(readLaunchctlPath).toHaveBeenCalledTimes(1);
+    expect(logWarning).toHaveBeenCalledWith(
+      "Failed to read login shell environment from /opt/homebrew/bin/nu.",
+      expect.any(Error),
+    );
+    expect(env.PATH).toBe("/opt/homebrew/bin:/usr/bin");
+  });
+
   it("does nothing outside macOS and linux", () => {
     const env: NodeJS.ProcessEnv = {
       SHELL: "C:/Program Files/Git/bin/bash.exe",

apps/desktop/src/syncShellEnvironment.ts

@@ -1,36 +1,79 @@
 import {
+  listLoginShellCandidates,
+  mergePathEntries,
+  readPathFromLaunchctl,
   readEnvironmentFromLoginShell,
-  resolveLoginShell,
   ShellEnvironmentReader,
 } from "@t3tools/shared/shell";
 
+const LOGIN_SHELL_ENV_NAMES = [
+  "PATH",
+  "SSH_AUTH_SOCK",
+  "HOMEBREW_PREFIX",
+  "HOMEBREW_CELLAR",
+  "HOMEBREW_REPOSITORY",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME",
+] as const;
+
+function logShellEnvironmentWarning(message: string, error?: unknown): void {
+  console.warn(`[desktop] ${message}`, error instanceof Error ? error.message : (error ?? ""));
+}
+
 export function syncShellEnvironment(
   env: NodeJS.ProcessEnv = process.env,
   options: {
     platform?: NodeJS.Platform;
     readEnvironment?: ShellEnvironmentReader;
+    readLaunchctlPath?: typeof readPathFromLaunchctl;
+    userShell?: string;
+    logWarning?: (message: string, error?: unknown) => void;
   } = {},
 ): void {
   const platform = options.platform ?? process.platform;
   if (platform !== "darwin" && platform !== "linux") return;
 
-  try {
-    const shell = resolveLoginShell(platform, env.SHELL);
-    if (!shell) return;
+  const logWarning = options.logWarning ?? logShellEnvironmentWarning;
+  const readEnvironment = options.readEnvironment ?? readEnvironmentFromLoginShell;
+  const shellEnvironment: Partial<Record<string, string>> = {};
 
-    const shellEnvironment = (options.readEnvironment ?? readEnvironmentFromLoginShell)(shell, [
-      "PATH",
-      "SSH_AUTH_SOCK",
-    ]);
+  try {
+    for (const shell of listLoginShellCandidates(platform, env.SHELL, options.userShell)) {
+      try {
+        Object.assign(shellEnvironment, readEnvironment(shell, LOGIN_SHELL_ENV_NAMES));
+        if (shellEnvironment.PATH) {
+          break;
+        }
+      } catch (error) {
+        logWarning(`Failed to read login shell environment from ${shell}.`, error);
+      }
+    }
 
-    if (shellEnvironment.PATH) {
-      env.PATH = shellEnvironment.PATH;
+    const launchctlPath =
+      platform === "darwin" && !shellEnvironment.PATH
+        ? (options.readLaunchctlPath ?? readPathFromLaunchctl)()
+        : undefined;
+    const mergedPath = mergePathEntries(shellEnvironment.PATH ?? launchctlPath, env.PATH, platform);
+    if (mergedPath) {
+      env.PATH = mergedPath;
     }
 
     if (!env.SSH_AUTH_SOCK && shellEnvironment.SSH_AUTH_SOCK) {
       env.SSH_AUTH_SOCK = shellEnvironment.SSH_AUTH_SOCK;
     }
-  } catch {
-    // Keep inherited environment if shell lookup fails.
+
+    for (const name of [
+      "HOMEBREW_PREFIX",
+      "HOMEBREW_CELLAR",
+      "HOMEBREW_REPOSITORY",
+      "XDG_CONFIG_HOME",
+      "XDG_DATA_HOME",
+    ] as const) {
+      if (!env[name] && shellEnvironment[name]) {
+        env[name] = shellEnvironment[name];
+      }
+    }
+  } catch (error) {
+    logWarning("Failed to synchronize the desktop shell environment.", error);
   }
 }

apps/server/src/atomicWrite.ts

@@ -0,0 +1,25 @@
+import { Effect, FileSystem, Path } from "effect";
+import * as Random from "effect/Random";
+
+export const writeFileStringAtomically = (input: {
+  readonly filePath: string;
+  readonly contents: string;
+}) =>
+  Effect.scoped(
+    Effect.gen(function* () {
+      const fileSystem = yield* FileSystem.FileSystem;
+      const path = yield* Path.Path;
+      const tempFileId = yield* Random.nextUUIDv4;
+      const targetDirectory = path.dirname(input.filePath);
+
+      yield* fileSystem.makeDirectory(targetDirectory, { recursive: true });
+      const tempDirectory = yield* fileSystem.makeTempDirectoryScoped({
+        directory: targetDirectory,
+        prefix: `${path.basename(input.filePath)}.`,
+      });
+      const tempPath = path.join(tempDirectory, `${tempFileId}.tmp`);
+
+      yield* fileSystem.writeFileString(tempPath, input.contents);
+      yield* fileSystem.rename(tempPath, input.filePath);
+    }),
+  );

apps/server/src/bin.ts

@@ -1,5 +1,3 @@
-import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
-import * as NodeServices from "@effect/platform-node/NodeServices";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
 import { Command } from "effect/unstable/cli";
@@ -8,11 +6,32 @@ import { NetService } from "@t3tools/shared/Net";
 import { cli } from "./cli";
 import { version } from "../package.json" with { type: "json" };
 
-const CliRuntimeLayer = Layer.mergeAll(NodeServices.layer, NetService.layer);
+const isBunRuntime = typeof Bun !== "undefined";
 
-const main = (Command.run(cli, { version }) as any).pipe(
-  Effect.scoped,
-  Effect.provide(CliRuntimeLayer),
-);
+const main = (Command.run(cli, { version }) as any).pipe(Effect.scoped);
 
-NodeRuntime.runMain(main);
+async function bootCli(): Promise<void> {
+  // Keep runtime selection dynamic so the same source can boot under Bun for
+  // local development and Node for packaged builds, without forcing the CJS
+  // build to support top-level await.
+  if (isBunRuntime) {
+    const [BunRuntime, BunServices] = await Promise.all([
+      import("@effect/platform-bun/BunRuntime"),
+      import("@effect/platform-bun/BunServices"),
+    ]);
+    const cliRuntimeLayer = Layer.mergeAll(BunServices.layer, NetService.layer);
+
+    BunRuntime.runMain(main.pipe(Effect.provide(cliRuntimeLayer)));
+    return;
+  }
+
+  const [NodeRuntime, NodeServices] = await Promise.all([
+    import("@effect/platform-node/NodeRuntime"),
+    import("@effect/platform-node/NodeServices"),
+  ]);
+  const cliRuntimeLayer = Layer.mergeAll(NodeServices.layer, NetService.layer);
+
+  NodeRuntime.runMain(main.pipe(Effect.provide(cliRuntimeLayer)));
+}
+
+void bootCli();

apps/server/src/checkpointing/Diffs.test.ts

@@ -65,4 +65,39 @@ describe("parseTurnDiffFilesFromUnifiedDiff", () => {
       { path: "a.txt", additions: 2, deletions: 1 },
     ]);
   });
+
+  it("parses quoted diff headers for paths that need escaping", () => {
+    const diff = [
+      'diff --git "a/src/with space.ts" "b/src/with space.ts"',
+      "index 1111111..2222222 100644",
+      '--- "a/src/with space.ts"',
+      '+++ "b/src/with space.ts"',
+      "@@ -1 +1 @@",
+      "-old",
+      "+new",
+      "",
+    ].join("\n");
+
+    expect(parseTurnDiffFilesFromUnifiedDiff(diff)).toEqual([
+      { path: "src/with space.ts", additions: 1, deletions: 1 },
+    ]);
+  });
+
+  it("does not treat added +++ content as a path header", () => {
+    const diff = [
+      "diff --git a/a.txt b/a.txt",
+      "index 1111111..2222222 100644",
+      "--- a/a.txt",
+      "+++ b/a.txt",
+      "@@ -1 +1,2 @@",
+      " unchanged",
+      "+hello",
+      "+++ counter",
+      "",
+    ].join("\n");
+
+    expect(parseTurnDiffFilesFromUnifiedDiff(diff)).toEqual([
+      { path: "a.txt", additions: 2, deletions: 0 },
+    ]);
+  });
 });