Refactor Codex command execution to support WSL integration

.github/workflows/release.yml

@@ -220,39 +220,9 @@ jobs:
           path: release-publish/*
           if-no-files-found: error
 
-  publish_cli:
-    name: Publish CLI to npm
-    needs: [preflight, build]
-    runs-on: ubuntu-24.04
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          ref: ${{ needs.preflight.outputs.ref }}
-
-      - name: Setup Bun
-        uses: oven-sh/setup-bun@v2
-        with:
-          bun-version-file: package.json
-
-      - name: Setup Node
-        uses: actions/setup-node@v4
-        with:
-          node-version-file: package.json
-          registry-url: https://registry.npmjs.org
-
-      - name: Install dependencies
-        run: bun install --frozen-lockfile
-
-      - name: Build CLI package
-        run: bun run build --filter=@t3tools/web --filter=t3
-
-      - name: Publish CLI package
-        run: node apps/server/scripts/cli.ts publish --tag latest --app-version "${{ needs.preflight.outputs.version }}" --verbose
-
   release:
     name: Publish GitHub Release
-    needs: [preflight, build, publish_cli]
+    needs: [preflight, build]
     runs-on: ubuntu-24.04
     steps:
       - name: Download all desktop artifacts

apps/server/src/codexAppServerManager.ts

@@ -22,6 +22,8 @@ import {
 import { normalizeModelSlug } from "@t3tools/shared/model";
 import { Effect, ServiceMap } from "effect";
 
+import { resolveWorkspaceCommandLaunch, toWslPath } from "./wsl";
+
 type PendingRequestKey = string;
 
 interface PendingRequest {
@@ -138,6 +140,13 @@ export interface CodexThreadSnapshot {
   turns: CodexThreadTurnSnapshot[];
 }
 
+interface CodexSpawnConfig {
+  readonly command: string;
+  readonly args: ReadonlyArray<string>;
+  readonly cwd: string;
+  readonly distribution: string | null;
+}
+
 const ANSI_ESCAPE_CHAR = String.fromCharCode(27);
 const ANSI_ESCAPE_REGEX = new RegExp(`${ANSI_ESCAPE_CHAR}\\[[0-9;]*m`, "g");
 const CODEX_STDERR_LOG_REGEX =
@@ -168,6 +177,32 @@ function asString(value: unknown): string | undefined {
   return typeof value === "string" ? value : undefined;
 }
 
+function resolveCodexSpawnConfig(input: {
+  readonly cwd: string;
+  readonly binaryPath: string;
+}): CodexSpawnConfig {
+  const wslLaunch = resolveWorkspaceCommandLaunch({
+    workspaceRoot: input.cwd,
+    command: input.binaryPath,
+    args: ["app-server"],
+  });
+  if (wslLaunch) {
+    return {
+      command: wslLaunch.command,
+      args: wslLaunch.args,
+      cwd: wslLaunch.cwd,
+      distribution: wslLaunch.workspace.distribution,
+    };
+  }
+
+  return {
+    command: input.binaryPath,
+    args: ["app-server"],
+    cwd: input.cwd,
+    distribution: null,
+  };
+}
+
 export function readCodexAccountSnapshot(response: unknown): CodexAccountSnapshot {
   const record = asObject(response);
   const account = asObject(record?.account) ?? record;
@@ -535,14 +570,24 @@ export class CodexAppServerManager extends EventEmitter<CodexAppServerManagerEve
       const codexOptions = readCodexProviderOptions(input);
       const codexBinaryPath = codexOptions.binaryPath ?? "codex";
       const codexHomePath = codexOptions.homePath;
-      const child = spawn(codexBinaryPath, ["app-server"], {
+      const spawnConfig = resolveCodexSpawnConfig({
         cwd: resolvedCwd,
+        binaryPath: codexBinaryPath,
+      });
+      const translatedCodexHomePath =
+        spawnConfig.distribution && codexHomePath
+          ? toWslPath(codexHomePath, {
+              distribution: spawnConfig.distribution,
+            }) ?? codexHomePath
+          : codexHomePath;
+      const child = spawn(spawnConfig.command, [...spawnConfig.args], {
+        cwd: spawnConfig.cwd,
         env: {
           ...process.env,
-          ...(codexHomePath ? { CODEX_HOME: codexHomePath } : {}),
+          ...(translatedCodexHomePath ? { CODEX_HOME: translatedCodexHomePath } : {}),
         },
         stdio: ["pipe", "pipe", "pipe"],
-        shell: process.platform === "win32",
+        shell: false,
       });
       const output = readline.createInterface({ input: child.stdout });
 

apps/server/src/git/Layers/CodexTextGeneration.ts

@@ -7,6 +7,7 @@ import { sanitizeBranchFragment, sanitizeFeatureBranchName } from "@t3tools/shar
 
 import { resolveAttachmentPath } from "../../attachmentStore.ts";
 import { ServerConfig } from "../../config.ts";
+import { resolveWorkspaceCommandLaunch, toWslPath } from "../../wsl.ts";
 import { TextGenerationError } from "../Errors.ts";
 import {
   type BranchNameGenerationInput,
@@ -204,9 +205,29 @@ const makeCodexTextGeneration = Effect.gen(function* () {
       const outputPath = yield* writeTempFile(operation, "codex-output", "");
 
       const runCodexCommand = Effect.gen(function* () {
+        const wslLaunch = resolveWorkspaceCommandLaunch({
+          workspaceRoot: cwd,
+          command: "codex",
+          args: [
+            "exec",
+            "--ephemeral",
+            "-s",
+            "read-only",
+            "--model",
+            CODEX_MODEL,
+            "--config",
+            `model_reasoning_effort="${CODEX_REASONING_EFFORT}"`,
+            "--output-schema",
+            toWslPath(schemaPath) ?? schemaPath,
+            "--output-last-message",
+            toWslPath(outputPath) ?? outputPath,
+            ...imagePaths.flatMap((imagePath) => ["--image", toWslPath(imagePath) ?? imagePath]),
+            "-",
+          ],
+        });
         const command = ChildProcess.make(
-          "codex",
-          [
+          wslLaunch?.command ?? "codex",
+          wslLaunch?.args ?? [
             "exec",
             "--ephemeral",
             "-s",
@@ -223,8 +244,8 @@ const makeCodexTextGeneration = Effect.gen(function* () {
             "-",
           ],
           {
-            cwd,
-            shell: process.platform === "win32",
+            cwd: wslLaunch?.cwd ?? cwd,
+            shell: false,
             stdin: {
               stream: Stream.make(new TextEncoder().encode(prompt)),
             },

apps/server/src/provider/Layers/ProviderHealth.test.ts

@@ -4,7 +4,11 @@ import { Effect, Layer, Sink, Stream } from "effect";
 import * as PlatformError from "effect/PlatformError";
 import { ChildProcessSpawner } from "effect/unstable/process";
 
-import { checkCodexProviderStatus, parseAuthStatusFromOutput } from "./ProviderHealth";
+import {
+  checkCodexProviderStatus,
+  makeCheckCodexProviderStatus,
+  parseAuthStatusFromOutput,
+} from "./ProviderHealth";
 
 // ── Test helpers ────────────────────────────────────────────────────
 
@@ -26,13 +30,31 @@ function mockHandle(result: { stdout: string; stderr: string; code: number }) {
 }
 
 function mockSpawnerLayer(
-  handler: (args: ReadonlyArray<string>) => { stdout: string; stderr: string; code: number },
+  handler: (input: {
+    command: string;
+    args: ReadonlyArray<string>;
+  }) => { stdout: string; stderr: string; code: number },
 ) {
   return Layer.succeed(
     ChildProcessSpawner.ChildProcessSpawner,
     ChildProcessSpawner.make((command) => {
-      const cmd = command as unknown as { args: ReadonlyArray<string> };
-      return Effect.succeed(mockHandle(handler(cmd.args)));
+      const cmd = command as unknown as { command: string; args: ReadonlyArray<string> };
+      return Effect.try({
+        try: () =>
+          mockHandle(
+            handler({
+              command: cmd.command,
+              args: cmd.args,
+            }),
+          ),
+        catch: (cause) =>
+          PlatformError.systemError({
+            _tag: "BadResource",
+            module: "ChildProcess",
+            method: "spawn",
+            description: cause instanceof Error ? cause.message : String(cause),
+          }),
+      });
     }),
   );
 }
@@ -64,7 +86,7 @@ it.effect("returns ready when codex is installed and authenticated", () =>
     assert.strictEqual(status.authStatus, "authenticated");
   }).pipe(
     Effect.provide(
-      mockSpawnerLayer((args) => {
+      mockSpawnerLayer(({ args }) => {
         const joined = args.join(" ");
         if (joined === "--version") return { stdout: "codex 1.0.0\n", stderr: "", code: 0 };
         if (joined === "login status") return { stdout: "Logged in\n", stderr: "", code: 0 };
@@ -98,7 +120,7 @@ it.effect("returns unauthenticated when auth probe reports login required", () =
     );
   }).pipe(
     Effect.provide(
-      mockSpawnerLayer((args) => {
+      mockSpawnerLayer(({ args }) => {
         const joined = args.join(" ");
         if (joined === "--version") return { stdout: "codex 1.0.0\n", stderr: "", code: 0 };
         if (joined === "login status") {
@@ -125,7 +147,7 @@ it.effect(
       );
     }).pipe(
       Effect.provide(
-        mockSpawnerLayer((args) => {
+        mockSpawnerLayer(({ args }) => {
           const joined = args.join(" ");
           if (joined === "--version") return { stdout: "codex 1.0.0\n", stderr: "", code: 0 };
           if (joined === "login status")
@@ -149,7 +171,7 @@ it.effect("returns warning when login status command is unsupported", () =>
     );
   }).pipe(
     Effect.provide(
-      mockSpawnerLayer((args) => {
+      mockSpawnerLayer(({ args }) => {
         const joined = args.join(" ");
         if (joined === "--version") return { stdout: "codex 1.0.0\n", stderr: "", code: 0 };
         if (joined === "login status") {
@@ -161,6 +183,36 @@ it.effect("returns warning when login status command is unsupported", () =>
   ),
 );
 
+it.effect("falls back to WSL when codex is only available there on Windows", () =>
+  Effect.gen(function* () {
+    const status = yield* makeCheckCodexProviderStatus("win32");
+    assert.strictEqual(status.provider, "codex");
+    assert.strictEqual(status.status, "ready");
+    assert.strictEqual(status.available, true);
+    assert.strictEqual(status.authStatus, "authenticated");
+  }).pipe(
+    Effect.provide(
+      mockSpawnerLayer(({ args }) => {
+        const expectedVersionProbe =
+          '--exec /bin/sh -lc shell="${SHELL:-/bin/sh}"; exec "$shell" -l -i -c \'exec "$@"\' wsl-shell "$@" wsl-shell codex --version';
+        const expectedAuthProbe =
+          '--exec /bin/sh -lc shell="${SHELL:-/bin/sh}"; exec "$shell" -l -i -c \'exec "$@"\' wsl-shell "$@" wsl-shell codex login status';
+        const joined = args.join(" ");
+        if (joined === "--version") {
+          throw new Error("spawn codex ENOENT");
+        }
+        if (joined === expectedVersionProbe) {
+          return { stdout: "codex 1.0.0\n", stderr: "", code: 0 };
+        }
+        if (joined === expectedAuthProbe) {
+          return { stdout: "Logged in\n", stderr: "", code: 0 };
+        }
+        throw new Error(`Unexpected args: ${joined}`);
+      }),
+    ),
+  ),
+);
+
 // ── Pure function tests ─────────────────────────────────────────────
 
 it("parseAuthStatusFromOutput: exit code 0 with no auth markers is ready", () => {