localpreview 0.1.0

package/dist/control-plane.js

@@ -0,0 +1,182 @@
+import { LOCALPREVIEW_PROTOCOL_VERSION, LOCALPREVIEW_RELAY_SNAPSHOT_VERSION, } from "@localpreview/protocol";
+import { Context, Effect, Layer, Schedule } from "effect";
+import { ControlPlaneError } from "./errors.js";
+export class ControlPlaneClient extends Context.Service()("ControlPlaneClient") {
+}
+export const ControlPlaneClientLive = Layer.succeed(ControlPlaneClient)({
+    cleanAllSubdomains: (controlPlaneUrl, input) => cleanAllSubdomainsEffect(controlPlaneUrl, input),
+    cleanSubdomain: (controlPlaneUrl, input) => cleanSubdomainEffect(controlPlaneUrl, input),
+    closeTunnel: (controlPlaneUrl, tunnel) => closeTunnelEffect(controlPlaneUrl, tunnel).pipe(Effect.retry({
+        schedule: Schedule.recurs(2),
+        while: (error) => error.retryable === true,
+    })),
+    createTunnel: (controlPlaneUrl, body) => createTunnelEffect(controlPlaneUrl, body),
+});
+export const createTunnel = (controlPlaneUrl, body) => Effect.runPromise(createTunnelEffect(controlPlaneUrl, body));
+export const closeTunnel = (controlPlaneUrl, tunnel) => Effect.runPromise(closeTunnelEffect(controlPlaneUrl, tunnel));
+export const cleanSubdomain = (controlPlaneUrl, input) => Effect.runPromise(cleanSubdomainEffect(controlPlaneUrl, input));
+export const cleanAllSubdomains = (controlPlaneUrl, input) => Effect.runPromise(cleanAllSubdomainsEffect(controlPlaneUrl, input));
+const createTunnelEffect = (controlPlaneUrl, body) => Effect.promise(async () => {
+    let response;
+    try {
+        response = await fetch(new URL("/api/tunnels", controlPlaneUrl), {
+            body: JSON.stringify(body),
+            headers: {
+                "content-type": "application/json",
+            },
+            method: "POST",
+        });
+    }
+    catch {
+        throw new ControlPlaneError({
+            message: [
+                `Could not reach localpreview control-plane at ${controlPlaneUrl}.`,
+                'Use "-l" or "--local" to target a local control-plane at http://localhost:3000.',
+            ].join("\n"),
+            retryable: false,
+        });
+    }
+    const json = await readJson(response, "Tunnel creation");
+    if (!response.ok) {
+        if (json.error?.code === "SUBDOMAIN_TAKEN") {
+            throw new ControlPlaneError({
+                message: `Subdomain "${json.error.subdomain ?? "requested"}" is already in use.`,
+            });
+        }
+        throw new ControlPlaneError({
+            message: json.error?.message ?? `Tunnel creation failed with HTTP ${response.status}.`,
+        });
+    }
+    return validateCreateTunnelResponse(json);
+});
+const closeTunnelEffect = (controlPlaneUrl, tunnel) => Effect.promise(async () => {
+    let response;
+    try {
+        response = await fetch(new URL(`/api/tunnels/${tunnel.tunnelId}`, controlPlaneUrl), {
+            headers: {
+                "x-localpreview-client-token": tunnel.clientToken,
+            },
+            method: "DELETE",
+        });
+    }
+    catch {
+        throw new ControlPlaneError({
+            message: `Could not clean up tunnel ${tunnel.tunnelId}.`,
+            retryable: true,
+        });
+    }
+    if (!response.ok) {
+        throw new ControlPlaneError({
+            message: `Tunnel cleanup failed with HTTP ${response.status}.`,
+            retryable: response.status >= 500,
+        });
+    }
+});
+const cleanSubdomainEffect = (controlPlaneUrl, input) => Effect.promise(async () => {
+    let response;
+    const url = new URL(`/api/subdomains/${encodeURIComponent(input.subdomain)}`, controlPlaneUrl);
+    if (input.force) {
+        url.searchParams.set("force", "1");
+    }
+    try {
+        response = await fetch(url, {
+            headers: {
+                "x-localpreview-admin-token": input.adminToken,
+            },
+            method: "DELETE",
+        });
+    }
+    catch {
+        throw new ControlPlaneError({
+            message: `Could not reach localpreview control-plane at ${controlPlaneUrl}.`,
+            retryable: false,
+        });
+    }
+    const json = await readJson(response, "Subdomain cleanup");
+    if (!response.ok) {
+        throw new ControlPlaneError({
+            message: json.error?.message ?? `Subdomain cleanup failed with HTTP ${response.status}.`,
+        });
+    }
+    return json;
+});
+const cleanAllSubdomainsEffect = (controlPlaneUrl, input) => Effect.promise(async () => {
+    let response;
+    const url = new URL("/api/subdomains", controlPlaneUrl);
+    if (input.force) {
+        url.searchParams.set("force", "1");
+    }
+    try {
+        response = await fetch(url, {
+            headers: {
+                "x-localpreview-admin-token": input.adminToken,
+            },
+            method: "DELETE",
+        });
+    }
+    catch {
+        throw new ControlPlaneError({
+            message: `Could not reach localpreview control-plane at ${controlPlaneUrl}.`,
+            retryable: false,
+        });
+    }
+    const json = await readJson(response, "Bulk subdomain cleanup");
+    if (!response.ok) {
+        if (json.error?.code === "TUNNEL_HOST_NOT_FOUND") {
+            throw new ControlPlaneError({
+                message: [
+                    "The control-plane does not support bulk cleanup yet.",
+                    "Deploy the updated control-plane, or use `localpreview clean <subdomain> --force` for a single tunnel.",
+                ].join(" "),
+            });
+        }
+        throw new ControlPlaneError({
+            message: json.error?.message ?? `Bulk subdomain cleanup failed with HTTP ${response.status}.`,
+        });
+    }
+    return json;
+});
+const requiredCreateTunnelStringFields = [
+    "tunnelId",
+    "subdomain",
+    "publicUrl",
+    "relayWsUrl",
+    "clientToken",
+    "expiresAt",
+    "protocolVersion",
+    "relaySnapshotVersion",
+];
+const validateCreateTunnelResponse = (json) => {
+    for (const field of requiredCreateTunnelStringFields) {
+        if (typeof json[field] !== "string" || json[field].length === 0) {
+            throw new ControlPlaneError({
+                message: [
+                    `Tunnel creation returned an invalid response; missing ${field}.`,
+                    "This usually means the control-plane is running an older LocalPreview protocol.",
+                ].join(" "),
+            });
+        }
+    }
+    if (json.protocolVersion !== LOCALPREVIEW_PROTOCOL_VERSION ||
+        json.relaySnapshotVersion !== LOCALPREVIEW_RELAY_SNAPSHOT_VERSION) {
+        throw new ControlPlaneError({
+            message: [
+                "LocalPreview protocol mismatch:",
+                `expected protocol ${LOCALPREVIEW_PROTOCOL_VERSION}, got ${json.protocolVersion};`,
+                `expected relay snapshot ${LOCALPREVIEW_RELAY_SNAPSHOT_VERSION}, got ${json.relaySnapshotVersion}.`,
+                "Rebuild and promote a relay snapshot with pnpm relay:snapshot.",
+            ].join(" "),
+        });
+    }
+    return json;
+};
+const readJson = async (response, operation) => {
+    try {
+        return (await response.json());
+    }
+    catch {
+        throw new ControlPlaneError({
+            message: `${operation} failed with HTTP ${response.status}; control-plane returned an invalid JSON response.`,
+        });
+    }
+};

package/dist/errors.d.ts

@@ -0,0 +1,58 @@
+declare const CliUsageError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "CliUsageError";
+} & Readonly<A>;
+export declare class CliUsageError extends CliUsageError_base<{
+    readonly message: string;
+}> {
+}
+declare const CliConfigError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "CliConfigError";
+} & Readonly<A>;
+export declare class CliConfigError extends CliConfigError_base<{
+    readonly message: string;
+}> {
+}
+declare const ControlPlaneError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ControlPlaneError";
+} & Readonly<A>;
+export declare class ControlPlaneError extends ControlPlaneError_base<{
+    readonly message: string;
+    readonly retryable?: boolean;
+}> {
+}
+declare const RelayConnectionError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "RelayConnectionError";
+} & Readonly<A>;
+export declare class RelayConnectionError extends RelayConnectionError_base<{
+    readonly message: string;
+    readonly retryable?: boolean;
+}> {
+}
+declare const RelayProtocolError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "RelayProtocolError";
+} & Readonly<A>;
+export declare class RelayProtocolError extends RelayProtocolError_base<{
+    readonly message: string;
+}> {
+}
+declare const LocalRequestError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "LocalRequestError";
+} & Readonly<A>;
+export declare class LocalRequestError extends LocalRequestError_base<{
+    readonly message: string;
+    readonly requestId: string;
+}> {
+}
+declare const RequestLimitError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "RequestLimitError";
+} & Readonly<A>;
+export declare class RequestLimitError extends RequestLimitError_base<{
+    readonly limitBytes: number;
+    readonly message: string;
+    readonly requestId: string;
+}> {
+}
+export type CliRuntimeError = CliConfigError | ControlPlaneError | RelayConnectionError | RelayProtocolError | LocalRequestError | RequestLimitError;
+export declare const errorMessage: (error: unknown) => string;
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":";;;AAEA,qBAAa,aAAc,SAAQ,mBAAkC;IACnE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;CAAG;;;;AAEL,qBAAa,cAAe,SAAQ,oBAAmC;IACrE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;CAAG;;;;AAEL,qBAAa,iBAAkB,SAAQ,uBAAsC;IAC3E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;CAAG;;;;AAEL,qBAAa,oBAAqB,SAAQ,0BAAyC;IACjF,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;CAAG;;;;AAEL,qBAAa,kBAAmB,SAAQ,wBAAuC;IAC7E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;CAAG;;;;AAEL,qBAAa,iBAAkB,SAAQ,uBAAsC;IAC3E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;CAAG;;;;AAEL,qBAAa,iBAAkB,SAAQ,uBAAsC;IAC3E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;CAC5B,CAAC;CAAG;AAEL,MAAM,MAAM,eAAe,GACvB,cAAc,GACd,iBAAiB,GACjB,oBAAoB,GACpB,kBAAkB,GAClB,iBAAiB,GACjB,iBAAiB,CAAC;AAEtB,eAAO,MAAM,YAAY,GAAI,OAAO,OAAO,KAAG,MAM7C,CAAC"}

package/dist/errors.js

@@ -0,0 +1,21 @@
+import { Data } from "effect";
+export class CliUsageError extends Data.TaggedError("CliUsageError") {
+}
+export class CliConfigError extends Data.TaggedError("CliConfigError") {
+}
+export class ControlPlaneError extends Data.TaggedError("ControlPlaneError") {
+}
+export class RelayConnectionError extends Data.TaggedError("RelayConnectionError") {
+}
+export class RelayProtocolError extends Data.TaggedError("RelayProtocolError") {
+}
+export class LocalRequestError extends Data.TaggedError("LocalRequestError") {
+}
+export class RequestLimitError extends Data.TaggedError("RequestLimitError") {
+}
+export const errorMessage = (error) => {
+    if (typeof error === "object" && error !== null && "message" in error) {
+        return String(error.message);
+    }
+    return "Unknown failure.";
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
+import { Console, Effect } from "effect";
+import { runCli } from "./command.js";
+import { errorMessage } from "./errors.js";
+const argv = process.argv.slice(2);
+const program = runCli(argv).pipe(Effect.catch((error) => Console.error(errorMessage(error)).pipe(Effect.andThen(Effect.sync(() => {
+    process.exitCode =
+        typeof error === "object" &&
+            error !== null &&
+            "_tag" in error &&
+            error._tag === "CliUsageError"
+            ? 2
+            : 1;
+})))));
+NodeRuntime.runMain(program);

package/dist/local-proxy.d.ts

@@ -0,0 +1,15 @@
+import { type HeaderPairs, type TunnelTarget } from "@localpreview/protocol";
+import { Context, Effect, Layer } from "effect";
+import type WebSocket from "ws";
+import { CliConfig } from "./config.js";
+import { RelayProtocolError } from "./errors.js";
+export type LocalProxyShape = {
+    readonly handleMessage: (socket: WebSocket, target: TunnelTarget, input: string) => Effect.Effect<void, RelayProtocolError>;
+};
+declare const LocalProxy_base: Context.ServiceClass<LocalProxy, "LocalProxy", LocalProxyShape>;
+export declare class LocalProxy extends LocalProxy_base {
+}
+export declare const LocalProxyLive: Layer.Layer<LocalProxy, never, CliConfig>;
+export declare const filterLocalResponseHeaders: (headers: Headers) => HeaderPairs;
+export {};
+//# sourceMappingURL=local-proxy.d.ts.map

package/dist/local-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"local-proxy.d.ts","sourceRoot":"","sources":["../src/local-proxy.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,WAAW,EAEhB,KAAK,YAAY,EAClB,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAW,OAAO,EAAE,MAAM,EAAS,KAAK,EAAO,MAAM,QAAQ,CAAC;AACrE,OAAO,KAAK,SAAS,MAAM,IAAI,CAAC;AAChC,OAAO,EAAE,SAAS,EAAuB,MAAM,aAAa,CAAC;AAC7D,OAAO,EAEL,kBAAkB,EAGnB,MAAM,aAAa,CAAC;AAWrB,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,aAAa,EAAE,CACtB,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,MAAM,KACV,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,kBAAkB,CAAC,CAAC;CAC9C,CAAC;;AAEF,qBAAa,UAAW,SAAQ,eAA4D;CAAG;AAE/F,eAAO,MAAM,cAAc,2CAU1B,CAAC;AAySF,eAAO,MAAM,0BAA0B,GAAI,SAAS,OAAO,KAAG,WAqB7D,CAAC"}

package/dist/local-proxy.js

@@ -0,0 +1,214 @@
+import { decodeServerRelayMessage, encodeRelayMessage, filterEndToEndHeaderPairs, } from "@localpreview/protocol";
+import { Console, Context, Effect, Fiber, Layer, Ref } from "effect";
+import { CliConfig } from "./config.js";
+import { LocalRequestError, RelayProtocolError, RequestLimitError, errorMessage, } from "./errors.js";
+export class LocalProxy extends Context.Service()("LocalProxy") {
+}
+export const LocalProxyLive = Layer.effect(LocalProxy)(Effect.gen(function* () {
+    const config = yield* CliConfig;
+    const requests = yield* Ref.make(new Map());
+    return {
+        handleMessage: (socket, target, input) => handleMessage(config, requests, socket, target, input),
+    };
+}));
+const handleMessage = (config, requests, socket, target, input) => Effect.gen(function* () {
+    const decoded = decodeServerRelayMessage(input);
+    if (!decoded.ok) {
+        return yield* Effect.fail(new RelayProtocolError({
+            message: `Received an invalid relay request message: ${errorMessage(decoded.error)}`,
+        }));
+    }
+    const message = decoded.message;
+    switch (message.type) {
+        case "request-start":
+            return yield* handleRequestStart(config, requests, socket, message);
+        case "request-chunk":
+            return yield* handleRequestChunk(config, requests, socket, message);
+        case "request-end":
+            return yield* handleRequestEnd(config, requests, socket, target, message);
+        case "cancel":
+            return yield* handleCancel(requests, message.requestId);
+    }
+});
+const handleRequestStart = (config, requests, socket, message) => Effect.gen(function* () {
+    const current = yield* Ref.get(requests);
+    if (current.size >= config.maxInFlightRequests) {
+        yield* send(socket, {
+            message: `Too many in-flight requests; limit is ${config.maxInFlightRequests}.`,
+            requestId: message.requestId,
+            type: "response-error",
+        });
+        return;
+    }
+    const next = new Map(current);
+    next.set(message.requestId, {
+        chunks: [],
+        headers: message.headers,
+        method: message.method,
+        path: message.path,
+        totalBytes: 0,
+    });
+    yield* Ref.set(requests, next);
+    yield* Console.log(`-> ${message.method} ${logPath(message.path)}`);
+});
+const handleRequestChunk = (config, requests, socket, message) => Effect.gen(function* () {
+    const current = yield* Ref.get(requests);
+    const request = current.get(message.requestId);
+    if (request === undefined) {
+        return;
+    }
+    const chunk = Buffer.from(message.chunkBase64, "base64");
+    const totalBytes = request.totalBytes + chunk.length;
+    if (totalBytes > config.requestBodyLimitBytes) {
+        const next = new Map(current);
+        next.delete(message.requestId);
+        yield* Ref.set(requests, next);
+        yield* sendRequestError(socket, message.requestId, {
+            limitBytes: config.requestBodyLimitBytes,
+            message: "Request body is too large.",
+        });
+        return;
+    }
+    const next = new Map(current);
+    next.set(message.requestId, {
+        ...request,
+        chunks: [...request.chunks, chunk],
+        totalBytes,
+    });
+    yield* Ref.set(requests, next);
+});
+const handleRequestEnd = (config, requests, socket, target, message) => Effect.gen(function* () {
+    const current = yield* Ref.get(requests);
+    const request = current.get(message.requestId);
+    if (request === undefined) {
+        yield* send(socket, {
+            message: "Request ended without a matching start message.",
+            requestId: message.requestId,
+            type: "response-error",
+        });
+        return;
+    }
+    const fiber = yield* proxyToLocalTarget(config, socket, target, message.requestId, request).pipe(Effect.catch((error) => send(socket, {
+        message: error.message,
+        requestId: message.requestId,
+        type: "response-error",
+    }).pipe(Effect.andThen(Console.log(`<- error ${logPath(request.path)} ${error.message}`)))), Effect.ensuring(Ref.update(requests, (map) => {
+        const next = new Map(map);
+        next.delete(message.requestId);
+        return next;
+    })), Effect.forkDetach);
+    const next = new Map(current);
+    next.set(message.requestId, { ...request, fiber });
+    yield* Ref.set(requests, next);
+});
+const handleCancel = (requests, requestId) => Effect.gen(function* () {
+    const current = yield* Ref.get(requests);
+    const request = current.get(requestId);
+    if (request?.fiber !== undefined) {
+        yield* Fiber.interrupt(request.fiber);
+    }
+    const next = new Map(current);
+    next.delete(requestId);
+    yield* Ref.set(requests, next);
+});
+const proxyToLocalTarget = (config, socket, target, requestId, request) => Effect.gen(function* () {
+    const startedAt = Date.now();
+    const targetUrl = new URL(request.path, `${target.protocol}://${target.hostname}:${target.port}`);
+    const headers = new Headers(filterEndToEndHeaderPairs(request.headers).map(([name, value]) => [
+        name,
+        value,
+    ]));
+    headers.set("accept-encoding", "identity");
+    headers.set("host", `${target.hostname}:${target.port}`);
+    const body = Buffer.concat(request.chunks);
+    const init = {
+        headers,
+        method: request.method,
+    };
+    if (request.method !== "GET" && request.method !== "HEAD") {
+        init.body = body;
+    }
+    const response = yield* Effect.promise(() => fetch(targetUrl, init)).pipe(timeoutFail(config.requestTimeoutMs, new LocalRequestError({
+        message: "Local request timed out.",
+        requestId,
+    })), Effect.mapError((error) => error instanceof LocalRequestError
+        ? error
+        : new LocalRequestError({
+            message: errorMessage(error),
+            requestId,
+        })));
+    const responseBody = yield* Effect.promise(() => response.arrayBuffer()).pipe(timeoutFail(config.requestTimeoutMs, new LocalRequestError({
+        message: "Local request timed out.",
+        requestId,
+    })), Effect.map((arrayBuffer) => Buffer.from(arrayBuffer)), Effect.mapError((error) => error instanceof LocalRequestError
+        ? error
+        : new LocalRequestError({
+            message: errorMessage(error),
+            requestId,
+        })));
+    if (responseBody.length > config.responseBodyLimitBytes) {
+        return yield* Effect.fail(new RequestLimitError({
+            limitBytes: config.responseBodyLimitBytes,
+            message: "Response body is too large.",
+            requestId,
+        }));
+    }
+    yield* send(socket, {
+        headers: filterLocalResponseHeaders(response.headers),
+        requestId,
+        status: response.status,
+        type: "response-start",
+    });
+    for (let offset = 0; offset < responseBody.length; offset += config.responseChunkSizeBytes) {
+        const chunk = responseBody.subarray(offset, offset + config.responseChunkSizeBytes);
+        yield* send(socket, {
+            chunkBase64: chunk.toString("base64"),
+            requestId,
+            type: "response-chunk",
+        });
+    }
+    yield* send(socket, {
+        requestId,
+        type: "response-end",
+    });
+    yield* Console.log(`<- ${response.status} ${logPath(request.path)} ${Date.now() - startedAt}ms`);
+});
+const sendRequestError = (socket, requestId, error) => send(socket, {
+    message: `${error.message} Limit is ${error.limitBytes} bytes.`,
+    requestId,
+    type: "response-error",
+});
+const send = (socket, message) => Effect.sync(() => {
+    if (socket.readyState === socket.OPEN) {
+        socket.send(encodeRelayMessage(message));
+    }
+});
+export const filterLocalResponseHeaders = (headers) => {
+    const setCookies = getSetCookies(headers);
+    const pairs = [];
+    for (const [name, value] of headers.entries()) {
+        const lowerName = name.toLowerCase();
+        if (lowerName !== "set-cookie" &&
+            lowerName !== "content-encoding" &&
+            lowerName !== "content-length") {
+            pairs.push([name, value]);
+        }
+    }
+    for (const cookie of setCookies) {
+        pairs.push(["set-cookie", cookie]);
+    }
+    return filterEndToEndHeaderPairs(pairs);
+};
+const getSetCookies = (headers) => {
+    const withSetCookie = headers;
+    return withSetCookie.getSetCookie?.() ?? [];
+};
+const logPath = (path) => {
+    try {
+        return new URL(path, "http://localpreview.local").pathname;
+    }
+    catch {
+        return path.split("?")[0] ?? path;
+    }
+};
+const timeoutFail = (millis, error) => (effect) => Effect.raceFirst(effect, Effect.sleep(`${millis} millis`).pipe(Effect.andThen(Effect.fail(error))));

package/dist/relay-client.d.ts

@@ -0,0 +1,15 @@
+import type { CreateTunnelResponse, TunnelTarget } from "@localpreview/protocol";
+import { Context, Effect, Layer } from "effect";
+import { CliConfig } from "./config.js";
+import { RelayConnectionError, RelayProtocolError } from "./errors.js";
+import { LocalProxy } from "./local-proxy.js";
+export type RelayClientShape = {
+    readonly connectAndServe: (tunnel: CreateTunnelResponse, target: TunnelTarget) => Effect.Effect<void, RelayConnectionError | RelayProtocolError>;
+};
+declare const RelayClient_base: Context.ServiceClass<RelayClient, "RelayClient", RelayClientShape>;
+export declare class RelayClient extends RelayClient_base {
+}
+export declare const RelayClientLive: Layer.Layer<RelayClient, never, LocalProxy | CliConfig>;
+export declare const isRetryableCloseCode: (code: number) => boolean;
+export {};
+//# sourceMappingURL=relay-client.d.ts.map

package/dist/relay-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-client.d.ts","sourceRoot":"","sources":["../src/relay-client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACjF,OAAO,EAAW,OAAO,EAAY,MAAM,EAAE,KAAK,EAAY,MAAM,QAAQ,CAAC;AAE7E,OAAO,EAAE,SAAS,EAAuB,MAAM,aAAa,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,kBAAkB,EAAgB,MAAM,aAAa,CAAC;AACrF,OAAO,EAAE,UAAU,EAAwB,MAAM,kBAAkB,CAAC;AAEpE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,eAAe,EAAE,CACxB,MAAM,EAAE,oBAAoB,EAC5B,MAAM,EAAE,YAAY,KACjB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,oBAAoB,GAAG,kBAAkB,CAAC,CAAC;CACrE,CAAC;;AAEF,qBAAa,WAAY,SAAQ,gBAA+D;CAAG;AAEnG,eAAO,MAAM,eAAe,yDAS3B,CAAC;AAyLF,eAAO,MAAM,oBAAoB,GAAI,MAAM,MAAM,KAAG,OAAwB,CAAC"}

package/dist/relay-client.js

@@ -0,0 +1,115 @@
+import { Console, Context, Deferred, Effect, Layer, Schedule } from "effect";
+import WebSocket from "ws";
+import { CliConfig } from "./config.js";
+import { RelayConnectionError, RelayProtocolError, errorMessage } from "./errors.js";
+import { LocalProxy } from "./local-proxy.js";
+export class RelayClient extends Context.Service()("RelayClient") {
+}
+export const RelayClientLive = Layer.effect(RelayClient)(Effect.gen(function* () {
+    const config = yield* CliConfig;
+    const localProxy = yield* LocalProxy;
+    return {
+        connectAndServe: (tunnel, target) => connectAndServe(config, localProxy, tunnel, target),
+    };
+}));
+const connectAndServe = (config, localProxy, tunnel, target) => serveWithReconnect(config, localProxy, tunnel, target);
+const serveWithReconnect = (config, localProxy, tunnel, target) => serveOnce(config, localProxy, tunnel, target).pipe(Effect.catch((error) => {
+    if (error instanceof RelayConnectionError && error.retryable === true) {
+        return Console.error(`${error.message}; reconnecting...`).pipe(Effect.andThen(Effect.sleep("1 second")), Effect.andThen(serveWithReconnect(config, localProxy, tunnel, target)));
+    }
+    return Effect.fail(error);
+}));
+const serveOnce = (config, localProxy, tunnel, target) => Effect.gen(function* () {
+    const socket = yield* openSocket(tunnel).pipe(Effect.retry({
+        schedule: Schedule.recurs(Math.ceil(config.relayConnectTimeoutMs / 250)),
+    }));
+    yield* Console.log("Connected to relay.");
+    const done = yield* Deferred.make();
+    const handleSignal = () => {
+        socket.close(1000, "Interrupted");
+        Effect.runFork(Deferred.succeed(done, undefined));
+    };
+    yield* Effect.scoped(Effect.gen(function* () {
+        yield* Effect.acquireRelease(Effect.sync(() => {
+            process.once("SIGINT", handleSignal);
+            process.once("SIGTERM", handleSignal);
+            socket.on("message", (data) => {
+                const effect = localProxy.handleMessage(socket, target, data.toString()).pipe(Effect.catch((error) => Effect.gen(function* () {
+                    socket.close(1002, error.message);
+                    yield* Deferred.fail(done, error);
+                })));
+                Effect.runFork(effect);
+            });
+            socket.on("error", (error) => {
+                Effect.runFork(Deferred.fail(done, new RelayConnectionError({
+                    message: error.message,
+                })));
+            });
+            socket.on("close", (code, reason) => {
+                if (code === 1000 || code === 1001) {
+                    Effect.runFork(Deferred.succeed(done, undefined));
+                    return;
+                }
+                Effect.runFork(Deferred.fail(done, new RelayConnectionError({
+                    message: `Relay connection closed (${code}): ${reason.toString()}`,
+                    retryable: isRetryableCloseCode(code),
+                })));
+            });
+        }), () => Effect.sync(() => {
+            process.off("SIGINT", handleSignal);
+            process.off("SIGTERM", handleSignal);
+            if (socket.readyState === socket.OPEN || socket.readyState === socket.CONNECTING) {
+                socket.close(1000, "Closing");
+            }
+        }));
+        yield* Deferred.await(done);
+    }));
+});
+const openSocket = (tunnel) => Effect.callback((resume) => {
+    const relayUrl = new URL(tunnel.relayWsUrl);
+    relayUrl.searchParams.set("tunnelId", tunnel.tunnelId);
+    relayUrl.searchParams.set("token", tunnel.clientToken);
+    const socket = new WebSocket(relayUrl);
+    let opened = false;
+    const cleanup = () => {
+        socket.off("open", onOpen);
+        socket.off("error", onError);
+        socket.off("close", onClose);
+    };
+    const onOpen = () => {
+        opened = true;
+        cleanup();
+        resume(Effect.succeed(socket));
+    };
+    const onError = (error) => {
+        if (opened) {
+            return;
+        }
+        cleanup();
+        resume(Effect.fail(new RelayConnectionError({
+            message: error.message,
+        })));
+    };
+    const onClose = (code, reason) => {
+        if (opened) {
+            return;
+        }
+        cleanup();
+        resume(Effect.fail(new RelayConnectionError({
+            message: `Relay connection closed before open (${code}): ${reason.toString()}`,
+            retryable: isRetryableCloseCode(code),
+        })));
+    };
+    socket.once("open", onOpen);
+    socket.once("error", onError);
+    socket.once("close", onClose);
+    return Effect.sync(() => {
+        cleanup();
+        if (!opened) {
+            socket.close(1000, "Opening cancelled");
+        }
+    });
+}).pipe(Effect.mapError((error) => new RelayConnectionError({
+    message: errorMessage(error),
+})));
+export const isRetryableCloseCode = (code) => code === 1006;