import { Hono } from "@hono/hono"; import type { StructuredLoggerInterface } from "@publicdomainrelay/logger"; export interface IngressRef { ingressRef: string; readonly ingressUrl: string; readonly ingressHost: string; readonly name?: string; onServe(fetch: (req: Request) => Promise): Promise; close(): void; } export interface ServeTcpOpts { name?: string; addr?: string; port?: number; cert?: string; key?: string; certFile?: string; keyFile?: string; } export interface ServeUnixOpts { name?: string; socketPath: string; } export type ServeListenerKind = "tcp" | "unix" | "relay"; export interface ServeListener { name: string; kind: ServeListenerKind; address: string; } export interface CreateServeOpts { logger?: StructuredLoggerInterface; tcp?: ServeTcpOpts | ServeTcpOpts[]; unix?: ServeUnixOpts | ServeUnixOpts[]; relays?: IngressRef[]; portFile?: string; listenersFile?: string; } export const LISTENER_NAME_PATTERN = /^[a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?$/; export async function readTlsFiles( certFile: unknown, keyFile: unknown, ): Promise<{ cert?: string; key?: string }> { if (typeof certFile !== "string" || typeof keyFile !== "string" || !certFile || !keyFile) return {}; return { cert: await Deno.readTextFile(certFile), key: await Deno.readTextFile(keyFile), }; } export interface ServeHandle { app: Hono; addRelay(relay: IngressRef): Promise; onConnected(cb: (ingressRef: string) => void | Promise): void; beginServe(): Promise; shutdown(): void; listenersWritten(): Promise; readonly tcpPort: number; readonly listeners: ServeListener[]; } interface ListenerReport { path: string; order: string[]; entries: Map; chain: Promise; } const reports = new Map(); function reportFor(path: string): ListenerReport { let report = reports.get(path); if (!report) { report = { path, order: [], entries: new Map(), chain: Promise.resolve() }; reports.set(path, report); } return report; } function claimName(report: ListenerReport | undefined, local: Set, wanted: string): string { const taken = (name: string) => local.has(name) || (report?.order.includes(name) ?? false); let name = wanted; for (let n = 1; taken(name); n++) name = `${wanted}-${n}`; local.add(name); report?.order.push(name); return name; } function asList(value: T | T[] | undefined): T[] { if (value === undefined) return []; return Array.isArray(value) ? value : [value]; } export function tcpListenerAddress(hostname: string, port: number): string { return hostname.includes(":") ? `[${hostname}]:${port}` : `${hostname}:${port}`; } function absolutePath(path: string): string { if (path.startsWith("/")) return path; try { return `${Deno.cwd()}/${path}`; } catch { return path; } } function closeQuietly(relay: IngressRef): void { try { relay.close(); } catch (_err) { return; } } export function createServe(opts: CreateServeOpts): ServeHandle { const app = new Hono(); const logger = opts.logger; const tcpOpts = asList(opts.tcp); const unixOpts = asList(opts.unix); const relays: IngressRef[] = [...(opts.relays ?? [])]; const onConnectedCallbacks: Array<(ingressRef: string) => void | Promise> = []; const report = opts.listenersFile ? reportFor(opts.listenersFile) : undefined; const localNames = new Set(); const own: ServeListener[] = []; const servers: Deno.HttpServer[] = []; let controller: AbortController | null = null; let _tcpPort = 0; let relayCount = 0; function checkName(name: string | undefined): void { if (name !== undefined && !LISTENER_NAME_PATTERN.test(name)) { throw new Error(`createServe: listener name ${JSON.stringify(name)} is not a dns label`); } } function writeReport(): Promise { if (!report) return Promise.resolve(); report.chain = report.chain.then(async () => { const listeners = report.order.flatMap((name) => { const entry = report.entries.get(name); return entry ? [entry] : []; }); try { await Deno.writeTextFile(report.path, JSON.stringify({ listeners }) + "\n"); logger?.info("listeners file written", { path: report.path, listeners }); } catch (err) { logger?.error?.("listeners file write failed", { path: report.path, error: String(err) }); } }); return report.chain; } function record(listener: ServeListener): void { own.push(listener); report?.entries.set(listener.name, listener); } function relayName(relay: IngressRef): string { checkName(relay.name); const wanted = relay.name ?? (relayCount === 0 ? "relay" : `relay-${relayCount}`); relayCount++; return claimName(report, localNames, wanted); } async function connectRelay(relay: IngressRef, name: string): Promise { await relay.onServe(fetchAdapter); record({ name, kind: "relay", address: relay.ingressUrl }); await writeReport(); } function addRelay(relay: IngressRef): Promise { relays.push(relay); if (!controller) return Promise.resolve(); const name = relayName(relay); return connectRelay(relay, name).catch((err) => { logger?.error?.("relay onServe failed", { error: String(err) }); }); } function onConnected(cb: (ingressRef: string) => void | Promise): void { onConnectedCallbacks.push(cb); } const fetchAdapter = (req: Request): Promise => { return Promise.resolve(app.fetch(req)); }; async function serveTcp(tcp: ServeTcpOpts, name: string, signal: AbortSignal): Promise { const fromFiles = await readTlsFiles(tcp.certFile, tcp.keyFile); const certPem = tcp.cert ?? fromFiles.cert; const keyPem = tcp.key ?? fromFiles.key; const tlsEnabled = !!(certPem && keyPem); const tlsOpts = tlsEnabled ? { cert: certPem, key: keyPem } : {}; const bound = Promise.withResolvers<{ hostname: string; port: number }>(); const server = Deno.serve( { hostname: tcp.addr ?? "0.0.0.0", port: tcp.port ?? 0, signal, onListen: ({ hostname, port }) => { logger?.info("serve listening", { name, hostname, port, tls: tlsEnabled }); bound.resolve({ hostname, port }); }, ...tlsOpts, }, app.fetch, ); servers.push(server); server.finished.catch((err) => { logger?.error?.("serve finished with error", { name, error: String(err) }); }); const { hostname, port } = await bound.promise; if (_tcpPort === 0) _tcpPort = port; record({ name, kind: "tcp", address: tcpListenerAddress(hostname, port) }); } async function serveUnix(unix: ServeUnixOpts, name: string, signal: AbortSignal): Promise { await Deno.remove(unix.socketPath).catch(() => undefined); const bound = Promise.withResolvers(); const server = Deno.serve( { path: unix.socketPath, signal, onListen: ({ path }) => { logger?.info("serve listening", { name, path }); bound.resolve(path); }, }, app.fetch, ); servers.push(server); server.finished.catch((err) => { logger?.error?.("serve finished with error", { name, error: String(err) }); }); record({ name, kind: "unix", address: absolutePath(await bound.promise) }); } async function writePortFile(): Promise { if (!opts.portFile || tcpOpts.length === 0) return; try { await Deno.writeTextFile(opts.portFile, String(_tcpPort)); logger?.info("port file written", { path: opts.portFile, port: _tcpPort }); } catch (err) { logger?.error?.("port file write failed", { path: opts.portFile, error: String(err) }); } } async function beginServe(): Promise { if (controller) return; if (tcpOpts.length === 0 && unixOpts.length === 0 && relays.length === 0) { throw new Error("createServe: at least one mode required (tcp, unix, or relays)"); } for (const l of [...tcpOpts, ...unixOpts]) checkName(l.name); for (const relay of relays) checkName(relay.name); const tcpNames = tcpOpts.map((tcp, i) => claimName(report, localNames, tcp.name ?? (i === 0 ? "tcp" : `tcp-${i}`))); const unixNames = unixOpts.map((unix, i) => claimName(report, localNames, unix.name ?? (i === 0 ? "unix" : `unix-${i}`))); const relayNames = relays.map((relay) => relayName(relay)); controller = new AbortController(); const signal = controller.signal; for (const [i, tcp] of tcpOpts.entries()) await serveTcp(tcp, tcpNames[i], signal); for (const [i, unix] of unixOpts.entries()) await serveUnix(unix, unixNames[i], signal); await writePortFile(); await writeReport(); for (const [i, relay] of relays.entries()) await connectRelay(relay, relayNames[i]); const primaryProxyRef = relays[0]?.ingressRef ?? ""; for (const cb of onConnectedCallbacks) { await cb(primaryProxyRef); } } function shutdown(): void { controller?.abort(); for (const relay of relays) closeQuietly(relay); if (report) { for (const name of localNames) { report.entries.delete(name); report.order = report.order.filter((n) => n !== name); } localNames.clear(); if (report.order.length === 0) reports.delete(report.path); void writeReport(); } } function listenersWritten(): Promise { return report?.chain ?? Promise.resolve(); } return { app, addRelay, onConnected, beginServe, shutdown, listenersWritten, get tcpPort() { return _tcpPort; }, get listeners() { return [...own]; }, }; }