sailfork / t3code-github / apps/ desktop/ src/ backend/ DesktopBackendConfiguration.test.ts

import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { assert, describe, it } from "@effect/vitest";
import { currentDesktopBootstrapToken } from "@t3tools/shared/desktopBootstrapToken";
import * as HostProcess from "@t3tools/shared/HostProcess";
import * as Clock from "effect/Clock";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Layer from "effect/Layer";
import * as ManagedRuntime from "effect/ManagedRuntime";
import * as Option from "effect/Option";
import * as Path from "effect/Path";
import * as Stream from "effect/Stream";
import { ChildProcessSpawner } from "effect/process";

import * as DesktopEnvironment from "../app/DesktopEnvironment.ts";
import * as DesktopManagedPolicy from "../app/DesktopManagedPolicy.ts";
import * as DesktopBackendConfiguration from "./DesktopBackendConfiguration.ts";
import * as DesktopShellEnvironment from "../shell/DesktopShellEnvironment.ts";
import * as DesktopConfig from "../app/DesktopConfig.ts";
import * as DesktopServerExposure from "./DesktopServerExposure.ts";
import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts";
import * as DesktopWslEnvironment from "../wsl/DesktopWslEnvironment.ts";
import * as DesktopWslServerTree from "../wsl/DesktopWslServerTree.ts";

const layerShellEnvironment = (prepared = true) =>
  Layer.succeed(DesktopShellEnvironment.DesktopShellEnvironment, {
    installIntoProcess: Effect.succeed(prepared),
    awaitDiscovery: Effect.succeed(prepared),
    updates: Stream.empty,
  });

const layerBackendConfiguration = (prepared = true) =>
  DesktopBackendConfiguration.layer.pipe(Layer.provide(layerShellEnvironment(prepared)));

const layerServerExposure = Layer.succeed(DesktopServerExposure.DesktopServerExposure, {
  getState: Effect.die("unexpected getState"),
  backendConfig: Effect.succeed({
    port: 4888,
    bindHost: "0.0.0.0",
    httpBaseUrl: new URL("http://127.0.0.1:4888"),
    tailscaleServeEnabled: true,
    tailscaleServePort: 8443,
  }),
  configureFromSettings: () => Effect.die("unexpected configureFromSettings"),
  setMode: () => Effect.die("unexpected setMode"),
  setTailscaleServeEnabled: () => Effect.die("unexpected setTailscaleServeEnabled"),
  getAdvertisedEndpoints: Effect.succeed([]),
} satisfies DesktopServerExposure.DesktopServerExposure["Service"]);

function layerEnvironment(
  baseDir: string,
  options?: {
    readonly appPath?: string;
    readonly dirname?: string;
    readonly isPackaged?: boolean;
    readonly devServerUrl?: string;
    readonly platform?: NodeJS.Platform;
    readonly resourcesPath?: string;
    readonly appVersion?: string;
    readonly processArch?: NodeJS.Architecture;
    readonly otlpTracesUrl?: string;
    readonly otlpMetricsUrl?: string;
    readonly otlpLogsUrl?: string;
  },
) {
  return DesktopEnvironment.layer({
    dirname: options?.dirname ?? "/repo/apps/desktop/src",
    homeDirectory: baseDir,
    platform: options?.platform ?? "darwin",
    processArch: options?.processArch ?? "x64",
    appVersion: options?.appVersion ?? "1.2.3",
    appPath: options?.appPath ?? "/repo",
    isPackaged: options?.isPackaged ?? true,
    resourcesPath: options?.resourcesPath ?? "/missing/resources",
    runningUnderArm64Translation: false,
  }).pipe(
    Layer.provide(
      Layer.mergeAll(
        NodeServices.layer,
        NodeCrypto.layer,
        DesktopConfig.layerTest({
          T3CODE_HOME: baseDir,
          T3CODE_PORT: "9999",
          T3CODE_MODE: "desktop",
          T3CODE_DESKTOP_LAN_HOST: "192.168.1.50",
          VITE_DEV_SERVER_URL: options?.devServerUrl,
          T3CODE_OTLP_TRACES_URL: options?.otlpTracesUrl,
          T3CODE_OTLP_METRICS_URL: options?.otlpMetricsUrl,
          T3CODE_OTLP_LOGS_URL: options?.otlpLogsUrl,
        }),
      ),
    ),
  );
}

const withHarness = <A, E, R>(
  effect: Effect.Effect<
    A,
    E,
    | R
    | DesktopEnvironment.DesktopEnvironment
    | FileSystem.FileSystem
    | DesktopBackendConfiguration.DesktopBackendConfiguration
  >,
  prepared = true,
) =>
  Effect.gen(function* () {
    const fileSystem = yield* FileSystem.FileSystem;
    const baseDir = yield* fileSystem.makeTempDirectoryScoped({
      prefix: "t3-desktop-backend-config-test-",
    });

    return yield* effect.pipe(
      Effect.provide(
        layerBackendConfiguration(prepared).pipe(
          Layer.provideMerge(layerServerExposure),
          Layer.provideMerge(DesktopAppSettings.layerTest()),
          Layer.provideMerge(DesktopWslEnvironment.layerTest()),
          Layer.provideMerge(DesktopWslServerTree.layerTest()),
          Layer.provideMerge(layerEnvironment(baseDir)),
        ),
      ),
    );
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)));

interface PackagedWslHarnessContext {
  readonly baseDir: string;
  readonly archivePath: string;
  readonly hashPath: string;
  readonly archiveHash: string;
  readonly mountedAppRoot: string;
  readonly mountedEntryPath: string;
}

const withPackagedWslHarness = <A, E, R>(
  input: {
    readonly archiveHash: string;
    readonly wsl: (
      context: PackagedWslHarnessContext,
    ) => DesktopWslEnvironment.DesktopWslEnvironmentTestStub;
    readonly forbidFallback?: string;
    readonly cleanupLegacy?: Effect.Effect<void>;
    readonly forbidCleanup?: string;
  },
  effect: (
    context: PackagedWslHarnessContext,
  ) => Effect.Effect<
    A,
    E,
    R | FileSystem.FileSystem | Path.Path | DesktopBackendConfiguration.DesktopBackendConfiguration
  >,
) =>
  Effect.gen(function* () {
    const fileSystem = yield* FileSystem.FileSystem;
    const path = yield* Path.Path;
    const baseDir = yield* fileSystem.makeTempDirectoryScoped({
      prefix: "t3-desktop-backend-config-test-",
    });
    const archivePath = path.join(baseDir, "wsl-runtime.tar.gz");
    const hashPath = `${archivePath}.sha256`;
    const mountedAppRoot = "/mnt/c/app.asar.unpacked";
    const mountedEntryPath = path.join(baseDir, "app.asar.unpacked/apps/server/dist/bin.mjs");
    yield* fileSystem.makeDirectory(path.dirname(mountedEntryPath), { recursive: true });
    yield* fileSystem.writeFileString(mountedEntryPath, "");
    yield* fileSystem.writeFileString(archivePath, "archive");
    yield* fileSystem.writeFileString(hashPath, `${input.archiveHash}\n`);

    const context = {
      baseDir,
      archivePath,
      hashPath,
      archiveHash: input.archiveHash,
      mountedAppRoot,
      mountedEntryPath,
    } satisfies PackagedWslHarnessContext;
    const layerServerTree = input.forbidFallback
      ? Layer.succeed(
          DesktopWslServerTree.DesktopWslServerTree,
          DesktopWslServerTree.DesktopWslServerTree.of({
            ensure: Effect.die(input.forbidFallback),
            cleanupLegacy: input.forbidCleanup
              ? Effect.die(input.forbidCleanup)
              : (input.cleanupLegacy ?? Effect.void),
          }),
        )
      : DesktopWslServerTree.layerTest({
          result: { ok: true, root: path.join(baseDir, "app.asar.unpacked") },
          cleanupLegacy: input.cleanupLegacy ?? Effect.void,
        });

    return yield* effect(context).pipe(
      Effect.provide(
        layerBackendConfiguration().pipe(
          Layer.provideMerge(layerServerExposure),
          Layer.provideMerge(DesktopAppSettings.layerTest()),
          Layer.provideMerge(layerServerTree),
          Layer.provideMerge(
            DesktopWslEnvironment.layerTest({
              isAvailable: true,
              distros: [{ name: "Ubuntu", isDefault: true, version: 2 }],
              windowsToWslPath: () => Option.some(mountedAppRoot),
              getDistroIp: () => Option.some("172.27.0.99"),
              ...input.wsl(context),
            }),
          ),
          Layer.provideMerge(
            layerEnvironment(baseDir, {
              appPath: baseDir,
              platform: "win32",
              resourcesPath: baseDir,
            }),
          ),
        ),
      ),
    );
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)));

describe("DesktopBackendConfiguration", () => {
  it.effect("resolvePrimary produces a stable scoped bootstrap token", () =>
    withHarness(
      Effect.gen(function* () {
        const environment = yield* DesktopEnvironment.DesktopEnvironment;
        const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration;

        const first = yield* configuration.resolvePrimary;
        const second = yield* configuration.resolvePrimary;

        assert.equal(first.executablePath, process.execPath);
        assert.deepEqual(first.args.slice(0, 3), [
          "--require",
          environment.compileCachePath,
          environment.backendEntryPath,
        ]);
        assert.equal(first.entryPath, environment.backendEntryPath);
        assert.equal(first.cwd, environment.backendCwd);
        assert.equal(first.captureOutput, true);
        assert.equal(first.env.ELECTRON_RUN_AS_NODE, "1");
        assert.equal(first.env.T3CODE_DESKTOP_SHELL_DISCOVERY_PENDING, "1");
        assert.isUndefined(first.env.T3CODE_PORT);
        assert.isUndefined(first.env.T3CODE_MODE);
        assert.isUndefined(first.env.T3CODE_DESKTOP_LAN_HOST);

        assert.equal(first.bootstrap.mode, "desktop");
        assert.equal(first.bootstrap.noBrowser, true);
        assert.equal(first.bootstrap.port, 4888);
        assert.equal(first.bootstrap.host, "0.0.0.0");
        assert.equal(first.bootstrap.t3Home, environment.baseDir);
        assert.equal(first.bootstrap.tailscaleServeEnabled, true);
        assert.equal(first.bootstrap.tailscaleServePort, 8443);
        assert.match(first.bootstrap.desktopBootstrapSecret ?? "", /^[0-9a-f]{64}$/i);
        assert.equal(
          second.bootstrap.desktopBootstrapSecret,
          first.bootstrap.desktopBootstrapSecret,
        );
        assert.equal(
          first.bootstrap.desktopBootstrapToken,
          yield* currentDesktopBootstrapToken(
            first.bootstrap.desktopBootstrapSecret ?? "",
            yield* Clock.currentTimeMillis,
          ).pipe(Effect.provide(NodeCrypto.layerMac)),
        );
        assert.equal(
          yield* configuration.currentBootstrapToken,
          first.bootstrap.desktopBootstrapToken,
        );
      }),
    ),
  );

  it.effect("resolvePrimary starts from server.asar without materializing the WSL tree", () =>
    Effect.gen(function* () {
      const fileSystem = yield* FileSystem.FileSystem;
      const path = yield* Path.Path;
      const baseDir = yield* fileSystem.makeTempDirectoryScoped({
        prefix: "t3-desktop-backend-config-test-",
      });
      const resourcesPath = path.join(baseDir, "resources");

      const config = yield* Effect.gen(function* () {
        const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration;
        return yield* configuration.resolvePrimary;
      }).pipe(
        Effect.provide(
          layerBackendConfiguration().pipe(
            Layer.provideMerge(layerServerExposure),
            Layer.provideMerge(DesktopAppSettings.layerTest()),
            Layer.provideMerge(DesktopWslEnvironment.layerTest()),
            Layer.provideMerge(
              Layer.succeed(
                DesktopWslServerTree.DesktopWslServerTree,
                DesktopWslServerTree.DesktopWslServerTree.of({
                  ensure: Effect.die("Windows primary must not extract the WSL server tree"),
                  cleanupLegacy: Effect.die("Windows primary must not clean the WSL server tree"),
                }),
              ),
            ),
            Layer.provideMerge(
              layerEnvironment(baseDir, {
                appPath: `${resourcesPath}/app.asar`,
                platform: "win32",
                resourcesPath,
              }),
            ),
          ),
        ),
      );

      assert.equal(
        config.entryPath,
        path.join(resourcesPath, "server.asar/apps/server/dist/bin.mjs"),
      );
      assert.equal(config.env.ELECTRON_RUN_AS_NODE, "1");
    }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
  );

  it.effect("resolveWsl pins a default-tracking run to the concrete default distro", () =>
    Effect.gen(function* () {
      const fileSystem = yield* FileSystem.FileSystem;
      const path = yield* Path.Path;
      const baseDir = yield* fileSystem.makeTempDirectoryScoped({
        prefix: "t3-desktop-backend-config-test-",
      });
      const entryPath = path.join(baseDir, "apps/server/dist/bin.mjs");
      yield* fileSystem.makeDirectory(path.dirname(entryPath), { recursive: true });
      yield* fileSystem.writeFileString(entryPath, "");

      const observedDistros: Array<string | null> = [];
      const config = yield* Effect.gen(function* () {
        const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration;
        return yield* configuration.resolveWsl({ port: 5000, distro: null });
      }).pipe(
        Effect.provide(
          layerBackendConfiguration().pipe(
            Layer.provideMerge(layerServerExposure),
            Layer.provideMerge(DesktopAppSettings.layerTest()),
            Layer.provideMerge(DesktopWslServerTree.layerTest()),
            Layer.provideMerge(
              DesktopWslEnvironment.layerTest({
                isAvailable: true,
                distros: [
                  { name: "Debian", isDefault: false, version: 2 },
                  { name: "Ubuntu", isDefault: true, version: 2 },
                ],
                windowsToWslPath: (distro) => {
                  observedDistros.push(distro);
                  return Option.some("/repo");
                },
                ensureNodePty: (distro) => {
                  observedDistros.push(distro);
                  return { ok: true, nodePath: "/usr/bin/node", resolvedPath: "/usr/bin:/bin" };
                },
                getDistroIp: (distro) => {
                  observedDistros.push(distro);
                  return Option.some("172.27.0.99");
                },
              }),
            ),
            Layer.provideMerge(
              layerEnvironment(baseDir, {
                appPath: baseDir,
                platform: "win32",
                resourcesPath: baseDir,
              }),
            ),
          ),
        ),
      );

      assert.equal(config.runningDistro, "Ubuntu");
      assert.deepEqual(config.args.slice(0, 2), ["-d", "Ubuntu"]);
      assert.deepEqual(observedDistros, ["Ubuntu", "Ubuntu", "Ubuntu"]);
      assert.isTrue(Option.isNone(config.preflightFailure));
    }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
  );

  it.effect("resolveWsl launches a packaged backend from the WSL-local runtime cache", () => {
    const observedArchives: Array<{
      windowsArchivePath: string;
      runtimeId: string;
      sha256: string;
    }> = [];
    const observedProbeRoots: string[] = [];
    let legacyCleanupCount = 0;
    const linuxAppRoot = "/home/test/.t3/wsl-runtime/1.2.3-x64";
    const resolvedPath = "/home/test/.local/bin:/usr/bin:/bin";

    return withPackagedWslHarness(
      {
        archiveHash: "a".repeat(64),
        forbidFallback: "A valid WSL archive must not extract the Windows fallback",
        cleanupLegacy: Effect.sync(() => {
          legacyCleanupCount += 1;
        }),
        wsl: () => ({
          prepareRuntime: (_distro, archive) => {
            observedArchives.push({
              windowsArchivePath: archive.windowsPath,
              runtimeId: archive.runtimeId,
              sha256: archive.sha256,
            });
            return { ok: true, linuxAppRoot };
          },
          probeRuntime: (_distro, root) => {
            observedProbeRoots.push(root);
            return { ok: true, resolvedPath };
          },
          ensureNodePty: () => {
            throw new Error("the staged runtime must not probe for node-pty");
          },
        }),
      },
      ({ archiveHash, archivePath, baseDir }) =>
        Effect.gen(function* () {
          const path = yield* Path.Path;
          const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration;
          const config = yield* configuration.resolveWsl({ port: 5000, distro: "Ubuntu" });

          assert.deepEqual(observedArchives, [
            {
              windowsArchivePath: archivePath,
              runtimeId: `sha256-${archiveHash}`,
              sha256: archiveHash,
            },
          ]);
          assert.deepEqual(observedProbeRoots, [linuxAppRoot]);
          assert.equal(
            config.entryPath,
            path.join(baseDir, "server.asar/apps/server/dist/bin.mjs"),
          );
          assert.deepEqual(config.args, [
            "-d",
            "Ubuntu",
            "--exec",
            "env",
            `PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:${resolvedPath}`,
            `${linuxAppRoot}/t3`,
            "--bootstrap-fd",
            "0",
          ]);
          assert.notInclude(config.args, "/usr/bin/node");
          assert.equal(config.wslRuntimeId, `sha256-${archiveHash}`);
          assert.equal(legacyCleanupCount, 1);
          assert.isTrue(Option.isNone(config.preflightFailure));
        }),
    );
  });

  it.effect("resolveWsl changes the cache id when the packaged archive changes", () => {
    const firstHash = "a".repeat(64);
    const secondHash = "b".repeat(64);
    const observedRuntimeIds: string[] = [];
    return withPackagedWslHarness(
      {
        archiveHash: firstHash,
        wsl: () => ({
          prepareRuntime: (_distro, archive) => {
            observedRuntimeIds.push(archive.runtimeId);
            return { ok: true, linuxAppRoot: `/runtime/${archive.runtimeId}` };
          },
          ensureNodePty: () => ({
            ok: true,
            nodePath: "/usr/bin/node",
            resolvedPath: "/usr/bin:/bin",
          }),
        }),
      },
      ({ hashPath, mountedAppRoot }) =>
        Effect.gen(function* () {
          const fileSystem = yield* FileSystem.FileSystem;
          const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration;
          const first = yield* configuration.resolveWsl({ port: 5000, distro: "Ubuntu" });
          yield* fileSystem.writeFileString(hashPath, secondHash);
          const second = yield* configuration.resolveWsl({ port: 5000, distro: "Ubuntu" });
          yield* fileSystem.writeFileString(hashPath, "not-a-sha256");
          const invalidIdentity = yield* configuration.resolveWsl({ port: 5000, distro: "Ubuntu" });

          assert.deepEqual(observedRuntimeIds, [`sha256-${firstHash}`, `sha256-${secondHash}`]);
          assert.equal(first.wslRuntimeId, observedRuntimeIds[0]);
          assert.include(first.args, `/runtime/sha256-${firstHash}/t3`);
          assert.equal(second.wslRuntimeId, observedRuntimeIds[1]);
          assert.include(second.args, `/runtime/sha256-${secondHash}/t3`);
          assert.isUndefined(invalidIdentity.wslRuntimeId);
          assert.include(invalidIdentity.args, "/usr/bin/node");
          assert.include(invalidIdentity.args, `${mountedAppRoot}/apps/server/dist/bin.mjs`);
        }),
    );
  });

  it.effect("resolveWsl falls back to the mounted runtime when archive staging fails", () => {
    const observedNodePtyRoots: string[] = [];
    return withPackagedWslHarness(
      {
        archiveHash: "b".repeat(64),
        wsl: () => ({
          prepareRuntime: () => ({ ok: false, reason: "archive is corrupt" }),
          invalidateRuntime: () => Effect.die("failed staging must not invalidate a runtime"),
          ensureNodePty: (_distro, root) => {
            observedNodePtyRoots.push(root);
            return { ok: true, nodePath: "/usr/bin/node", resolvedPath: "/usr/bin:/bin" };
          },
        }),
      },
      ({ mountedAppRoot, mountedEntryPath }) =>
        Effect.gen(function* () {
          const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration;
          const config = yield* configuration.resolveWsl({ port: 5000, distro: "Ubuntu" });

          assert.deepEqual(observedNodePtyRoots, [mountedAppRoot]);
          assert.equal(config.entryPath, mountedEntryPath);
          assert.include(config.args, "/usr/bin/node");
          assert.include(config.args, `${mountedAppRoot}/apps/server/dist/bin.mjs`);
          assert.isUndefined(config.wslRuntimeId);
          assert.isTrue(Option.isNone(config.preflightFailure));
        }),
    );
  });

  it.effect("resolveWsl retires a staged runtime whose executable does not start", () => {
    const archiveHash = "c".repeat(64);
    const stagedAppRoot = `/home/test/.t3/wsl-runtime/sha256-${archiveHash}`;
    const observedProbeRoots: string[] = [];
    const observedNodePtyRoots: string[] = [];
    const invalidatedRuntimeIds: string[] = [];
    return withPackagedWslHarness(
      {
        archiveHash,
        wsl: () => ({
          prepareRuntime: () => ({ ok: true, linuxAppRoot: stagedAppRoot }),
          invalidateRuntime: (_distro, runtimeId) =>
            Effect.sync(() => {
              invalidatedRuntimeIds.push(runtimeId);
            }),
          probeRuntime: (_distro, root) => {
            observedProbeRoots.push(root);
            return { ok: false, reason: `${root}/t3 --version failed (exit 127)` };
          },
          ensureNodePty: (_distro, root) => {
            observedNodePtyRoots.push(root);
            return { ok: true, nodePath: "/usr/bin/node", resolvedPath: "/usr/bin:/bin" };
          },
        }),
      },
      ({ mountedAppRoot, mountedEntryPath }) =>
        Effect.gen(function* () {
          const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration;
          const config = yield* configuration.resolveWsl({ port: 5000, distro: "Ubuntu" });

          assert.deepEqual(observedProbeRoots, [stagedAppRoot]);
          assert.deepEqual(observedNodePtyRoots, [mountedAppRoot]);
          assert.include(config.args, "/usr/bin/node");
          assert.include(config.args, `${mountedAppRoot}/apps/server/dist/bin.mjs`);
          assert.notInclude(config.args, `${stagedAppRoot}/t3`);
          assert.equal(config.entryPath, mountedEntryPath);
          assert.isUndefined(config.wslRuntimeId);
          assert.isTrue(Option.isNone(config.preflightFailure));
          assert.deepEqual(invalidatedRuntimeIds, [`sha256-${archiveHash}`]);
        }),
    );
  });

  it.effect("resolveWsl keeps WSL retryable when the mounted fallback fails transiently", () => {
    const stagedAppRoot = "/home/test/.t3/wsl-runtime/cache";
    const invalidatedRuntimeIds: string[] = [];
    return withPackagedWslHarness(
      {
        archiveHash: "f".repeat(64),
        wsl: () => ({
          prepareRuntime: () => ({ ok: true, linuxAppRoot: stagedAppRoot }),
          invalidateRuntime: (_distro, runtimeId) =>
            Effect.sync(() => {
              invalidatedRuntimeIds.push(runtimeId);
            }),
          probeRuntime: () => ({ ok: false, reason: "t3 --version failed (exit 1)" }),
          ensureNodePty: () => ({
            ok: false,
            reason: "WSL backend preflight timed out while probing for Node.js.",
            fatal: false,
          }),
        }),
      },
      () =>
        Effect.gen(function* () {
          const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration;
          const config = yield* configuration.resolveWsl({ port: 5000, distro: "Ubuntu" });
          const failure = Option.getOrThrow(config.preflightFailure);

          assert.isFalse(failure.fatal);
          assert.equal(failure.retryLimit, 12);
          assert.include(failure.reason, "timed out");
          assert.deepEqual(invalidatedRuntimeIds, []);
        }),
    );
  });

  it.effect(
    "resolveWsl preserves inherited PATH with quote-sensitive values as separate args",
    () =>
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const path = yield* Path.Path;
        const baseDir = yield* fileSystem.makeTempDirectoryScoped({
          prefix: "t3-desktop-backend-config-test-",
        });
        const entryPath = path.join(baseDir, "apps/server/dist/bin.mjs");
        yield* fileSystem.makeDirectory(path.dirname(entryPath), { recursive: true });
        yield* fileSystem.writeFileString(entryPath, "");

        const nodePath = "/home/test user's/.nvm/versions/node/v22.0.0/bin/node";
        const linuxAppRoot = "/tmp/t3 code's launch";
        const linuxEntryPath = `${linuxAppRoot}/apps/server/dist/bin.mjs`;
        const resolvedPath = "/home/test user/bin:/opt/test's tools/bin:/usr/bin:/bin";
        const devServerUrl = "http://127.0.0.1:5733/dev%20assets/?label=hello%20world";
        const config = yield* Effect.gen(function* () {
          const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration;
          return yield* configuration.resolveWsl({ port: 5000, distro: "Ubuntu" });
        }).pipe(
          Effect.provide(
            layerBackendConfiguration().pipe(
              Layer.provideMerge(layerServerExposure),
              Layer.provideMerge(DesktopAppSettings.layerTest()),
              Layer.provideMerge(DesktopWslServerTree.layerTest()),
              Layer.provideMerge(
                DesktopWslEnvironment.layerTest({
                  isAvailable: true,
                  distros: [{ name: "Ubuntu", isDefault: true, version: 2 }],
                  windowsToWslPath: () => Option.some(linuxAppRoot),
                  ensureNodePty: () => ({ ok: true, nodePath, resolvedPath }),
                  getDistroIp: () => Option.some("172.27.0.99"),
                }),
              ),
              Layer.provideMerge(
                layerEnvironment(baseDir, {
                  appPath: baseDir,
                  devServerUrl,
                  isPackaged: true,
                  platform: "win32",
                  resourcesPath: baseDir,
                }),
              ),
            ),
          ),
        );

        assert.equal(config.bootstrapDelivery, "stdin");
        assert.deepEqual(config.args, [
          "-d",
          "Ubuntu",
          "--exec",
          "env",
          "PATH=/home/test user's/.nvm/versions/node/v22.0.0/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/home/test user/bin:/opt/test's tools/bin:/usr/bin:/bin",
          nodePath,
          linuxEntryPath,
          "--bootstrap-fd",
          "0",
          "--dev-url",
          devServerUrl,
        ]);
        assert.notInclude(config.args, "bash");
        assert.notInclude(config.args, "/bin/sh");
        assert.notInclude(config.args, "-c");
        assert.isTrue(Option.isNone(config.preflightFailure));
      }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
  );

  it.effect("resolvePrimary and resolveWsl share one token under concurrent resolution", () =>
    withHarness(
      Effect.gen(function* () {
        const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration;

        const [primary, wsl] = yield* Effect.all(
          [configuration.resolvePrimary, configuration.resolveWsl({ port: 5000, distro: null })],
          { concurrency: "unbounded" },
        );

        assert.equal(wsl.bootstrap.desktopBootstrapToken, primary.bootstrap.desktopBootstrapToken);
      }),
    ),
  );

  it.effect("resolveWsl carries the kill switch and resource attributes into the distro", () =>
    Effect.gen(function* () {
      const fileSystem = yield* FileSystem.FileSystem;
      const baseDir = yield* fileSystem.makeTempDirectoryScoped({
        prefix: "t3-desktop-backend-config-test-",
      });

      yield* Effect.gen(function* () {
        const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration;
        const config = yield* configuration.resolveWsl({ port: 5050, distro: null });

        assert.equal(config.env.OTEL_SDK_DISABLED, "true");
        assert.include((config.env.WSLENV ?? "").split(":"), "OTEL_SDK_DISABLED");
        assert.equal(config.env.T3CODE_TELEMETRY_ENABLED, "false");
        assert.include((config.env.WSLENV ?? "").split(":"), "T3CODE_TELEMETRY_ENABLED");
        assert.equal(config.env.OTEL_RESOURCE_ATTRIBUTES, "deployment.environment.name=staging");
        assert.include((config.env.WSLENV ?? "").split(":"), "OTEL_RESOURCE_ATTRIBUTES");
      }).pipe(
        Effect.provide(
          layerBackendConfiguration().pipe(
            Layer.provideMerge(layerServerExposure),
            Layer.provideMerge(DesktopAppSettings.layerTest()),
            Layer.provideMerge(DesktopWslServerTree.layerTest()),
            Layer.provideMerge(
              DesktopWslEnvironment.layerTest({
                isAvailable: true,
                windowsToWslPath: () => Option.some("/mnt/c/repo/apps/server/src/index.ts"),
                getDistroIp: () => Option.some("172.27.0.99"),
              }),
            ),
            Layer.provideMerge(layerEnvironment(baseDir, { platform: "win32" })),
          ),
        ),
        Effect.provideService(HostProcess.Environment, {
          OTEL_SDK_DISABLED: "true",
          T3CODE_TELEMETRY_ENABLED: "false",
          OTEL_RESOURCE_ATTRIBUTES: "deployment.environment.name=staging",
        }),
      );
    }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
  );

  it.effect("resolveWsl preserves existing WSLENV entries when forwarding backend secrets", () =>
    Effect.gen(function* () {
      const fileSystem = yield* FileSystem.FileSystem;
      const baseDir = yield* fileSystem.makeTempDirectoryScoped({
        prefix: "t3-desktop-backend-config-test-",
      });

      yield* Effect.gen(function* () {
        const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration;
        const config = yield* configuration.resolveWsl({ port: 5050, distro: null });

        assert.equal(config.executablePath, "wsl.exe");
        assert.equal(config.bootstrap.port, 5050);
        assert.equal(config.bootstrap.host, "0.0.0.0");
        assert.equal(config.bootstrap.tailscaleServeEnabled, false);
        assert.notProperty(config.bootstrap, "desktopTelemetryFd");
        assert.notProperty(config.bootstrap, "resourceMonitorPath");
        assert.equal(config.httpBaseUrl.href, "http://172.27.0.99:5050/");
        assert.equal(config.env.OPENAI_API_KEY, "openai-key");
        assert.equal(config.env.ANTHROPIC_API_KEY, "anthropic-key");
        assert.equal(config.env.T3CODE_OTLP_PROTOCOL, "http/protobuf");
        assert.equal(
          config.env.WSLENV,
          "GOPATH/p:OPENAI_API_KEY/u:EMPTY::AZURE_DEVOPS_EXT_PAT/u:ANTHROPIC_API_KEY:T3CODE_OTLP_HEADERS:T3CODE_OTLP_PROTOCOL",
        );
      }).pipe(
        Effect.provide(
          layerBackendConfiguration().pipe(
            Layer.provideMerge(layerServerExposure),
            Layer.provideMerge(DesktopAppSettings.layerTest()),
            Layer.provideMerge(DesktopWslServerTree.layerTest()),
            Layer.provideMerge(
              DesktopWslEnvironment.layerTest({
                isAvailable: true,
                windowsToWslPath: () => Option.some("/mnt/c/repo/apps/server/src/index.ts"),
                getDistroIp: () => Option.some("172.27.0.99"),
              }),
            ),
            Layer.provideMerge(layerEnvironment(baseDir, { platform: "win32" })),
          ),
        ),
        Effect.provideService(HostProcess.Environment, {
          WSLENV: "GOPATH/p:OPENAI_API_KEY/u:EMPTY::AZURE_DEVOPS_EXT_PAT/u",
          OPENAI_API_KEY: "openai-key",
          ANTHROPIC_API_KEY: "anthropic-key",
          T3CODE_OTLP_HEADERS: 'authorization="Bearer%20my-token"',
          T3CODE_OTLP_PROTOCOL: "http/protobuf",
        }),
      );
    }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
  );

  it.effect(
    "resolvePrimary falls back to the Windows primary when wsl-only but WSL is unavailable",
    () =>
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const baseDir = yield* fileSystem.makeTempDirectoryScoped({
          prefix: "t3-desktop-backend-config-test-",
        });

        yield* Effect.gen(function* () {
          const environment = yield* DesktopEnvironment.DesktopEnvironment;
          const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration;
          const config = yield* configuration.resolvePrimary;

          assert.equal(config.executablePath, process.execPath);
          assert.equal(config.bootstrap.t3Home, environment.baseDir);
          assert.isTrue(Option.isNone(config.preflightFailure));
        }).pipe(
          Effect.provide(
            layerBackendConfiguration().pipe(
              Layer.provideMerge(layerServerExposure),
              Layer.provideMerge(
                DesktopAppSettings.layerTest({
                  ...DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS,
                  wslBackendEnabled: true,
                  wslOnly: true,
                }),
              ),
              Layer.provideMerge(DesktopWslServerTree.layerTest()),
              Layer.provideMerge(DesktopWslEnvironment.layerTest({ isAvailable: false })),
              Layer.provideMerge(layerEnvironment(baseDir, { platform: "win32" })),
            ),
          ),
        );
      }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
  );

  it.effect(
    "resolvePrimary marks a removed persisted WSL distro as a fatal preflight failure",
    () =>
      Effect.gen(function* () {
        const fileSystem = yield* FileSystem.FileSystem;
        const baseDir = yield* fileSystem.makeTempDirectoryScoped({
          prefix: "t3-desktop-backend-config-test-",
        });

        yield* Effect.gen(function* () {
          const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration;
          const config = yield* configuration.resolvePrimary;
          const failure = Option.getOrThrow(config.preflightFailure);

          assert.equal(config.executablePath, "wsl.exe");
          assert.isTrue(failure.fatal);
          assert.include(failure.reason, "Removed-Distro");
        }).pipe(
          Effect.provide(
            layerBackendConfiguration().pipe(
              Layer.provideMerge(layerServerExposure),
              Layer.provideMerge(
                DesktopAppSettings.layerTest({
                  ...DesktopAppSettings.DEFAULT_DESKTOP_SETTINGS,
                  wslBackendEnabled: true,
                  wslOnly: true,
                  wslDistro: "Removed-Distro",
                }),
              ),
              Layer.provideMerge(DesktopWslServerTree.layerTest()),
              Layer.provideMerge(
                DesktopWslEnvironment.layerTest({
                  isAvailable: true,
                  distros: [{ name: "Ubuntu", isDefault: true, version: 2 }],
                }),
              ),
              Layer.provideMerge(layerEnvironment(baseDir, { platform: "win32" })),
            ),
          ),
        );
      }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
  );

  it.effect("resolveWsl marks a missing packaged server entry as fatal", () =>
    Effect.gen(function* () {
      const fileSystem = yield* FileSystem.FileSystem;
      const baseDir = yield* fileSystem.makeTempDirectoryScoped({
        prefix: "t3-desktop-backend-config-test-",
      });

      yield* Effect.gen(function* () {
        const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration;
        const config = yield* configuration.resolveWsl({ port: 5050, distro: "Ubuntu" });
        const failure = Option.getOrThrow(config.preflightFailure);

        assert.isTrue(failure.fatal);
        assert.include(failure.reason, "missing server entry");
      }).pipe(
        Effect.provide(
          layerBackendConfiguration().pipe(
            Layer.provideMerge(layerServerExposure),
            Layer.provideMerge(DesktopAppSettings.layerTest()),
            Layer.provideMerge(DesktopWslServerTree.layerTest()),
            Layer.provideMerge(
              DesktopWslEnvironment.layerTest({
                isAvailable: true,
                distros: [{ name: "Ubuntu", isDefault: true, version: 2 }],
              }),
            ),
            Layer.provideMerge(layerEnvironment(baseDir, { platform: "win32" })),
          ),
        ),
      );
    }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
  );

  it.effect("prefers the external packaged resource monitor over the copy inside the asar", () =>
    Effect.gen(function* () {
      const fileSystem = yield* FileSystem.FileSystem;
      const path = yield* Path.Path;
      const baseDir = yield* fileSystem.makeTempDirectoryScoped({
        prefix: "t3-desktop-backend-config-test-",
      });
      const resourcesPath = path.join(baseDir, "resources");
      const dirname = `${resourcesPath}/app.asar/apps/desktop/dist-electron`;
      const embeddedMonitorPath = `${resourcesPath}/app.asar/apps/desktop/prod-resources/resource-monitor/t3-resource-monitor`;
      const monitorPath = path.join(resourcesPath, "resource-monitor/t3-resource-monitor");
      yield* fileSystem.makeDirectory(
        `${resourcesPath}/app.asar/apps/desktop/prod-resources/resource-monitor`,
        { recursive: true },
      );
      yield* fileSystem.makeDirectory(`${resourcesPath}/resource-monitor`, {
        recursive: true,
      });
      yield* fileSystem.writeFileString(embeddedMonitorPath, "embedded");
      yield* fileSystem.writeFileString(monitorPath, "binary");
      yield* fileSystem.chmod(monitorPath, 0o755);

      yield* Effect.gen(function* () {
        const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration;
        const config = yield* configuration.resolvePrimary;
        assert.equal(config.bootstrap.resourceMonitorPath, monitorPath);
        assert.equal(config.bootstrap.desktopTelemetryFd, 4);
        assert.equal(config.bootstrap.desktopTelemetryControlFd, 5);
      }).pipe(
        Effect.provide(
          layerBackendConfiguration().pipe(
            Layer.provideMerge(layerServerExposure),
            Layer.provideMerge(DesktopAppSettings.layerTest()),
            Layer.provideMerge(DesktopWslServerTree.layerTest()),
            Layer.provideMerge(DesktopWslEnvironment.layerTest()),
            Layer.provideMerge(
              layerEnvironment(baseDir, {
                appPath: `${resourcesPath}/app.asar`,
                dirname,
                isPackaged: true,
                resourcesPath,
              }),
            ),
          ),
        ),
      );
    }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
  );

  it("resolvePrimaryLabel is runSync-safe against the real WSL availability probe", async () => {
    // oxlint-disable-next-line t3code/no-manual-effect-runtime-in-tests -- This test intentionally replicates the sync IPC handler's runSync path to catch a regression to async-only resolution; it.effect would mask it.
    const runtime = ManagedRuntime.make(
      layerBackendConfiguration().pipe(
        Layer.provideMerge(layerServerExposure),
        Layer.provideMerge(DesktopAppSettings.layerTest()),
        Layer.provideMerge(DesktopWslServerTree.layerTest()),
        Layer.provideMerge(DesktopWslEnvironment.layer),
        Layer.provideMerge(DesktopManagedPolicy.layerTest()),
        Layer.provideMerge(
          Layer.succeed(
            ChildProcessSpawner.ChildProcessSpawner,
            ChildProcessSpawner.make(() =>
              Effect.die("spawner should not be used while probing WSL availability"),
            ),
          ),
        ),
        Layer.provideMerge(layerEnvironment("/tmp/t3-wsl-isavailable", { platform: "win32" })),
        Layer.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer)),
      ),
    );
    try {
      const configuration = await runtime.runPromise(
        DesktopBackendConfiguration.DesktopBackendConfiguration,
      );
      // oxlint-disable-next-line t3code/no-manual-effect-runtime-in-tests -- Same reason: this is the synchronous resolution the IPC handler performs.
      const label = Effect.runSync(configuration.resolvePrimaryLabel);
      assert.equal(typeof label, "string");
    } finally {
      await runtime.dispose();
    }
  });
});