The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import * as Cause from "effect/Cause"; |
| 2 | import * as Context from "effect/Context"; |
| 3 | import * as Effect from "effect/Effect"; |
| 4 | import * as Layer from "effect/Layer"; |
| 5 | import * as Option from "effect/Option"; |
| 6 | import * as Ref from "effect/Ref"; |
| 7 | import * as Semaphore from "effect/Semaphore"; |
| 8 | |
| 9 | import * as NetService from "@t3tools/shared/Net"; |
| 10 | |
| 11 | import * as DesktopObservability from "../app/DesktopObservability.ts"; |
| 12 | import * as DesktopBackendConfiguration from "../backend/DesktopBackendConfiguration.ts"; |
| 13 | import * as DesktopBackendPool from "../backend/DesktopBackendPool.ts"; |
| 14 | import * as DesktopServerExposure from "../backend/DesktopServerExposure.ts"; |
| 15 | import * as DesktopAppSettings from "../settings/DesktopAppSettings.ts"; |
| 16 | import * as DesktopWslEnvironment from "./DesktopWslEnvironment.ts"; |
| 17 | |
| 18 | export const WSL_INSTANCE_ID_PREFIX = "wsl:"; |
| 19 | const WSL_DEFAULT_DISTRO_ID = `${WSL_INSTANCE_ID_PREFIX}default`; |
| 20 | const MAX_TCP_PORT = 65_535; |
| 21 | |
| 22 | export class DesktopWslBackend extends Context.Service< |
| 23 | DesktopWslBackend, |
| 24 | { |
| 25 | readonly reconcile: Effect.Effect<void>; |
| 26 | readonly lastPreflightError: Effect.Effect<Option.Option<string>>; |
| 27 | } |
| 28 | >()("@t3tools/desktop/wsl/DesktopWslBackend") {} |
| 29 | |
| 30 | const { logInfo: logWslBackendInfo, logWarning: logWslBackendWarning } = |
| 31 | DesktopObservability.makeComponentLogger("desktop-wsl-backend"); |
| 32 | |
| 33 | const resolveTargetInstanceId = (distro: string | null): DesktopBackendPool.BackendInstanceId => |
| 34 | DesktopBackendPool.BackendInstanceId( |
| 35 | distro === null ? WSL_DEFAULT_DISTRO_ID : `${WSL_INSTANCE_ID_PREFIX}${distro}`, |
| 36 | ); |
| 37 | |
| 38 | const isWslInstanceId = (id: DesktopBackendPool.BackendInstanceId): boolean => |
| 39 | id.startsWith(WSL_INSTANCE_ID_PREFIX); |
| 40 | |
| 41 | const buildLabel = (distro: string | null): string => |
| 42 | distro === null ? "WSL (default distro)" : `WSL (${distro})`; |
| 43 | |
| 44 | // WSL auto-forwards loopback ports, so only IPv4 loopback availability matters. |
| 45 | const scanForWslPort = Effect.fn("desktop.wslBackend.scanForWslPort")(function* ( |
| 46 | startPort: number, |
| 47 | ): Effect.fn.Return<number, NetService.NetError, NetService.NetService> { |
| 48 | const net = yield* NetService.NetService; |
| 49 | for (let port = startPort; port <= MAX_TCP_PORT; port += 1) { |
| 50 | if (yield* net.canListenOnHost(port, "127.0.0.1")) { |
| 51 | return port; |
| 52 | } |
| 53 | } |
| 54 | return yield* new NetService.NetError({ |
| 55 | message: `No loopback port available for WSL backend between ${startPort} and ${MAX_TCP_PORT}.`, |
| 56 | }); |
| 57 | }); |
| 58 | |
| 59 | export const layer = Layer.effect( |
| 60 | DesktopWslBackend, |
| 61 | Effect.gen(function* () { |
| 62 | const pool = yield* DesktopBackendPool.DesktopBackendPool; |
| 63 | const configuration = yield* DesktopBackendConfiguration.DesktopBackendConfiguration; |
| 64 | const serverExposure = yield* DesktopServerExposure.DesktopServerExposure; |
| 65 | const wslEnvironment = yield* DesktopWslEnvironment.DesktopWslEnvironment; |
| 66 | const appSettings = yield* DesktopAppSettings.DesktopAppSettings; |
| 67 | const net = yield* NetService.NetService; |
| 68 | // Serialize bootstrap and IPC reconciles so concurrent reads cannot register competing WSL instances. |
| 69 | const reconcileMutex = yield* Semaphore.make(1); |
| 70 | |
| 71 | const preflightErrorRef = yield* Ref.make(Option.none<string>()); |
| 72 | const ownershipRefusedRef = yield* Ref.make( |
| 73 | Option.none<DesktopBackendPool.BackendInstanceId>(), |
| 74 | ); |
| 75 | |
| 76 | const findExistingWslInstance = pool.list.pipe( |
| 77 | Effect.map((instances) => instances.find((instance) => isWslInstanceId(instance.id))), |
| 78 | Effect.map(Option.fromNullishOr), |
| 79 | ); |
| 80 | |
| 81 | const stopExisting = (id: DesktopBackendPool.BackendInstanceId) => |
| 82 | pool.unregister(id).pipe( |
| 83 | Effect.catchTags({ |
| 84 | DesktopBackendPoolCannotUnregisterPrimaryError: (cause) => |
| 85 | logWslBackendWarning("refusing to unregister primary as wsl instance", { |
| 86 | id, |
| 87 | error: cause.message, |
| 88 | }), |
| 89 | }), |
| 90 | ); |
| 91 | |
| 92 | const startNew = Effect.fn("desktop.wslBackend.startNew")(function* (input: { |
| 93 | readonly distro: string | null; |
| 94 | }) { |
| 95 | const primaryConfig = yield* serverExposure.backendConfig; |
| 96 | const port = yield* scanForWslPort(primaryConfig.port + 1).pipe( |
| 97 | Effect.provideService(NetService.NetService, net), |
| 98 | Effect.asSome, |
| 99 | Effect.catch((error) => |
| 100 | logWslBackendWarning("could not allocate port for WSL backend", { |
| 101 | error: error.message, |
| 102 | }).pipe(Effect.as(Option.none<number>())), |
| 103 | ), |
| 104 | ); |
| 105 | |
| 106 | if (Option.isNone(port)) { |
| 107 | return; |
| 108 | } |
| 109 | const allocatedPort = port.value; |
| 110 | |
| 111 | const targetId = resolveTargetInstanceId(input.distro); |
| 112 | yield* logWslBackendInfo("registering WSL backend with pool", { |
| 113 | id: targetId, |
| 114 | port: allocatedPort, |
| 115 | distro: input.distro ?? null, |
| 116 | }); |
| 117 | |
| 118 | const instance = yield* pool |
| 119 | .register({ |
| 120 | id: targetId, |
| 121 | label: Effect.succeed(buildLabel(input.distro)), |
| 122 | configResolve: configuration.resolveWsl({ port: allocatedPort, distro: input.distro }), |
| 123 | onPreflightFailed: (failure) => |
| 124 | Ref.set(preflightErrorRef, Option.some(failure.reason)).pipe(Effect.as(false)), |
| 125 | onStateDirOwned: () => |
| 126 | Ref.set(ownershipRefusedRef, Option.some(targetId)).pipe( |
| 127 | Effect.andThen( |
| 128 | Ref.set( |
| 129 | preflightErrorRef, |
| 130 | Option.some( |
| 131 | "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.", |
| 132 | ), |
| 133 | ), |
| 134 | ), |
| 135 | ), |
| 136 | onReady: () => |
| 137 | Ref.set(ownershipRefusedRef, Option.none()).pipe( |
| 138 | Effect.andThen(Ref.set(preflightErrorRef, Option.none())), |
| 139 | ), |
| 140 | }) |
| 141 | .pipe( |
| 142 | Effect.asSome, |
| 143 | Effect.catch((error) => |
| 144 | logWslBackendWarning("WSL backend already registered, skipping start", { |
| 145 | id: targetId, |
| 146 | error: error.message, |
| 147 | }).pipe(Effect.as(Option.none<DesktopBackendPool.DesktopBackendInstance>())), |
| 148 | ), |
| 149 | ); |
| 150 | |
| 151 | yield* Option.match(instance, { |
| 152 | onNone: () => Effect.void, |
| 153 | onSome: (registered) => registered.start, |
| 154 | }); |
| 155 | }); |
| 156 | |
| 157 | const reconcileBody = Effect.gen(function* () { |
| 158 | const settings = yield* appSettings.get; |
| 159 | if (!settings.localEnvironmentEnabled) return; |
| 160 | const available = yield* wslEnvironment.isAvailable; |
| 161 | const existing = yield* findExistingWslInstance; |
| 162 | const existingId = Option.map(existing, (instance) => instance.id); |
| 163 | |
| 164 | // In wsl-only mode WSL is already primary; do not start a second backend on the same distro. |
| 165 | const shouldRun = settings.wslBackendEnabled && available && !settings.wslOnly; |
| 166 | const targetId = shouldRun |
| 167 | ? Option.some(resolveTargetInstanceId(settings.wslDistro)) |
| 168 | : Option.none<DesktopBackendPool.BackendInstanceId>(); |
| 169 | |
| 170 | if (Option.isNone(targetId) && Option.isNone(existingId)) { |
| 171 | return; |
| 172 | } |
| 173 | if ( |
| 174 | Option.isSome(targetId) && |
| 175 | Option.isSome(existing) && |
| 176 | targetId.value === existing.value.id |
| 177 | ) { |
| 178 | const existingInstance = existing.value; |
| 179 | const snapshot = yield* existingInstance.snapshot; |
| 180 | const isIdle = |
| 181 | !snapshot.ready && Option.isNone(snapshot.activePid) && !snapshot.restartScheduled; |
| 182 | if (isIdle) { |
| 183 | const refused = yield* Ref.get(ownershipRefusedRef); |
| 184 | if (Option.isSome(refused) && refused.value === existingInstance.id) return; |
| 185 | yield* logWslBackendInfo("retrying idle WSL backend", { id: existingInstance.id }); |
| 186 | yield* Ref.set(preflightErrorRef, Option.none()); |
| 187 | yield* existingInstance.start; |
| 188 | } |
| 189 | return; |
| 190 | } |
| 191 | |
| 192 | yield* Ref.set(preflightErrorRef, Option.none()); |
| 193 | yield* Ref.set(ownershipRefusedRef, Option.none()); |
| 194 | |
| 195 | if (Option.isSome(existingId)) { |
| 196 | yield* logWslBackendInfo("tearing down WSL backend", { id: existingId.value }); |
| 197 | yield* stopExisting(existingId.value); |
| 198 | } |
| 199 | |
| 200 | if (Option.isSome(targetId)) { |
| 201 | // Pre-warm WSL so readiness cannot race its cold start. |
| 202 | yield* wslEnvironment.preWarm(settings.wslDistro); |
| 203 | yield* startNew({ distro: settings.wslDistro }); |
| 204 | } |
| 205 | }); |
| 206 | |
| 207 | const reconcile = reconcileMutex |
| 208 | .withPermits(1)(reconcileBody) |
| 209 | .pipe( |
| 210 | Effect.catchCause((cause) => |
| 211 | logWslBackendWarning("reconcile failed", { cause: Cause.pretty(cause) }), |
| 212 | ), |
| 213 | Effect.withSpan("desktop.wslBackend.reconcile"), |
| 214 | ); |
| 215 | |
| 216 | return DesktopWslBackend.of({ |
| 217 | reconcile, |
| 218 | lastPreflightError: Ref.get(preflightErrorRef), |
| 219 | }); |
| 220 | }), |
| 221 | ); |