Stabilize auth session cookies per server mode (#1898)

Julius Marminge committed 7 months ago

Commit 4ae9de31 parent 5fa09fa11 files · +212 −22Browse files

Showing the changes to scripts (2 of 11 files). Show all

Unified · Split

2 files

scripts/dev-runner.test.ts +63 −10
scripts/dev-runner.ts +21 −2

scripts/dev-runner.test.ts+63−10

 import { Effect } from "effect";
 import {
+  checkPortAvailabilityOnHosts,
   createDevRunnerEnv,
   findFirstAvailableOffset,
   resolveModePortOffsets,
         const env = yield* createDevRunnerEnv({
           mode: "dev:desktop",
           baseEnv: {
-            T3CODE_PORT: "3773",
+            T3CODE_PORT: "13773",
             T3CODE_MODE: "web",
             T3CODE_NO_BROWSER: "0",
             T3CODE_HOST: "0.0.0.0",
-            VITE_WS_URL: "ws://localhost:3773",
+            VITE_WS_URL: "ws://localhost:13773",
           },
           serverOffset: 0,
           webOffset: 0,
         assert.equal(env.VITE_WS_URL, "ws://127.0.0.1:4222");
       }),
     );
+    it.effect("defaults dev server mode to the higher backend port range", () =>
+      Effect.gen(function* () {
+        const env = yield* createDevRunnerEnv({
+          mode: "dev",
+          baseEnv: {},
+          serverOffset: 0,
+          webOffset: 0,
+          t3Home: undefined,
+          noBrowser: undefined,
+          autoBootstrapProjectFromCwd: undefined,
+          logWebSocketEvents: undefined,
+          host: undefined,
+          port: undefined,
+          devUrl: undefined,
+        });
+        assert.equal(env.T3CODE_PORT, "13773");
+        assert.equal(env.VITE_HTTP_URL, "http://localhost:13773");
+        assert.equal(env.VITE_WS_URL, "ws://localhost:13773");
+      }),
+    );
   });
   describe("findFirstAvailableOffset", () => {
     it.effect("advances until all required ports are available", () =>
       Effect.gen(function* () {
-        const taken = new Set([3773, 5733, 3774, 5734]);
+        const taken = new Set([13773, 5733, 13774, 5734]);
         const offset = yield* findFirstAvailableOffset({
           startOffset: 0,
           requireServerPort: true,
       }),
     );
-    it.effect("allows offsets where only non-required ports exceed max", () =>
+    it.effect("allows offsets where the non-required server port exceeds max", () =>
       Effect.gen(function* () {
         const offset = yield* findFirstAvailableOffset({
-          startOffset: 59_803,
+          startOffset: 59_802,
-          requireServerPort: true,
+          requireServerPort: false,
-          requireWebPort: false,
+          requireWebPort: true,
           checkPortAvailability: () => Effect.succeed(true),
         });
-        assert.equal(offset, 59_803);
+        assert.equal(offset, 59_802);
+      }),
+    );
+  });
+  describe("checkPortAvailabilityOnHosts", () => {
+    it.effect("checks overlapping hosts sequentially to avoid self-interference", () =>
+      Effect.gen(function* () {
+        let inFlightCount = 0;
+        const calls: Array<[number, string]> = [];
+        const available = yield* checkPortAvailabilityOnHosts(
+          13_773,
+          ["127.0.0.1", "0.0.0.0", "::"],
+          (port, host) =>
+            Effect.promise(async () => {
+              calls.push([port, host]);
+              inFlightCount += 1;
+              const overlapped = inFlightCount > 1;
+              await Promise.resolve();
+              inFlightCount -= 1;
+              return !overlapped;
+            }),
+        );
+        assert.equal(available, true);
+        assert.deepStrictEqual(calls, [
+          [13_773, "127.0.0.1"],
+          [13_773, "0.0.0.0"],
+          [13_773, "::"],
+        ]);
       }),
     );
   });
   describe("resolveModePortOffsets", () => {
     it.effect("uses a shared fallback offset for dev mode", () =>
       Effect.gen(function* () {
-        const taken = new Set([3773, 5733]);
+        const taken = new Set([13773, 5733]);
         const offsets = yield* resolveModePortOffsets({
           mode: "dev",
           startOffset: 0,
     it.effect("shifts only server offset for dev:server", () =>
       Effect.gen(function* () {
-        const taken = new Set([3773]);
+        const taken = new Set([13773]);
         const offsets = yield* resolveModePortOffsets({
           mode: "dev:server",
           startOffset: 0,

scripts/dev-runner.ts+21−2

 import { Argument, Command, Flag } from "effect/unstable/cli";
 import { ChildProcess } from "effect/unstable/process";
-const BASE_SERVER_PORT = 3773;
+const BASE_SERVER_PORT = 13773;
 const BASE_WEB_PORT = 5733;
 const MAX_HASH_OFFSET = 3000;
 const MAX_PORT = 65535;
 const DESKTOP_DEV_LOOPBACK_HOST = "127.0.0.1";
+const DEV_PORT_PROBE_HOSTS = ["127.0.0.1", "0.0.0.0", "::1", "::"] as const;
 export const DEFAULT_T3_HOME = Effect.map(Effect.service(Path.Path), (path) =>
   path.join(homedir(), ".t3"),
   };
 }
+export function checkPortAvailabilityOnHosts<R>(
+  port: number,
+  hosts: ReadonlyArray<string>,
+  canListenOnHost: (port: number, host: string) => Effect.Effect<boolean, never, R>,
+): Effect.Effect<boolean, never, R> {
+  return Effect.gen(function* () {
+    for (const host of hosts) {
+      if (!(yield* canListenOnHost(port, host))) {
+        return false;
+      }
+    }
+    return true;
+  });
+}
 const defaultCheckPortAvailability: PortAvailabilityCheck<NetService> = (port) =>
   Effect.gen(function* () {
     const net = yield* NetService;
-    return yield* net.isPortAvailableOnLoopback(port);
+    return yield* checkPortAvailabilityOnHosts(port, DEV_PORT_PROBE_HOSTS, (candidatePort, host) =>
+      net.canListenOnHost(candidatePort, host),
+    );
   });
 interface FindFirstAvailableOffsetInput<R = NetService> {