Skip to content
Source
Sign inSign up
pingdotgg/t3code
Open History to see the last commit

DirectEndpoints.ts

181 lines6.9 KB

1import type { ServerDirectEndpoint } from "@t3tools/contracts";
2import {
3 buildTailscaleHttpsBaseUrl,
4 probeTailscaleHttpsEndpoint,
5 readTailscaleStatus,
6} from "@t3tools/tailscale";
7import * as Context from "effect/Context";
8import * as Duration from "effect/Duration";
9import * as Effect from "effect/Effect";
10import * as Layer from "effect/Layer";
11import * as Option from "effect/Option";
12import * as Ref from "effect/Ref";
13import { HttpClient } from "effect/http";
14import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
15import * as NodeNet from "node:net";
16import * as NodeOS from "node:os";
17​
18import * as HostProcess from "@t3tools/shared/HostProcess";
19import {
20 formatHostForUrl,
21 isTailnetHost,
22 isWildcardHost,
23} from "@t3tools/shared/hostClassification";
24​
25import * as ServerConfig from "../config.ts";
26import { isLoopbackHost, isPrivateNetworkAddress, VIRTUAL_INTERFACE } from "../startupAccess.ts";
27​
28type NetworkInterfacesMap = ReturnType<typeof NodeOS.networkInterfaces>;
29​
30// Stay below the config discovery timeout so slow Tailscale drops only the tailnet name.
31const TAILSCALE_ENDPOINT_TIMEOUT = Duration.seconds(3);
32​
33export class DirectEndpoints extends Context.Service<
34 DirectEndpoints,
35 {
36 readonly resolveAvailable: () => Effect.Effect<ReadonlyArray<ServerDirectEndpoint>>;
37 readonly resolve: () => Effect.Effect<ReadonlyArray<ServerDirectEndpoint>>;
38 }
39>()("t3/environment/DirectEndpoints") {}
40​
41// Credentials travel over HTTP; public IPs leak them and hostnames can resolve differently per client.
42const isAdvertisableAddress = (address: string): boolean =>
43 NodeNet.isIPv4(address) && !address.startsWith("127.") && isPrivateNetworkAddress(address);
44​
45// macOS utun names need Tailscale's IPv6 range to identify them; WARP shares its IPv4 range.
46const isTailscaleInterface = (
47 name: string,
48 entries: ReadonlyArray<NodeOS.NetworkInterfaceInfo>,
49): boolean =>
50 /^tailscale/i.test(name) ||
51 entries.some((entry) => entry.family === "IPv6" && isTailnetHost(entry.address));
52​
53// Windows adapter names are mutable; Linux bridges can inherit these MACs.
54const WINDOWS_HOST_ADAPTER_MAC = /^(0a:00:27|00:50:56:c0:00):/i;
55​
56export function resolveBoundEndpoints(input: {
57 readonly platform: NodeJS.Platform;
58 readonly host: string | undefined;
59 readonly port: number;
60 readonly interfaces: NetworkInterfacesMap;
61 /** A cloud VM's private network is its provider's, which no client shares. */
62 readonly onCloudVm?: boolean;
63}): ReadonlyArray<ServerDirectEndpoint> {
64 if (isLoopbackHost(input.host)) return [];
65 const tailscaleAddresses = new Set(
66 Object.entries(input.interfaces).flatMap(([name, entries = []]) =>
67 isTailscaleInterface(name, entries) ? entries.map((entry) => entry.address) : [],
68 ),
69 );
70 const addresses = isWildcardHost(input.host)
71 ? Object.entries(input.interfaces)
72 .flatMap(([name, entries]) => (VIRTUAL_INTERFACE.test(name) ? [] : (entries ?? [])))
73 .filter(
74 (entry) =>
75 !entry.internal &&
76 entry.family === "IPv4" &&
77 isAdvertisableAddress(entry.address) &&
78 !(input.platform === "win32" && WINDOWS_HOST_ADAPTER_MAC.test(entry.mac)),
79 )
80 .map((entry) => entry.address)
81 : [input.host!].filter(isAdvertisableAddress);
82 return [...new Set(addresses)]
83 .filter((address) => !input.onCloudVm || tailscaleAddresses.has(address))
84 .map((address) => ({
85 kind: tailscaleAddresses.has(address) ? "tailnet" : "lan",
86 httpBaseUrl: `http://${formatHostForUrl(address)}:${input.port}/`,
87 }));
89​
90/**
91 * AWS, GCP, Azure, DigitalOcean, Hetzner, Linode, Vultr, and Oracle all serve
92 * instance metadata at this address. A plain TCP connect skips HTTP proxies,
93 * which would otherwise answer for a machine that is not in a cloud.
94 */
95const CLOUD_METADATA_ADDRESS = "169.254.169.254";
96const CLOUD_METADATA_TIMEOUT_MS = 300;
97​
98const probeCloudMetadata = Effect.callback<boolean>((resume) => {
99 const socket = NodeNet.connect({
100 host: CLOUD_METADATA_ADDRESS,
101 port: 80,
102 timeout: CLOUD_METADATA_TIMEOUT_MS,
103 });
104 let settled = false;
105 const settle = (found: boolean) => {
106 if (settled) return;
107 settled = true;
108 socket.destroy();
109 resume(Effect.succeed(found));
110 };
111 socket.once("connect", () => settle(true));
112 socket.once("timeout", () => settle(false));
113 socket.once("error", () => settle(false));
114 return Effect.sync(() => socket.destroy());
115});
116​
117/** @public */
118export const make = Effect.gen(function* () {
119 const config = yield* ServerConfig.ServerConfig;
120 const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
121 const httpClient = yield* HttpClient.HttpClient;
122 const platform = yield* HostProcess.Platform;
123 // Only the service default listens on every interface without being asked,
124 // so only it checks once whether it runs in a cloud. The check starts now so
125 // the first client does not wait for its timeout.
126 const onCloudVm = config.privateNetworkOnly
127 ? yield* Effect.cached(probeCloudMetadata)
128 : Effect.succeed(false);
129 yield* Effect.forkDetach(onCloudVm);
130​
131 const servedEndpoint = yield* Ref.make<Option.Option<string>>(Option.none());
132 const resolveAvailable = Effect.fn("DirectEndpoints.resolveAvailable")(function* () {
133 const endpoints = [
134 ...resolveBoundEndpoints({
135 platform,
136 host: config.host,
137 port: config.port,
138 interfaces: NodeOS.networkInterfaces(),
139 onCloudVm: yield* onCloudVm,
140 }),
141 ];
142 const servedUrl = yield* Ref.get(servedEndpoint);
143 if (Option.isSome(servedUrl)) endpoints.push({ kind: "tailnet", httpBaseUrl: servedUrl.value });
144 return endpoints;
145 });
146​
147 const resolve = Effect.gen(function* () {
148 // Serve setup can fail without stopping startup; advertise only after it answers as this server.
149 if (config.tailscaleServeEnabled) {
150 const servedUrl = yield* readTailscaleStatus.pipe(
151 Effect.map((status) => status.magicDnsName),
152 Effect.flatMap((magicDnsName) => {
153 if (magicDnsName === null) return Effect.succeed(null);
154 const httpBaseUrl = buildTailscaleHttpsBaseUrl({
155 magicDnsName,
156 servePort: config.tailscaleServePort,
157 });
158 return probeTailscaleHttpsEndpoint({ baseUrl: httpBaseUrl }).pipe(
159 Effect.map((reachable) => (reachable ? httpBaseUrl : null)),
160 );
161 }),
162 Effect.timeoutOption(TAILSCALE_ENDPOINT_TIMEOUT),
163 Effect.map(Option.flatMap(Option.fromNullishOr)),
164 Effect.orElseSucceed(() => Option.none<string>()),
165 Effect.provideService(ChildProcessSpawner.ChildProcessSpawner, spawner),
166 Effect.provideService(HttpClient.HttpClient, httpClient),
167 );
168 yield* Ref.set(servedEndpoint, servedUrl);
169 }
170 return yield* resolveAvailable();
171 });
172​
173 return DirectEndpoints.of({
174 resolveAvailable,
175 resolve: Effect.fn("DirectEndpoints.resolve")(function () {
176 return resolve;
177 }),
178 });
179});
180​
181export const layer = Layer.effect(DirectEndpoints, make);