Make Tailscale integration more idiomatic Effect

Cursor Agent committed 5 months ago

Commit 87d37d61 parent b3e8c034 files · +100 −51Browse files

Unified · Split

4 files

apps/desktop/src/backend/tailscaleEndpointProvider.test.ts +3 −2
apps/desktop/src/backend/tailscaleEndpointProvider.ts +6 −6
packages/tailscale/src/tailscale.test.ts +48 −9
packages/tailscale/src/tailscale.ts +43 −34

apps/desktop/src/backend/tailscaleEndpointProvider.test.ts+3−2

 import { assert, describe, it } from "@effect/vitest";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
 import { HttpClient } from "effect/unstable/http";
 import { ChildProcessSpawner } from "effect/unstable/process";
       const dnsName = yield* parseTailscaleMagicDnsName(
         `{"Self":{"DNSName":"desktop.tail.ts.net."}}`,
       );
-      assert.equal(dnsName, "desktop.tail.ts.net");
+      assert.deepEqual(dnsName, Option.some("desktop.tail.ts.net"));
-      assert.equal(yield* parseTailscaleMagicDnsName("{}"), null);
+      assert.deepEqual(yield* parseTailscaleMagicDnsName("{}"), Option.none());
       const malformed = yield* Effect.result(parseTailscaleMagicDnsName("not-json"));
       assert.isTrue(malformed._tag === "Failure");
     }),

apps/desktop/src/backend/tailscaleEndpointProvider.ts+6−6

@@ -61,17 +61,17 @@ function resolveTailscaleIpAdvertisedEndpoints(input: { · 60 unmodified lines
61	const resolveTailscaleMagicDnsAdvertisedEndpoint = Effect.fn(	61	const resolveTailscaleMagicDnsAdvertisedEndpoint = Effect.fn(
62	"resolveTailscaleMagicDnsAdvertisedEndpoint",	62	"resolveTailscaleMagicDnsAdvertisedEndpoint",
63	)(function* (input: {	63	)(function* (input: {
64	readonly dnsName: string \| null;	64	readonly dnsName: Option.Option<string>;
65	readonly serveEnabled: boolean;	65	readonly serveEnabled: boolean;
66	readonly servePort?: number;	66	readonly servePort?: number;
67	readonly probe?: (baseUrl: string) => Effect.Effect<boolean, never, HttpClient.HttpClient>;	67	readonly probe?: (baseUrl: string) => Effect.Effect<boolean, never, HttpClient.HttpClient>;
68	}): Effect.fn.Return<Option.Option<AdvertisedEndpoint>, never, HttpClient.HttpClient> {	68	}): Effect.fn.Return<Option.Option<AdvertisedEndpoint>, never, HttpClient.HttpClient> {
69	if (!input.dnsName) {	69	if (Option.isNone(input.dnsName)) {
70	return Option.none();	70	return Option.none();
71	}	71	}
72		72
73	const httpBaseUrl = buildTailscaleHttpsBaseUrl({	73	const httpBaseUrl = buildTailscaleHttpsBaseUrl({
74	magicDnsName: input.dnsName,	74	magicDnsName: input.dnsName.value,
75	...(input.servePort === undefined ? {} : { servePort: input.servePort }),	75	...(input.servePort === undefined ? {} : { servePort: input.servePort }),
76	});	76	});
77	const probe =	77	const probe =
@@ -116,13 +116,13 @@ export const resolveTailscaleAdvertisedEndpoints = Effect.fn("resolveTailscaleAd · 38 unmodified lines
116	input.statusJson === undefined	116	input.statusJson === undefined
117	? yield* readTailscaleStatus.pipe(	117	? yield* readTailscaleStatus.pipe(
118	Effect.map((status) => status.magicDnsName),	118	Effect.map((status) => status.magicDnsName),
119	Effect.catch(() => Effect.succeed(null)),	119	Effect.catch(() => Effect.succeed(Option.none())),
120	)	120	)
121	: input.statusJson	121	: input.statusJson
122	? yield* parseTailscaleMagicDnsName(input.statusJson).pipe(	122	? yield* parseTailscaleMagicDnsName(input.statusJson).pipe(
123	Effect.catch(() => Effect.succeed(null)),	123	Effect.catch(() => Effect.succeed(Option.none())),
124	)	124	)
125	: null;	125	: Option.none();
126	const magicDnsEndpoint = yield* resolveTailscaleMagicDnsAdvertisedEndpoint({	126	const magicDnsEndpoint = yield* resolveTailscaleMagicDnsAdvertisedEndpoint({
127	dnsName,	127	dnsName,
128	serveEnabled: input.serveEnabled === true,	128	serveEnabled: input.serveEnabled === true,

packages/tailscale/src/tailscale.test.ts+48−9

 import { assert, describe, it } from "@effect/vitest";
+import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
+import * as Fiber from "effect/Fiber";
 import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
 import * as Sink from "effect/Sink";
 import * as Stream from "effect/Stream";
+import * as TestClock from "effect/testing/TestClock";
 import { ChildProcessSpawner } from "effect/unstable/process";
 import {
   parseTailscaleMagicDnsName,
   parseTailscaleStatus,
   readTailscaleStatus,
+  TAILSCALE_STATUS_TIMEOUT,
 } from "./tailscale.ts";
 const encoder = new TextEncoder();
   });
 }
+function mockHangingHandle() {
+  return ChildProcessSpawner.makeHandle({
+    pid: ChildProcessSpawner.ProcessId(1),
+    exitCode: Effect.never,
+    isRunning: Effect.succeed(true),
+    kill: () => Effect.void,
+    unref: Effect.succeed(Effect.void),
+    stdin: Sink.drain,
+    stdout: Stream.empty,
+    stderr: Stream.empty,
+    all: Stream.empty,
+    getInputFd: () => Sink.drain,
+    getOutputFd: () => Stream.empty,
+  });
+}
 function mockSpawnerLayer(
   handler: (
     command: string,
     args: ReadonlyArray<string>,
   ) => { stdout?: string; stderr?: string; code?: number },
 ) {
-  return Layer.succeed(
+  return Layer.mock(ChildProcessSpawner.ChildProcessSpawner, {
-    ChildProcessSpawner.ChildProcessSpawner,
+    spawn: (command) => {
-    ChildProcessSpawner.make((command) => {
       const childProcess = command as unknown as {
         readonly command: string;
         readonly args: ReadonlyArray<string>;
       };
       return Effect.succeed(mockHandle(handler(childProcess.command, childProcess.args)));
-    }),
+    },
-  );
+  });
 }
 describe("tailscale", () => {
   it.effect("parses MagicDNS names from tailscale status", () =>
     Effect.gen(function* () {
       const dnsName = yield* parseTailscaleMagicDnsName(tailscaleStatusJson);
-      assert.equal(dnsName, "desktop.tail.ts.net");
+      assert.deepEqual(dnsName, Option.some("desktop.tail.ts.net"));
-      assert.equal(yield* parseTailscaleMagicDnsName("{}"), null);
+      assert.deepEqual(yield* parseTailscaleMagicDnsName("{}"), Option.none());
     }),
   );
     Effect.gen(function* () {
       const status = yield* parseTailscaleStatus(tailscaleStatusJson);
       assert.deepEqual(status, {
-        magicDnsName: "desktop.tail.ts.net",
+        magicDnsName: Option.some("desktop.tail.ts.net"),
         tailnetIpv4Addresses: ["100.100.100.100"],
       });
     }),
     return Effect.gen(function* () {
       const status = yield* readTailscaleStatus.pipe(Effect.provide(layer));
       assert.deepEqual(status, {
-        magicDnsName: "desktop.tail.ts.net",
+        magicDnsName: Option.some("desktop.tail.ts.net"),
         tailnetIpv4Addresses: ["100.90.1.2"],
       });
     });
   });
+  it.effect("times out tailscale status with TestClock", () => {
+    const layer = Layer.mock(ChildProcessSpawner.ChildProcessSpawner, {
+      spawn: () => Effect.succeed(mockHangingHandle()),
+    });
+    return Effect.gen(function* () {
+      const fiber = yield* readTailscaleStatus.pipe(Effect.provide(layer), Effect.result, Effect.fork);
+      yield* Effect.yieldNow;
+      yield* TestClock.adjust(Duration.sum(TAILSCALE_STATUS_TIMEOUT, Duration.millis(1)));
+      const result = yield* Fiber.join(fiber);
+      assert.equal(result._tag, "Failure");
+      if (result._tag === "Failure") {
+        assert.equal(result.failure._tag, "TailscaleCommandError");
+        assert.equal(result.failure.message, "Tailscale status timed out.");
+      }
+    }).pipe(Effect.provide(TestClock.layer()));
+  });
   it.effect("configures tailscale serve through the process spawner service", () => {
     const layer = mockSpawnerLayer((command, args) => {
       assert.equal(command, "tailscale");

packages/tailscale/src/tailscale.ts+43−34

-import * as Data from "effect/Data";
+import * as Duration from "effect/Duration";
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
 export const DEFAULT_TAILSCALE_SERVE_PORT = 443;
-export const TAILSCALE_STATUS_TIMEOUT_MS = 1_500;
+export const TAILSCALE_STATUS_TIMEOUT = Duration.millis(1_500);
-export const TAILSCALE_SERVE_TIMEOUT_MS = 10_000;
+export const TAILSCALE_SERVE_TIMEOUT = Duration.seconds(10);
-export const TAILSCALE_PROBE_TIMEOUT_MS = 2_500;
+export const TAILSCALE_PROBE_TIMEOUT = Duration.millis(2_500);
-export class TailscaleCommandError extends Data.TaggedError("TailscaleCommandError")<{
+export class TailscaleCommandError extends Schema.TaggedErrorClass<TailscaleCommandError>()(
-  readonly command: readonly string[];
+  "TailscaleCommandError",
-  readonly message: string;
+  {
-  readonly exitCode: number | null;
+    command: Schema.Array(Schema.String),
-  readonly stderr: string;
+    message: Schema.String,
-}> {}
+    exitCode: Schema.Union([Schema.Number, Schema.Null]),
+    stderr: Schema.String,
+  },
+) {}
-export class TailscaleStatusParseError extends Data.TaggedError("TailscaleStatusParseError")<{
+export class TailscaleStatusParseError extends Schema.TaggedErrorClass<TailscaleStatusParseError>()(
-  readonly cause: unknown;
+  "TailscaleStatusParseError",
-}> {}
+  {
+    cause: Schema.Defect,
+  },
+) {}
-export class TailscaleUnavailableError extends Data.TaggedError("TailscaleUnavailableError")<{
+export class TailscaleUnavailableError extends Schema.TaggedErrorClass<TailscaleUnavailableError>()(
-  readonly reason: string;
+  "TailscaleUnavailableError",
-}> {}
+  {
+    reason: Schema.String,
+  },
+) {}
 const TailscaleStatusSelf = Schema.Struct({
   DNSName: Schema.optional(Schema.Unknown),
 export type TailscaleStatusJson = typeof TailscaleStatusJson.Type;
 export interface TailscaleStatus {
-  readonly magicDnsName: string | null;
+  readonly magicDnsName: Option.Option<string>;
   readonly tailnetIpv4Addresses: readonly string[];
 }
 const decodeTailscaleStatusJson = Schema.decodeEffect(Schema.fromJsonString(TailscaleStatusJson));
-function normalizeMagicDnsName(status: TailscaleStatusJson): string | null {
+function normalizeMagicDnsName(status: TailscaleStatusJson): Option.Option<string> {
   const dnsName = status.Self?.DNSName;
   if (typeof dnsName !== "string") {
-    return null;
+    return Option.none();
   }
   const normalized = dnsName.trim().replace(/\.$/u, "");
-  return normalized.length > 0 ? normalized : null;
+  return normalized.length > 0 ? Option.some(normalized) : Option.none();
 }
 export const parseTailscaleMagicDnsName = (
   rawStatusJson: string,
-): Effect.Effect<string | null, TailscaleStatusParseError> =>
+): Effect.Effect<Option.Option<string>, TailscaleStatusParseError> =>
   decodeTailscaleStatusJson(rawStatusJson).pipe(
     Effect.mapError((cause) => new TailscaleStatusParseError({ cause })),
     Effect.map(normalizeMagicDnsName),
   return yield* parseTailscaleStatus(stdout);
 }).pipe(
   Effect.scoped,
-  Effect.timeoutOption(TAILSCALE_STATUS_TIMEOUT_MS),
+  Effect.timeoutOption(TAILSCALE_STATUS_TIMEOUT),
   Effect.flatMap((result) =>
     Option.match(result, {
       onNone: () =>
     readonly runMessage: string;
     readonly exitMessage: (exitCode: number) => string;
     readonly timeoutMessage: string;
-    readonly timeoutMs: number;
+    readonly timeout: Duration.Input;
   },
 ): Effect.Effect<void, TailscaleCommandError, ChildProcessSpawner.ChildProcessSpawner> =>
   Effect.gen(function* () {
     }
   }).pipe(
     Effect.scoped,
-    Effect.timeoutOption(input.timeoutMs),
+    Effect.timeoutOption(input.timeout),
     Effect.flatMap((result) =>
       Option.match(result, {
         onNone: () => Effect.fail(tailscaleCommandError(args, input.timeoutMessage, null)),
     runMessage: "Failed to run tailscale serve.",
     exitMessage: (exitCode) => `Tailscale serve exited with code ${exitCode}.`,
     timeoutMessage: "Tailscale serve timed out.",
-    timeoutMs: TAILSCALE_SERVE_TIMEOUT_MS,
+    timeout: TAILSCALE_SERVE_TIMEOUT,
   });
 };
       runMessage: "Failed to run tailscale serve off.",
       exitMessage: (exitCode) => `Tailscale serve off exited with code ${exitCode}.`,
       timeoutMessage: "Tailscale serve off timed out.",
-      timeoutMs: TAILSCALE_SERVE_TIMEOUT_MS,
+      timeout: TAILSCALE_SERVE_TIMEOUT,
     });
   });
 export const probeTailscaleHttpsEndpoint = (input: {
   readonly baseUrl: string;
-  readonly timeoutMs?: number;
+  readonly timeout?: Duration.Input;
 }): Effect.Effect<boolean, never, HttpClient.HttpClient> =>
   Effect.gen(function* () {
     const client = yield* HttpClient.HttpClient;
       const url = new URL("/.well-known/t3/environment", input.baseUrl);
       const request = HttpClientRequest.get(url.toString());
       return yield* client.execute(request);
-    }).pipe(Effect.timeoutOption(input.timeoutMs ?? TAILSCALE_PROBE_TIMEOUT_MS));
+    }).pipe(Effect.timeoutOption(input.timeout ?? TAILSCALE_PROBE_TIMEOUT));
     return Option.match(response, {
       onNone: () => false,
     readonly servePort?: number;
   } = {},
 ): Effect.Effect<
-  string | null,
+  Option.Option<string>,
   TailscaleCommandError | TailscaleStatusParseError,
   ChildProcessSpawner.ChildProcessSpawner
 > =>
   readTailscaleStatus.pipe(
     Effect.map((status) =>
-      status.magicDnsName
+      Option.map(status.magicDnsName, (magicDnsName) =>
-        ? buildTailscaleHttpsBaseUrl({
+        buildTailscaleHttpsBaseUrl({
-            magicDnsName: status.magicDnsName,
+          magicDnsName,
             ...(input.servePort === undefined ? {} : { servePort: input.servePort }),
-          })
+        }),
-        : null,
+      ),
     ),
   );