import * as Cause from "effect/Cause"; import * as Context from "effect/Context"; import * as Effect from "effect/Effect"; import * as Layer from "effect/Layer"; import * as Option from "effect/Option"; import * as Ref from "effect/Ref"; import * as Semaphore from "effect/Semaphore"; import * as NetService from "@t3tools/shared/Net"; import * as DesktopObservability from "../app/DesktopObservability.ts"; import * as DesktopBackendConfiguration from "../backend/DesktopBackendConfiguration.ts"; import * as DesktopBackendPool from "../backend/DesktopBackendPool.ts"; import * as DesktopServerExposure from "../backend/DesktopServerExposure.ts"; import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts"; import * as DesktopWslEnvironment from "./DesktopWslEnvironment.ts"; export const WSL_INSTANCE_ID_PREFIX = "wsl:"; const WSL_DEFAULT_DISTRO_ID = `${WSL_INSTANCE_ID_PREFIX}default`; const MAX_TCP_PORT = 65_535; export class DesktopWslBackend extends Context.Service< DesktopWslBackend, { readonly reconcile: Effect.Effect; readonly lastPreflightError: Effect.Effect>; } >()("@t3tools/desktop/wsl/DesktopWslBackend") {} const { logInfo: logWslBackendInfo, logWarning: logWslBackendWarning } = DesktopObservability.makeComponentLogger("desktop-wsl-backend"); const resolveTargetInstanceId = (distro: string | null): DesktopBackendPool.BackendInstanceId => DesktopBackendPool.BackendInstanceId( distro === null ? WSL_DEFAULT_DISTRO_ID : `${WSL_INSTANCE_ID_PREFIX}${distro}`, ); const isWslInstanceId = (id: DesktopBackendPool.BackendInstanceId): boolean => id.startsWith(WSL_INSTANCE_ID_PREFIX); const buildLabel = (distro: string | null): string => distro === null ? "WSL (default distro)" : `WSL (${distro})`; // WSL auto-forwards loopback ports, so only IPv4 loopback availability matters. const scanForWslPort = Effect.fn("desktop.wslBackend.scanForWslPort")(function* ( startPort: number, ): Effect.fn.Return { const net = yield* NetService.NetService; for (let port = startPort; port <= MAX_TCP_PORT; port += 1) { if (yield* net.canListenOnHost(port, "127.0.0.1")) { return port; } } return yield* new NetService.NetError({ message: `No loopback port available for WSL backend between ${startPort} and ${MAX_TCP_PORT}.`, }); }); export const layer = Layer.effect( DesktopWslBackend, Effect.gen(function* () { const pool = yield* DesktopBackendPool.DesktopBackendPool; const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration; const serverExposure = yield* DesktopServerExposure.DesktopServerExposure; const wslEnvironment = yield* DesktopWslEnvironment.DesktopWslEnvironment; const appSettings = yield* DesktopAppSettings.DesktopAppSettings; const net = yield* NetService.NetService; // Serialize bootstrap and IPC reconciles so concurrent reads cannot register competing WSL instances. const reconcileMutex = yield* Semaphore.make(1); const preflightErrorRef = yield* Ref.make(Option.none()); const ownershipRefusedRef = yield* Ref.make( Option.none(), ); const findExistingWslInstance = pool.list.pipe( Effect.map((instances) => instances.find((instance) => isWslInstanceId(instance.id))), Effect.map(Option.fromNullishOr), ); const stopExisting = (id: DesktopBackendPool.BackendInstanceId) => pool.unregister(id).pipe( Effect.catchTags({ DesktopBackendPoolCannotUnregisterPrimaryError: (cause) => logWslBackendWarning("refusing to unregister primary as wsl instance", { id, error: cause.message, }), }), ); const startNew = Effect.fn("desktop.wslBackend.startNew")(function* (input: { readonly distro: string | null; }) { const primaryConfig = yield* serverExposure.backendConfig; const port = yield* scanForWslPort(primaryConfig.port + 1).pipe( Effect.provideService(NetService.NetService, net), Effect.asSome, Effect.catch((error) => logWslBackendWarning("could not allocate port for WSL backend", { error: error.message, }).pipe(Effect.as(Option.none())), ), ); if (Option.isNone(port)) { return; } const allocatedPort = port.value; const targetId = resolveTargetInstanceId(input.distro); yield* logWslBackendInfo("registering WSL backend with pool", { id: targetId, port: allocatedPort, distro: input.distro ?? null, }); const instance = yield* pool .register({ id: targetId, label: Effect.succeed(buildLabel(input.distro)), configResolve: configuration.resolveWsl({ port: allocatedPort, distro: input.distro }), onPreflightFailed: (failure) => Ref.set(preflightErrorRef, Option.some(failure.reason)).pipe(Effect.as(false)), onStateDirOwned: () => Ref.set(ownershipRefusedRef, Option.some(targetId)).pipe( Effect.andThen( Ref.set( preflightErrorRef, Option.some( "Another T3 Code server is using this distro's T3 home, or an older background service is set up for it. Stop that server or pair with it, or try `t3 update` in the distro. If the older launcher cannot update, run `t3 service uninstall` and optionally reinstall with `t3 service install` from a current CLI in the distro. Use `npx t3@latest` if `t3` is missing or outdated, and pass `--base-dir` with the service's T3 home to each command.", ), ), ), ), onReady: () => Ref.set(ownershipRefusedRef, Option.none()).pipe( Effect.andThen(Ref.set(preflightErrorRef, Option.none())), ), }) .pipe( Effect.asSome, Effect.catch((error) => logWslBackendWarning("WSL backend already registered, skipping start", { id: targetId, error: error.message, }).pipe(Effect.as(Option.none())), ), ); yield* Option.match(instance, { onNone: () => Effect.void, onSome: (registered) => registered.start, }); }); const reconcileBody = Effect.gen(function* () { const settings = yield* appSettings.get; if (!settings.localEnvironmentEnabled) return; const available = yield* wslEnvironment.isAvailable; const existing = yield* findExistingWslInstance; const existingId = Option.map(existing, (instance) => instance.id); // In wsl-only mode WSL is already primary; do not start a second backend on the same distro. const shouldRun = settings.wslBackendEnabled && available && !settings.wslOnly; const targetId = shouldRun ? Option.some(resolveTargetInstanceId(settings.wslDistro)) : Option.none(); if (Option.isNone(targetId) && Option.isNone(existingId)) { return; } if ( Option.isSome(targetId) && Option.isSome(existing) && targetId.value === existing.value.id ) { const existingInstance = existing.value; const snapshot = yield* existingInstance.snapshot; const isIdle = !snapshot.ready && Option.isNone(snapshot.activePid) && !snapshot.restartScheduled; if (isIdle) { const refused = yield* Ref.get(ownershipRefusedRef); if (Option.isSome(refused) && refused.value === existingInstance.id) return; yield* logWslBackendInfo("retrying idle WSL backend", { id: existingInstance.id }); yield* Ref.set(preflightErrorRef, Option.none()); yield* existingInstance.start; } return; } yield* Ref.set(preflightErrorRef, Option.none()); yield* Ref.set(ownershipRefusedRef, Option.none()); if (Option.isSome(existingId)) { yield* logWslBackendInfo("tearing down WSL backend", { id: existingId.value }); yield* stopExisting(existingId.value); } if (Option.isSome(targetId)) { // Pre-warm WSL so readiness cannot race its cold start. yield* wslEnvironment.preWarm(settings.wslDistro); yield* startNew({ distro: settings.wslDistro }); } }); const reconcile = reconcileMutex .withPermits(1)(reconcileBody) .pipe( Effect.catchCause((cause) => logWslBackendWarning("reconcile failed", { cause: Cause.pretty(cause) }), ), Effect.withSpan("desktop.wslBackend.reconcile"), ); return DesktopWslBackend.of({ reconcile, lastPreflightError: Ref.get(preflightErrorRef), }); }), );