@agent-relay/factory 0.1.49 → 0.1.51

package/dist/node/tailscale-preview.js

@@ -0,0 +1,748 @@
+import { randomUUID } from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { mkdir, open, readFile, rename, rm } from 'node:fs/promises';
+import { get } from 'node:http';
+import { get as getHttps } from 'node:https';
+import { createServer } from 'node:net';
+import { dirname } from 'node:path';
+import { promisify } from 'node:util';
+import lockfile from 'proper-lockfile';
+import { PreviewProcessSupervisor, } from './preview-process.js';
+const execFileAsync = promisify(execFile);
+const REGISTRY_VERSION = 1;
+const MANAGED_BY = '@agent-relay/factory';
+const PREVIEW_LOCK_STALE_MS = 30_000;
+const PREVIEW_PROVIDER_COMMAND_TIMEOUT_MS = 30_000;
+const PREVIEW_READY_TIMEOUT_MS = 5 * 60_000;
+const PREVIEW_PUBLISHED_READY_TIMEOUT_MS = 60_000;
+const PREVIEW_READY_POLL_INTERVAL_MS = 250;
+const PREVIEW_PROVISIONING_GRACE_MS = 10 * 60_000;
+/**
+ * Thin lifecycle adapter around Tailscale Serve. `tailscaled` owns background
+ * proxying, while this registry records the exact routes Factory may remove.
+ * Every destructive operation checks the live Serve target before issuing
+ * `off`, so a stale registry can never turn off a port repurposed by a human.
+ */
+export class TailscalePreviewManager {
+    #config;
+    #run;
+    #isPortAvailable;
+    #isReady;
+    #isPublishedReady;
+    #processes;
+    #sleep;
+    #readyTimeoutMs;
+    #publishedReadyTimeoutMs;
+    #readyPollIntervalMs;
+    #now;
+    #operation = Promise.resolve();
+    constructor(options) {
+        this.#config = options.config;
+        this.#run = options.run ?? (async (file, args) => {
+            const result = await execFileAsync(file, args, {
+                encoding: 'utf8',
+                timeout: PREVIEW_PROVIDER_COMMAND_TIMEOUT_MS,
+            });
+            return { stdout: result.stdout, stderr: result.stderr };
+        });
+        this.#isPortAvailable = options.isPortAvailable ?? portAvailable;
+        this.#isReady = options.isReady ?? httpReady;
+        this.#isPublishedReady = options.isPublishedReady ?? httpsReady;
+        this.#processes = options.processSupervisor ?? new PreviewProcessSupervisor();
+        this.#sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+        this.#readyTimeoutMs = options.readyTimeoutMs ?? PREVIEW_READY_TIMEOUT_MS;
+        this.#publishedReadyTimeoutMs = options.publishedReadyTimeoutMs ?? PREVIEW_PUBLISHED_READY_TIMEOUT_MS;
+        this.#readyPollIntervalMs = options.readyPollIntervalMs ?? PREVIEW_READY_POLL_INTERVAL_MS;
+        this.#now = options.now ?? (() => new Date());
+    }
+    async start(input) {
+        return await this.#exclusive(async () => {
+            const registry = await this.#readRegistry();
+            let status = await this.#serveStatus();
+            const existing = registry.previews.find((preview) => preview.namespace === input.namespace &&
+                preview.owner === input.owner &&
+                preview.service === input.service);
+            const existingMatchesRequest = existing &&
+                existing.repo === input.repo &&
+                (existing.configuredTargetPort ?? existing.targetPort) === input.targetPort &&
+                (input.preferredHttpsPort === undefined || existing.httpsPort === input.preferredHttpsPort) &&
+                existing.startCommand === input.startCommand &&
+                (!existing.process || existing.process.cwd === input.checkoutPath);
+            const existingRoute = existing
+                ? liveRoute(status, existing.httpsPort, existing.targetPort)
+                : undefined;
+            if (existingMatchesRequest && existingRoute && !existingRoute.funnel) {
+                const process = await this.#ensureManagedProcess(existing, input.checkoutPath);
+                await this.#awaitReady(existing.targetPort, process);
+                try {
+                    await this.#assertListenerOwned(existing.targetPort, process);
+                }
+                catch (error) {
+                    // The exact Factory root is unsafe to keep published when a different
+                    // process owns its upstream. Other mounts survive the path-scoped off.
+                    await this.#disable(existing);
+                    throw error;
+                }
+                const liveUrl = previewUrl(existingRoute.host, existing.httpsPort);
+                await this.#awaitPublishedReady(liveUrl, process);
+                const active = activatePreview({ ...existing, process }, liveUrl);
+                if (existing.state === 'pending' ||
+                    existing.url !== liveUrl ||
+                    !sameProcess(existing.process, process)) {
+                    registry.previews = registry.previews.map((preview) => preview.id === existing.id ? active : preview);
+                    await this.#writeRegistry(registry);
+                }
+                return referenceFrom(active);
+            }
+            if (existing) {
+                // A changed service declaration replaces only the old route whose live
+                // upstream still matches Factory's registry identity.
+                if (liveRouteMatches(status, existing)) {
+                    await this.#disable(existing);
+                    status = await this.#serveStatus();
+                }
+                if (!await this.#stopManagedProcess(existing)) {
+                    throw new Error(`Unable to confirm teardown of replaced preview process ${existing.id}`);
+                }
+                registry.previews = registry.previews.filter((preview) => preview.id !== existing.id);
+                await this.#writeRegistry(registry);
+            }
+            const serviceConfig = this.#config.services[input.service];
+            const lastTargetPort = Math.min(65_535, input.targetPort + (serviceConfig?.portSpan ?? 100) - 1);
+            const occupiedTargetPorts = new Set([
+                ...registry.previews.map((preview) => preview.targetPort),
+                ...liveUpstreamPorts(status),
+            ]);
+            let targetPort;
+            for (const candidate of portRange(input.targetPort, lastTargetPort)) {
+                if (occupiedTargetPorts.has(candidate))
+                    continue;
+                if (await this.#isPortAvailable(candidate)) {
+                    targetPort = candidate;
+                    break;
+                }
+            }
+            if (targetPort === undefined) {
+                throw new Error(`Unable to allocate a local target port for ${input.service}`);
+            }
+            const occupied = new Set(registry.previews.map((preview) => preview.httpsPort));
+            const candidates = input.preferredHttpsPort !== undefined
+                ? [input.preferredHttpsPort]
+                : portRange(this.#config.httpsPortRange[0], this.#config.httpsPortRange[1]);
+            let lastError;
+            for (const httpsPort of candidates) {
+                if (occupied.has(httpsPort) || livePortConfigured(status, httpsPort))
+                    continue;
+                const pending = {
+                    id: randomUUID(),
+                    provider: 'tailscale-serve',
+                    namespace: input.namespace,
+                    owner: input.owner,
+                    service: input.service,
+                    repo: input.repo,
+                    configuredTargetPort: input.targetPort,
+                    targetPort,
+                    httpsPort,
+                    access: 'tailnet',
+                    lifetime: 'issue',
+                    createdAt: this.#now().toISOString(),
+                    startCommand: input.startCommand,
+                    checkoutPath: input.checkoutPath,
+                    ...(input.node && input.node !== 'self' ? { node: input.node } : {}),
+                    managedBy: MANAGED_BY,
+                    state: 'pending',
+                };
+                registry.previews.push(pending);
+                // Persist intent before starting either external resource. The
+                // deterministic process marker closes the spawn/persist crash gap,
+                // while the pending route identity closes the Serve API crash gap.
+                await this.#writeRegistry(registry);
+                let commandSucceeded = false;
+                try {
+                    const process = await this.#processes.start({
+                        id: pending.id,
+                        command: input.startCommand,
+                        cwd: input.checkoutPath,
+                        port: targetPort,
+                    });
+                    pending.process = process;
+                    await this.#writeRegistry(registry);
+                    await this.#awaitReady(targetPort, process);
+                    await this.#assertListenerOwned(targetPort, process);
+                    await this.#configure(pending);
+                    commandSucceeded = true;
+                    const configured = await this.#serveStatus();
+                    const route = liveRoute(configured, httpsPort, targetPort);
+                    if (!route || route.funnel) {
+                        throw new Error(route?.funnel
+                            ? `tailscale serve reported public Funnel access on HTTPS port ${httpsPort}`
+                            : `tailscale serve did not report the configured route on HTTPS port ${httpsPort}`);
+                    }
+                    const liveUrl = previewUrl(route.host, httpsPort);
+                    await this.#awaitPublishedReady(liveUrl, process);
+                    const preview = activatePreview(pending, liveUrl);
+                    registry.previews = registry.previews.map((candidate) => candidate.id === pending.id ? preview : candidate);
+                    await this.#writeRegistry(registry);
+                    return referenceFrom(preview);
+                }
+                catch (error) {
+                    lastError = error;
+                    let routeRollbackCompleted = false;
+                    let processRollbackCompleted = false;
+                    try {
+                        const cleanupStatus = await this.#serveStatus();
+                        if (liveRoute(cleanupStatus, httpsPort, targetPort)) {
+                            await this.#disable({ httpsPort });
+                            routeRollbackCompleted = true;
+                        }
+                        else if (!commandSucceeded) {
+                            // A rejected command that left no exact route has no provider
+                            // mutation Factory can safely undo. Clear the pending intent;
+                            // genuinely ambiguous status failures retain it for sweeping.
+                            routeRollbackCompleted = true;
+                        }
+                    }
+                    catch (cleanupError) {
+                        lastError = new AggregateError([error, cleanupError], `Preview route setup and guarded rollback both failed on HTTPS port ${httpsPort}`);
+                    }
+                    try {
+                        processRollbackCompleted = await this.#stopManagedProcess(pending);
+                    }
+                    catch (cleanupError) {
+                        lastError = new AggregateError([lastError, cleanupError], `Preview setup and managed-process rollback both failed for ${pending.id}`);
+                    }
+                    if (routeRollbackCompleted && processRollbackCompleted) {
+                        registry.previews = registry.previews.filter((candidate) => candidate.id !== pending.id);
+                        try {
+                            await this.#writeRegistry(registry);
+                        }
+                        catch (registryError) {
+                            lastError = new AggregateError([lastError, registryError], `Preview route rollback succeeded but its pending registry entry could not be cleared on HTTPS port ${httpsPort}`);
+                        }
+                    }
+                    // Status already selected a free port. A command or verification
+                    // failure is provider-wide, not a reason to hammer the whole range.
+                    break;
+                }
+            }
+            throw new Error(`Unable to allocate a Tailscale Serve HTTPS port for ${input.service}`, lastError === undefined ? undefined : { cause: lastError });
+        });
+    }
+    async remove(reference) {
+        return await this.#exclusive(async () => {
+            const registry = await this.#readRegistry();
+            const preview = registry.previews.find((candidate) => candidate.managedBy === MANAGED_BY &&
+                candidate.id === reference.id &&
+                candidate.namespace === reference.namespace &&
+                candidate.owner === reference.owner &&
+                candidate.httpsPort === reference.httpsPort &&
+                candidate.targetPort === reference.targetPort);
+            // Idempotent teardown: an absent ownership record means this exact
+            // Factory route was already removed by a previous attempt or sweep.
+            if (!preview)
+                return true;
+            const status = await this.#serveStatus();
+            if (!liveRouteMatches(status, preview)) {
+                const processRemoved = await this.#stopManagedProcess(preview);
+                if (livePortConfigured(status, preview.httpsPort)) {
+                    // The port definitively points at another route. Forget the stale
+                    // ownership record, but never disable the replacement.
+                    if (!processRemoved)
+                        return false;
+                    registry.previews = registry.previews.filter((candidate) => candidate.id !== preview.id);
+                    await this.#writeRegistry(registry);
+                    return true;
+                }
+                if (preview.state === 'active' && processRemoved) {
+                    // Active means Factory previously observed and published the route.
+                    // Once both that route and its exact managed process are confirmed
+                    // absent, teardown is complete and retaining the row would make every
+                    // terminal retry fail forever. Pending rows remain conservative below
+                    // because they may represent an in-flight provider mutation.
+                    registry.previews = registry.previews.filter((candidate) => candidate.id !== preview.id);
+                    await this.#writeRegistry(registry);
+                    return true;
+                }
+                // An unconfigured port can be a transient status gap. Preserve the
+                // identity so a later startup sweep can still remove a route that
+                // becomes visible after this check.
+                return false;
+            }
+            await this.#disable(preview);
+            if (!await this.#stopManagedProcess(preview))
+                return false;
+            registry.previews = registry.previews.filter((candidate) => candidate.id !== preview.id);
+            await this.#writeRegistry(registry);
+            return true;
+        });
+    }
+    async sweep(input) {
+        return await this.#exclusive(async () => {
+            const active = new Set(input.activeOwners);
+            const activePreviewIds = input.activePreviewIds
+                ? new Set(input.activePreviewIds)
+                : undefined;
+            const registry = await this.#readRegistry();
+            let status = await this.#serveStatus();
+            const reaped = [];
+            const skipped = [];
+            const retained = [];
+            for (const preview of registry.previews) {
+                const ownerActive = active.has(preview.owner);
+                const exactActive = ownerActive && (!activePreviewIds || activePreviewIds.has(preview.id));
+                // Cross-daemon provisioning necessarily creates the provider record
+                // before the orchestrator can persist its returned ID. Give only recent
+                // records for a known-active owner a bounded chance to cross that gap.
+                const provisioningActive = ownerActive &&
+                    activePreviewIds !== undefined &&
+                    !activePreviewIds.has(preview.id) &&
+                    this.#withinProvisioningGrace(preview);
+                const authoritativeActive = exactActive || provisioningActive;
+                if (preview.managedBy !== MANAGED_BY ||
+                    preview.namespace !== input.namespace) {
+                    retained.push(preview);
+                    continue;
+                }
+                if (authoritativeActive) {
+                    try {
+                        const checkoutPath = preview.checkoutPath ?? preview.process?.cwd;
+                        if (!checkoutPath)
+                            throw new Error('managed preview checkout is not recoverable');
+                        const process = await this.#ensureManagedProcess(preview, checkoutPath);
+                        await this.#awaitReady(preview.targetPort, process);
+                        try {
+                            await this.#assertListenerOwned(preview.targetPort, process);
+                        }
+                        catch (error) {
+                            // This is a point-in-time ownership check. Arbitrary dev servers
+                            // cannot accept a reserved socket from Factory, so a narrow
+                            // check/use race remains; the final URL probe and every active
+                            // sweep repeat validation without introducing a bespoke proxy.
+                            if (liveRoute(status, preview.httpsPort, preview.targetPort)) {
+                                await this.#disable(preview);
+                                status = await this.#serveStatus();
+                            }
+                            throw error;
+                        }
+                        let route = liveRoute(status, preview.httpsPort, preview.targetPort);
+                        if (route?.funnel) {
+                            // This exact root route is ours, so it is safe to remove before
+                            // recreating it as tailnet-only Serve. Other mounts survive due
+                            // to the explicit root path selector.
+                            await this.#disable(preview);
+                            await this.#configure(preview);
+                            status = await this.#serveStatus();
+                            route = liveRoute(status, preview.httpsPort, preview.targetPort);
+                        }
+                        else if (!route) {
+                            if (livePortConfigured(status, preview.httpsPort)) {
+                                throw new Error('refusing route recovery because the HTTPS port has been repurposed');
+                            }
+                            await this.#configure(preview);
+                            status = await this.#serveStatus();
+                            route = liveRoute(status, preview.httpsPort, preview.targetPort);
+                        }
+                        if (!route || route.funnel) {
+                            throw new Error(route?.funnel
+                                ? 'recovered route still allows public Funnel access'
+                                : 'recovered Serve route is not observable');
+                        }
+                        const liveUrl = previewUrl(route.host, preview.httpsPort);
+                        await this.#awaitPublishedReady(liveUrl, process);
+                        retained.push(activatePreview({ ...preview, checkoutPath, process }, liveUrl));
+                    }
+                    catch (error) {
+                        retained.push(preview);
+                        skipped.push({
+                            id: preview.id,
+                            reason: `active preview recovery failed: ${error instanceof Error ? error.message : String(error)}`,
+                            node: preview.node,
+                        });
+                    }
+                    continue;
+                }
+                const route = liveRoute(status, preview.httpsPort, preview.targetPort);
+                if (!route) {
+                    const repurposed = livePortConfigured(status, preview.httpsPort);
+                    let processRemoved = false;
+                    try {
+                        processRemoved = await this.#stopManagedProcess(preview);
+                    }
+                    catch (error) {
+                        skipped.push({
+                            id: preview.id,
+                            reason: `managed process teardown failed: ${error instanceof Error ? error.message : String(error)}`,
+                            node: preview.node,
+                        });
+                    }
+                    if (!repurposed && preview.state === 'active' && processRemoved) {
+                        reaped.push(referenceFrom(preview));
+                    }
+                    else {
+                        if (!repurposed || !processRemoved)
+                            retained.push(preview);
+                        skipped.push({
+                            id: preview.id,
+                            reason: repurposed
+                                ? 'live route identity mismatch'
+                                : 'live route is not currently observable; retained for retry',
+                            node: preview.node,
+                        });
+                    }
+                    continue;
+                }
+                try {
+                    await this.#disable(preview);
+                    if (!await this.#stopManagedProcess(preview)) {
+                        throw new Error('managed process identity could not be confirmed stopped');
+                    }
+                    reaped.push(referenceFrom(activatePreview(preview, previewUrl(route.host, preview.httpsPort))));
+                }
+                catch (error) {
+                    retained.push(preview);
+                    skipped.push({
+                        id: preview.id,
+                        reason: error instanceof Error ? error.message : String(error),
+                        node: preview.node,
+                    });
+                }
+            }
+            registry.previews = retained;
+            await this.#writeRegistry(registry);
+            return { reaped, skipped };
+        });
+    }
+    async #awaitReady(port, process) {
+        await this.#awaitProbe(process, async () => await this.#isReady(port), `Preview command exited before local HTTP port ${port} became ready`, `Preview command did not make local HTTP port ${port} ready within ${this.#readyTimeoutMs}ms`, this.#readyTimeoutMs);
+    }
+    async #awaitPublishedReady(url, process) {
+        await this.#awaitProbe(process, async () => await this.#isPublishedReady(url), `Preview command exited before published URL ${url} became ready`, `Published preview URL ${url} did not become ready within ${this.#publishedReadyTimeoutMs}ms`, this.#publishedReadyTimeoutMs);
+    }
+    async #assertListenerOwned(port, process) {
+        const ownership = await this.#processes.listenerOwnership?.(process, port) ?? 'indeterminate';
+        if (ownership !== 'owned') {
+            throw new Error(ownership === 'unrelated'
+                ? `Local HTTP port ${port} is owned by a process outside the managed preview tree`
+                : `Ownership of local HTTP port ${port} could not be determined`);
+        }
+    }
+    async #awaitProbe(process, probe, exitedMessage, timeoutMessage, timeoutMs) {
+        const interval = Math.max(1, this.#readyPollIntervalMs);
+        const deadline = Date.now() + Math.max(0, timeoutMs);
+        while (true) {
+            if (!await this.#processes.isRunning(process)) {
+                throw new Error(exitedMessage);
+            }
+            const remaining = Math.max(1, deadline - Date.now());
+            if (await resolveBeforeDeadline(probe(), remaining, false))
+                return;
+            const remainingAfterProbe = deadline - Date.now();
+            if (remainingAfterProbe <= 0)
+                break;
+            await this.#sleep(Math.min(interval, remainingAfterProbe));
+        }
+        throw new Error(timeoutMessage);
+    }
+    #withinProvisioningGrace(preview) {
+        const createdAtMs = Date.parse(preview.createdAt);
+        if (!Number.isFinite(createdAtMs))
+            return false;
+        const ageMs = this.#now().getTime() - createdAtMs;
+        return ageMs >= 0 && ageMs <= PREVIEW_PROVISIONING_GRACE_MS;
+    }
+    async #stopManagedProcess(preview) {
+        if (preview.process && await this.#processes.stop(preview.process))
+            return true;
+        const recovered = await this.#processes.find(preview.id);
+        if (!recovered)
+            return true;
+        return await this.#processes.stop(recovered);
+    }
+    async #ensureManagedProcess(preview, checkoutPath) {
+        const recorded = preview.process && await this.#processes.isRunning(preview.process)
+            ? preview.process
+            : undefined;
+        const recovered = recorded ?? await this.#processes.find(preview.id);
+        if (!recovered && !await this.#isPortAvailable(preview.targetPort)) {
+            throw new Error(`Refusing to attach preview ${preview.id} to occupied unowned port ${preview.targetPort}`);
+        }
+        return await this.#processes.start({
+            id: preview.id,
+            command: preview.startCommand,
+            cwd: checkoutPath,
+            port: preview.targetPort,
+        });
+    }
+    async #disable(preview) {
+        await this.#run(this.#config.tailscaleBinary, [
+            'serve',
+            '--yes',
+            `--https=${preview.httpsPort}`,
+            '--set-path=/',
+            'off',
+        ]);
+    }
+    async #configure(preview) {
+        await this.#run(this.#config.tailscaleBinary, [
+            'serve',
+            '--bg',
+            '--yes',
+            `--https=${preview.httpsPort}`,
+            '--set-path=/',
+            `http://127.0.0.1:${preview.targetPort}`,
+        ]);
+    }
+    async #serveStatus() {
+        const result = await this.#run(this.#config.tailscaleBinary, ['serve', 'status', '--json']);
+        try {
+            return JSON.parse(result.stdout);
+        }
+        catch (error) {
+            throw new Error('tailscale serve status returned invalid JSON', { cause: error });
+        }
+    }
+    async #readRegistry() {
+        try {
+            const value = JSON.parse(await readFile(this.#config.registryPath, 'utf8'));
+            if (!isRecord(value) || value.version !== REGISTRY_VERSION || !Array.isArray(value.previews)) {
+                throw new Error('invalid preview registry');
+            }
+            return {
+                version: REGISTRY_VERSION,
+                previews: value.previews.filter(isRegistryPreview),
+            };
+        }
+        catch (error) {
+            if (isMissingFileError(error))
+                return { version: REGISTRY_VERSION, previews: [] };
+            throw error;
+        }
+    }
+    async #writeRegistry(registry) {
+        await mkdir(dirname(this.#config.registryPath), { recursive: true });
+        const temporary = `${this.#config.registryPath}.${process.pid}.${randomUUID()}.tmp`;
+        try {
+            const handle = await open(temporary, 'wx', 0o600);
+            try {
+                await handle.writeFile(`${JSON.stringify(registry, null, 2)}\n`);
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            await rename(temporary, this.#config.registryPath);
+        }
+        finally {
+            await rm(temporary, { force: true });
+        }
+    }
+    async #exclusive(operation) {
+        const withLock = async () => {
+            await mkdir(dirname(this.#config.registryPath), { recursive: true, mode: 0o700 });
+            const release = await lockfile.lock(this.#config.registryPath, {
+                realpath: false,
+                stale: PREVIEW_LOCK_STALE_MS,
+                update: PREVIEW_LOCK_STALE_MS / 2,
+                retries: {
+                    forever: true,
+                    factor: 1.2,
+                    minTimeout: 10,
+                    maxTimeout: 100,
+                    randomize: true,
+                },
+            });
+            try {
+                return await operation();
+            }
+            finally {
+                await release();
+            }
+        };
+        const result = this.#operation.then(withLock, withLock);
+        this.#operation = result.then(() => undefined, () => undefined);
+        return await result;
+    }
+}
+const activatePreview = (preview, url) => ({
+    ...preview,
+    state: 'active',
+    url,
+});
+const referenceFrom = ({ managedBy: _managedBy, state: _state, checkoutPath: _checkoutPath, ...preview }) => preview;
+const sameProcess = (left, right) => Boolean(left && right &&
+    left.pid === right.pid &&
+    left.startTime === right.startTime &&
+    left.cmdline === right.cmdline &&
+    left.cwd === right.cwd &&
+    left.marker === right.marker);
+const portRange = (start, end) => Array.from({ length: end - start + 1 }, (_, index) => start + index);
+const livePortConfigured = (status, httpsPort) => {
+    for (const config of serveConfigs(status)) {
+        const tcp = isRecord(config.TCP) ? config.TCP : undefined;
+        if (tcp && Object.hasOwn(tcp, String(httpsPort)))
+            return true;
+    }
+    return false;
+};
+const liveUpstreamPorts = (status) => {
+    const ports = new Set();
+    for (const config of serveConfigs(status)) {
+        const web = isRecord(config.Web) ? config.Web : undefined;
+        for (const rawServer of Object.values(web ?? {})) {
+            if (!isRecord(rawServer))
+                continue;
+            const handlers = isRecord(rawServer.Handlers) ? rawServer.Handlers : undefined;
+            for (const rawHandler of Object.values(handlers ?? {})) {
+                if (!isRecord(rawHandler) || typeof rawHandler.Proxy !== 'string')
+                    continue;
+                const match = rawHandler.Proxy.match(/^http:\/\/127\.0\.0\.1:(\d{1,5})(?:\/|$)/u);
+                const port = Number(match?.[1]);
+                if (Number.isInteger(port) && port >= 1 && port <= 65_535)
+                    ports.add(port);
+            }
+        }
+    }
+    return ports;
+};
+const liveRouteMatches = (status, preview) => Boolean(liveRoute(status, preview.httpsPort, preview.targetPort));
+const liveRoute = (status, httpsPort, targetPort) => {
+    const expectedProxy = `http://127.0.0.1:${targetPort}`;
+    for (const config of serveConfigs(status)) {
+        const tcp = isRecord(config.TCP) ? config.TCP : undefined;
+        const tcpHandler = tcp && isRecord(tcp[String(httpsPort)])
+            ? tcp[String(httpsPort)]
+            : undefined;
+        if (tcpHandler?.HTTPS !== true)
+            continue;
+        const web = isRecord(config.Web) ? config.Web : undefined;
+        for (const [hostPort, rawServer] of Object.entries(web ?? {})) {
+            if (!hostPort.endsWith(`:${httpsPort}`) || !isRecord(rawServer))
+                continue;
+            const handlers = isRecord(rawServer.Handlers) ? rawServer.Handlers : undefined;
+            const root = handlers && isRecord(handlers['/']) ? handlers['/'] : undefined;
+            if (root?.Proxy === expectedProxy) {
+                const allowFunnel = isRecord(config.AllowFunnel) ? config.AllowFunnel : undefined;
+                return {
+                    host: hostPort.slice(0, -String(httpsPort).length - 1),
+                    funnel: allowFunnel?.[hostPort] === true,
+                };
+            }
+        }
+    }
+    return undefined;
+};
+const serveConfigs = (status) => {
+    if (!isRecord(status))
+        return [];
+    const configs = [];
+    const visit = (config) => {
+        configs.push(config);
+        for (const nestedKey of ['Services', 'Foreground']) {
+            const nested = isRecord(config[nestedKey]) ? config[nestedKey] : undefined;
+            for (const child of Object.values(nested ?? {}).filter(isRecord))
+                visit(child);
+        }
+    };
+    visit(status);
+    return configs;
+};
+const previewUrl = (host, httpsPort) => `https://${host}${httpsPort === 443 ? '' : `:${httpsPort}`}/`;
+const isRegistryPreview = (value) => {
+    if (!isRecord(value))
+        return false;
+    const identity = value.managedBy === MANAGED_BY &&
+        value.provider === 'tailscale-serve' &&
+        value.access === 'tailnet' &&
+        value.lifetime === 'issue' &&
+        typeof value.id === 'string' &&
+        typeof value.namespace === 'string' &&
+        typeof value.owner === 'string' &&
+        typeof value.service === 'string' &&
+        typeof value.repo === 'string' &&
+        typeof value.startCommand === 'string' &&
+        typeof value.targetPort === 'number' &&
+        typeof value.httpsPort === 'number' &&
+        typeof value.createdAt === 'string';
+    if (!identity)
+        return false;
+    if (value.configuredTargetPort !== undefined && typeof value.configuredTargetPort !== 'number')
+        return false;
+    if (value.checkoutPath !== undefined && typeof value.checkoutPath !== 'string')
+        return false;
+    if (value.process !== undefined && !isPreviewProcessIdentity(value.process))
+        return false;
+    return value.state === 'pending' || (value.state === 'active' && typeof value.url === 'string');
+};
+const isPreviewProcessIdentity = (value) => isRecord(value) &&
+    Number.isInteger(value.pid) &&
+    Number(value.pid) > 0 &&
+    typeof value.startTime === 'string' &&
+    typeof value.cmdline === 'string' &&
+    typeof value.cwd === 'string' &&
+    typeof value.marker === 'string';
+const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const isMissingFileError = (error) => isRecord(error) && error.code === 'ENOENT';
+const portAvailable = async (port) => await new Promise((resolve) => {
+    const server = createServer();
+    let settled = false;
+    const finish = (available) => {
+        if (settled)
+            return;
+        settled = true;
+        resolve(available);
+    };
+    server.once('error', () => finish(false));
+    server.listen({ host: '127.0.0.1', port, exclusive: true }, () => {
+        server.close((error) => finish(!error));
+    });
+    server.unref();
+});
+const httpReady = async (port) => await new Promise((resolve) => {
+    let settled = false;
+    const finish = (ready) => {
+        if (settled)
+            return;
+        settled = true;
+        resolve(ready);
+    };
+    const request = get({ host: '127.0.0.1', port, path: '/', timeout: 1_000 }, (response) => {
+        response.resume();
+        finish(true);
+    });
+    request.once('error', () => finish(false));
+    request.once('timeout', () => {
+        request.destroy();
+        finish(false);
+    });
+});
+const httpsReady = async (url) => await new Promise((resolve) => {
+    let settled = false;
+    const finish = (ready) => {
+        if (settled)
+            return;
+        settled = true;
+        resolve(ready);
+    };
+    const request = getHttps(url, { timeout: 1_000 }, (response) => {
+        response.resume();
+        finish(true);
+    });
+    request.once('error', () => finish(false));
+    request.once('timeout', () => {
+        request.destroy();
+        finish(false);
+    });
+});
+const resolveBeforeDeadline = async (operation, timeoutMs, fallback) => await new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (result) => {
+        if (settled)
+            return;
+        settled = true;
+        clearTimeout(timer);
+        result();
+    };
+    const timer = setTimeout(() => finish(() => resolve(fallback)), Math.max(0, timeoutMs));
+    void operation.then((value) => finish(() => resolve(value)), (error) => finish(() => reject(error)));
+});
+//# sourceMappingURL=tailscale-preview.js.map