@reopt-ai/dev-proxy 1.1.1

package/dist/proxy/config.js

@@ -0,0 +1,78 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { homedir } from "node:os";
+// ── Paths ────────────────────────────────────────────────────
+export const CONFIG_DIR = resolve(homedir(), ".dev-proxy");
+export const GLOBAL_CONFIG_PATH = resolve(CONFIG_DIR, "config.json");
+export const PROJECT_CONFIG_NAME = ".dev-proxy.json";
+// ── Loaders ──────────────────────────────────────────────────
+function loadJson(path) {
+    try {
+        if (existsSync(path)) {
+            return JSON.parse(readFileSync(path, "utf-8"));
+        }
+    }
+    catch (err) {
+        console.error(`[dev-proxy] Failed to parse ${path}: ${err.message}`);
+    }
+    return null;
+}
+function resolveFilePath(rawPath, basePath) {
+    if (!rawPath)
+        return undefined;
+    if (isAbsolute(rawPath))
+        return rawPath;
+    return resolve(dirname(basePath), rawPath);
+}
+function parsePort(label, raw, fallback) {
+    if (raw === undefined)
+        return fallback;
+    if (Number.isInteger(raw) && raw > 0 && raw <= 65535)
+        return raw;
+    console.error(`[dev-proxy] Ignoring ${label}: expected integer port, received "${raw}"`);
+    return fallback;
+}
+function loadProjectConfig(projectDir) {
+    const configPath = resolve(projectDir, PROJECT_CONFIG_NAME);
+    if (!existsSync(configPath))
+        return null;
+    const raw = loadJson(configPath);
+    if (!raw)
+        return null;
+    return {
+        path: projectDir,
+        configPath,
+        routes: raw.routes ?? {},
+        worktrees: raw.worktrees ?? {},
+    };
+}
+// ── Main loader ──────────────────────────────────────────────
+function loadConfig() {
+    const global = loadJson(GLOBAL_CONFIG_PATH) ?? {};
+    const domain = global.domain ?? "localhost";
+    const port = parsePort("port", global.port, 3000);
+    const httpsPort = parsePort("httpsPort", global.httpsPort, 3443);
+    const certPath = resolveFilePath(global.certPath, GLOBAL_CONFIG_PATH);
+    const keyPath = resolveFilePath(global.keyPath, GLOBAL_CONFIG_PATH);
+    const projects = [];
+    if (global.projects) {
+        for (const projectDir of global.projects) {
+            const resolved = isAbsolute(projectDir)
+                ? projectDir
+                : resolve(CONFIG_DIR, projectDir);
+            const project = loadProjectConfig(resolved);
+            if (project) {
+                projects.push(project);
+            }
+            else {
+                console.error(`[dev-proxy] Project ${resolved}: no ${PROJECT_CONFIG_NAME} found`);
+            }
+        }
+    }
+    return { domain, port, httpsPort, certPath, keyPath, projects };
+}
+export const config = loadConfig();
+export const __testing = {
+    parsePort,
+    resolveFilePath,
+};

package/dist/proxy/routes.js

@@ -0,0 +1,70 @@
+import { config } from "./config.js";
+import { getWorktreeTarget } from "./worktrees.js";
+const ALLOWED_PROTOCOLS = new Set(["http:", "https:", "ws:", "wss:"]);
+// ── Helpers ──────────────────────────────────────────────────
+function formatTarget(url) {
+    return url.pathname === "/" && !url.search && !url.hash ? url.origin : url.toString();
+}
+function parseTarget(label, raw) {
+    try {
+        const target = new URL(raw);
+        if (!ALLOWED_PROTOCOLS.has(target.protocol)) {
+            console.error(`[dev-proxy] Ignoring ${label}: unsupported protocol "${target.protocol}"`);
+            return null;
+        }
+        return target;
+    }
+    catch (err) {
+        console.error(`[dev-proxy] Ignoring ${label}: ${err.message}`);
+        return null;
+    }
+}
+// ── Build from project configs ──────────────────────────────
+const parsedRoutes = new Map();
+let wildcardTarget = null;
+for (const project of config.projects) {
+    for (const [subdomain, target] of Object.entries(project.routes)) {
+        if (subdomain === "*") {
+            // First wildcard wins
+            wildcardTarget ??= parseTarget(`${project.path} routes.*`, target);
+            continue;
+        }
+        // First registration wins — later projects don't override
+        if (!parsedRoutes.has(subdomain)) {
+            const parsed = parseTarget(`${project.path} routes.${subdomain}`, target);
+            if (parsed)
+                parsedRoutes.set(subdomain, parsed);
+        }
+        else {
+            console.warn(`[dev-proxy] Ignoring duplicate subdomain "${subdomain}" from ${project.path} (already registered)`);
+        }
+    }
+}
+export const DOMAIN = config.domain;
+export const ROUTES = Object.fromEntries([...parsedRoutes.entries()].map(([sub, url]) => [sub, formatTarget(url)]));
+export const DEFAULT_TARGET = wildcardTarget ? formatTarget(wildcardTarget) : null;
+export const PROXY_PORT = config.port;
+export const HTTPS_PORT = config.httpsPort;
+export const CERT_PATH = config.certPath;
+export const KEY_PATH = config.keyPath;
+export function parseHost(host) {
+    // Strip port number before parsing (HTTP Host header may include :port)
+    const hostOnly = host.replace(/:\d+$/, "").toLowerCase();
+    const subdomain = hostOnly.split(".")[0] ?? hostOnly;
+    const delimIdx = subdomain.indexOf("--");
+    if (delimIdx !== -1) {
+        return {
+            worktree: subdomain.slice(0, delimIdx),
+            app: subdomain.slice(delimIdx + 2),
+        };
+    }
+    return { app: subdomain, worktree: null };
+}
+export function getTarget(host) {
+    const { app, worktree } = parseHost(host);
+    if (worktree) {
+        const target = getWorktreeTarget(worktree, app);
+        return { url: target, worktree };
+    }
+    return { url: parsedRoutes.get(app) ?? wildcardTarget, worktree: null };
+}

package/dist/proxy/server.js

@@ -0,0 +1,403 @@
+import http from "node:http";
+import https from "node:https";
+import fs from "node:fs";
+import net from "node:net";
+import tls from "node:tls";
+import { EventEmitter } from "node:events";
+import { getTarget, PROXY_PORT, HTTPS_PORT, CERT_PATH, KEY_PATH } from "./routes.js";
+import { resolveCerts } from "./certs.js";
+import { isDetailActive } from "../store.js";
+// Keep-Alive agent — reuses TCP connections to target servers
+const httpAgent = new http.Agent({ keepAlive: true, maxSockets: 64 });
+// Dev targets frequently use self-signed certs; keep the proxy permissive.
+// This only affects outbound connections to LOCAL dev servers, never public internet.
+const httpsAgent = new https.Agent({
+    keepAlive: true,
+    maxSockets: 64,
+    rejectUnauthorized: false,
+});
+// Monotonic counter — cheaper than crypto.randomUUID() for a dev tool
+let _nextId = 0;
+function nextId() {
+    return String(++_nextId);
+}
+function escapeHtml(s) {
+    return s
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+function worktreeErrorPage(worktree, target, error) {
+    return `<!DOCTYPE html>
+<html lang="ko"><head><meta charset="utf-8"><title>Worktree Offline</title>
+<style>
+  body{font-family:system-ui,sans-serif;display:flex;justify-content:center;align-items:center;min-height:100vh;margin:0;background:#0a0a0a;color:#e5e5e5}
+  .card{max-width:480px;padding:2.5rem;border:1px solid #333;border-radius:12px;text-align:center}
+  h1{font-size:1.25rem;color:#f97316;margin:0 0 1rem}
+  code{background:#1a1a2e;padding:0.6rem 1rem;border-radius:6px;display:block;margin:1rem 0;color:#60a5fa;font-size:0.9rem;text-align:left}
+  .dim{color:#888;font-size:0.85rem}
+</style></head>
+<body><div class="card">
+  <h1>Worktree &ldquo;${escapeHtml(worktree)}&rdquo; is offline</h1>
+  <p>Target <strong>${escapeHtml(target.origin)}</strong> is not responding.</p>
+  <code>cd worktree-${escapeHtml(worktree)} && pnpm dev</code>
+  <p class="dim">${escapeHtml(error)}</p>
+</div></body></html>`;
+}
+function parseCookies(header) {
+    if (!header)
+        return {};
+    const cookies = {};
+    for (const pair of header.split(";")) {
+        const [name, ...rest] = pair.split("=");
+        if (name)
+            cookies[name.trim()] = rest.join("=").trim();
+    }
+    return cookies;
+}
+function parseQuery(url) {
+    if (!url)
+        return {};
+    const idx = url.indexOf("?");
+    if (idx === -1)
+        return {};
+    const params = {};
+    const search = new URLSearchParams(url.slice(idx + 1));
+    for (const [key, value] of search) {
+        params[key] = value;
+    }
+    return params;
+}
+function headersToRecord(raw) {
+    const result = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (value !== undefined) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function formatListenError(err, port) {
+    const code = err.code;
+    if (code === "EADDRINUSE") {
+        return new Error(`port ${port} is already in use (another dev-proxy instance may already be running)`);
+    }
+    if (code === "EACCES" || code === "EPERM") {
+        return new Error(`port ${port} cannot be opened (${err.message})`);
+    }
+    return err;
+}
+function normalizeTargetProtocol(protocol) {
+    return protocol === "https:" || protocol === "wss:" ? "https:" : "http:";
+}
+function targetPort(target) {
+    if (target.port) {
+        return Number(target.port);
+    }
+    return normalizeTargetProtocol(target.protocol) === "https:" ? 443 : 80;
+}
+function requestTransport(target) {
+    return normalizeTargetProtocol(target.protocol) === "https:"
+        ? { request: https.request, agent: httpsAgent }
+        : { request: http.request, agent: httpAgent };
+}
+function connectToTarget(target, onConnect) {
+    const port = targetPort(target);
+    if (normalizeTargetProtocol(target.protocol) === "https:") {
+        return tls.connect({
+            host: target.hostname,
+            port,
+            servername: target.hostname,
+            rejectUnauthorized: false,
+        }, onConnect);
+    }
+    return net.connect(port, target.hostname, onConnect);
+}
+function createRequestHandler(emitter, proto) {
+    return (clientReq, clientRes) => {
+        const { url: target, worktree } = getTarget(clientReq.headers.host ?? "");
+        const start = performance.now();
+        const id = nextId();
+        const host = clientReq.headers.host ?? "";
+        // No target resolved — either unregistered worktree or unknown subdomain
+        if (!target) {
+            const errorMsg = worktree ? "worktree not registered" : "no route configured";
+            const event = {
+                id,
+                type: "http",
+                protocol: proto,
+                timestamp: Date.now(),
+                method: clientReq.method ?? "GET",
+                url: clientReq.url ?? "/",
+                host,
+                target: "",
+                worktree: worktree ?? undefined,
+                error: errorMsg,
+                cookies: {},
+                query: {},
+                requestHeaders: {},
+                responseHeaders: {},
+            };
+            emitter.emit("request", event);
+            emitter.emit("request:error", event);
+            if (worktree) {
+                clientRes.writeHead(502, { "Content-Type": "text/html; charset=utf-8" });
+                clientRes.end(worktreeErrorPage(worktree, new URL("http://unknown"), errorMsg));
+            }
+            else {
+                clientRes.writeHead(502, { "Content-Type": "text/plain" });
+                clientRes.end(`Dev proxy: ${errorMsg} for ${host}`);
+            }
+            return;
+        }
+        const collectDetail = isDetailActive();
+        const event = {
+            id,
+            type: "http",
+            protocol: proto,
+            timestamp: Date.now(),
+            method: clientReq.method ?? "GET",
+            url: clientReq.url ?? "/",
+            host,
+            target: target.origin,
+            worktree: worktree ?? undefined,
+            cookies: collectDetail ? parseCookies(clientReq.headers.cookie) : {},
+            query: collectDetail ? parseQuery(clientReq.url) : {},
+            requestHeaders: collectDetail ? headersToRecord(clientReq.headers) : {},
+            responseHeaders: {},
+        };
+        emitter.emit("request", event);
+        // Strip any client-supplied forwarding headers, then set ours
+        const headers = clientReq.headers;
+        delete headers["x-forwarded-for"];
+        delete headers["x-forwarded-host"];
+        delete headers["x-forwarded-proto"];
+        headers["x-forwarded-for"] = clientReq.socket.remoteAddress ?? "127.0.0.1";
+        headers["x-forwarded-host"] = host;
+        headers["x-forwarded-proto"] = proto;
+        // Rewrite Host so Next.js proxy.ts middleware sees the original subdomain
+        if (worktree) {
+            headers.host = host.replace(`${worktree}--`, "");
+        }
+        const transport = requestTransport(target);
+        const proxyReq = transport.request({
+            hostname: target.hostname,
+            port: targetPort(target),
+            path: clientReq.url,
+            method: clientReq.method,
+            headers,
+            agent: transport.agent,
+        }, (proxyRes) => {
+            // Track response body size, emit once on end
+            let responseSize = 0;
+            proxyRes.on("data", (chunk) => {
+                responseSize += chunk.length;
+            });
+            proxyRes.on("end", () => {
+                event.statusCode = proxyRes.statusCode;
+                event.duration = Math.round(performance.now() - start);
+                event.responseHeaders = collectDetail ? headersToRecord(proxyRes.headers) : {};
+                event.responseSize = responseSize;
+                emitter.emit("request:complete", event);
+            });
+            proxyRes.on("error", (err) => {
+                event.error = err.message;
+                event.duration = Math.round(performance.now() - start);
+                emitter.emit("request:error", event);
+                if (!clientRes.headersSent)
+                    clientRes.writeHead(502);
+                clientRes.end();
+            });
+            clientRes.on("error", () => {
+                // Client disconnected — best-effort, nothing to do
+                proxyRes.destroy();
+            });
+            clientRes.writeHead(proxyRes.statusCode ?? 502, proxyRes.headers);
+            proxyRes.pipe(clientRes);
+        });
+        proxyReq.on("error", (err) => {
+            event.error = err.message;
+            event.duration = Math.round(performance.now() - start);
+            emitter.emit("request:error", event);
+            if (!clientRes.headersSent) {
+                if (worktree) {
+                    clientRes.writeHead(502, {
+                        "Content-Type": "text/html; charset=utf-8",
+                    });
+                    clientRes.end(worktreeErrorPage(worktree, target, err.message));
+                }
+                else {
+                    clientRes.writeHead(502, { "Content-Type": "text/plain" });
+                    clientRes.end(`Dev proxy: target not ready (${err.message})`);
+                }
+            }
+            else {
+                clientRes.end();
+            }
+        });
+        clientReq.pipe(proxyReq);
+    };
+}
+function createUpgradeHandler(emitter, proto) {
+    return (clientReq, clientSocket, head) => {
+        const { url: target, worktree } = getTarget(clientReq.headers.host ?? "");
+        const host = clientReq.headers.host ?? "";
+        // No target resolved — close socket immediately
+        if (!target) {
+            clientSocket.end("HTTP/1.1 502 Bad Gateway\r\n\r\n");
+            return;
+        }
+        const id = nextId();
+        const wsStart = performance.now();
+        const wsEvent = {
+            id,
+            type: "ws",
+            protocol: proto === "https" ? "wss" : "ws",
+            timestamp: Date.now(),
+            url: clientReq.url ?? "/",
+            host,
+            target: target.origin,
+            worktree: worktree ?? undefined,
+            status: "open",
+        };
+        emitter.emit("ws", wsEvent);
+        // Rewrite Host header for worktree routing
+        if (worktree) {
+            clientReq.headers.host = host.replace(`${worktree}--`, "");
+        }
+        let closed = false;
+        const emitClose = (error) => {
+            if (closed)
+                return;
+            closed = true;
+            const closeEvent = {
+                ...wsEvent,
+                status: error ? "error" : "closed",
+                error,
+                duration: Math.round(performance.now() - wsStart),
+            };
+            emitter.emit("ws", closeEvent);
+        };
+        // Guard: bail out if the client already disconnected during routing
+        if (clientSocket.destroyed) {
+            emitClose("client disconnected before upgrade");
+            return;
+        }
+        const proxySocket = connectToTarget(target, () => {
+            const reqHeaders = [`${clientReq.method} ${clientReq.url} HTTP/1.1`];
+            for (const [key, value] of Object.entries(clientReq.headers)) {
+                if (value &&
+                    key !== "x-forwarded-for" &&
+                    key !== "x-forwarded-host" &&
+                    key !== "x-forwarded-proto") {
+                    reqHeaders.push(`${key}: ${Array.isArray(value) ? value.join(", ") : value}`);
+                }
+            }
+            reqHeaders.push(`x-forwarded-for: ${clientReq.socket.remoteAddress ?? "127.0.0.1"}`);
+            reqHeaders.push(`x-forwarded-host: ${clientReq.headers.host ?? ""}`);
+            reqHeaders.push(`x-forwarded-proto: ${proto}`);
+            proxySocket.write(reqHeaders.join("\r\n") + "\r\n\r\n");
+            if (head.length)
+                proxySocket.write(head);
+            proxySocket.pipe(clientSocket);
+            clientSocket.pipe(proxySocket);
+        });
+        // Register error handler immediately to prevent unhandled errors
+        // between socket creation and the onConnect callback
+        proxySocket.on("error", (err) => {
+            emitClose(err.message);
+            clientSocket.destroy();
+        });
+        proxySocket.on("close", () => {
+            emitClose();
+        });
+        clientSocket.on("close", () => {
+            emitClose();
+            proxySocket.destroy();
+        });
+        clientSocket.on("error", (err) => {
+            emitClose(err.message);
+            proxySocket.destroy();
+        });
+    };
+}
+export function createProxyServer() {
+    const emitter = new EventEmitter();
+    const server = http.createServer(createRequestHandler(emitter, "http"));
+    server.on("upgrade", createUpgradeHandler(emitter, "http"));
+    server.on("error", (err) => {
+        console.error(`[dev-proxy] HTTP server error: ${err.message}`);
+    });
+    let httpsServer = null;
+    const certs = resolveCerts(CERT_PATH, KEY_PATH);
+    if (certs) {
+        try {
+            const cert = fs.readFileSync(certs.certPath);
+            const key = fs.readFileSync(certs.keyPath);
+            httpsServer = https.createServer({ cert, key }, createRequestHandler(emitter, "https"));
+            httpsServer.on("upgrade", createUpgradeHandler(emitter, "https"));
+            httpsServer.on("error", (err) => {
+                console.error(`[dev-proxy] HTTPS server error: ${err.message}`);
+            });
+        }
+        catch (err) {
+            console.error(`[dev-proxy] HTTPS disabled — failed to read certificates: ${err.message}`);
+        }
+    }
+    return { server, httpsServer, emitter };
+}
+/** Destroy keep-alive agents to close lingering sockets on shutdown. */
+export function destroyAgents() {
+    httpAgent.destroy();
+    httpsAgent.destroy();
+}
+export function startProxyServer(server, httpsServer) {
+    return new Promise((resolve, reject) => {
+        const fail = (err, port) => {
+            try {
+                server.close();
+            }
+            catch {
+                /* ignored: best-effort cleanup */
+            }
+            try {
+                httpsServer?.close();
+            }
+            catch {
+                /* ignored: best-effort cleanup */
+            }
+            reject(formatListenError(err, port));
+        };
+        const failHttp = (err) => {
+            fail(err, PROXY_PORT);
+        };
+        const failHttps = (err) => {
+            fail(err, HTTPS_PORT);
+        };
+        server.once("error", failHttp);
+        server.listen(PROXY_PORT, () => {
+            if (httpsServer) {
+                httpsServer.once("error", failHttps);
+                httpsServer.listen(HTTPS_PORT, () => {
+                    server.off("error", failHttp);
+                    httpsServer.off("error", failHttps);
+                    resolve();
+                });
+            }
+            else {
+                server.off("error", failHttp);
+                resolve();
+            }
+        });
+    });
+}
+export const __testing = {
+    escapeHtml,
+    parseCookies,
+    parseQuery,
+    headersToRecord,
+    formatListenError,
+    normalizeTargetProtocol,
+    targetPort,
+};

package/dist/proxy/types.js

@@ -0,0 +1 @@
+export {};

package/dist/proxy/worktrees.js

@@ -0,0 +1,116 @@
+import { existsSync, readFileSync, watch } from "node:fs";
+import { basename, dirname } from "node:path";
+import { useSyncExternalStore } from "react";
+import { config } from "./config.js";
+// ── State ────────────────────────────────────────────────────
+let worktreeMap = new Map();
+const watchers = [];
+let debounceTimer = null;
+const listeners = new Set();
+function notify() {
+    for (const l of listeners)
+        l();
+}
+// ── Core API ─────────────────────────────────────────────────
+function isValidEntry(entry) {
+    if ("ports" in entry) {
+        return Object.keys(entry.ports).length > 0;
+    }
+    return typeof entry.port === "number";
+}
+function readRegistry() {
+    const next = new Map();
+    for (const project of config.projects) {
+        const worktrees = readProjectWorktrees(project);
+        for (const [branch, entry] of Object.entries(worktrees)) {
+            if (isValidEntry(entry) && !next.has(branch)) {
+                next.set(branch, entry);
+            }
+        }
+    }
+    worktreeMap = next;
+    notify();
+}
+function readProjectWorktrees(project) {
+    try {
+        if (!existsSync(project.configPath))
+            return project.worktrees;
+        const raw = readFileSync(project.configPath, "utf-8");
+        const data = JSON.parse(raw);
+        return data.worktrees ?? {};
+    }
+    catch {
+        // Config read/parse failed — fall back to cached worktrees
+        return project.worktrees;
+    }
+}
+export function loadRegistry() {
+    readRegistry();
+    for (const project of config.projects) {
+        if (!existsSync(project.configPath))
+            continue;
+        try {
+            const dir = dirname(project.configPath);
+            const base = basename(project.configPath);
+            const watcher = watch(dir, (_event, filename) => {
+                if (filename !== base)
+                    return;
+                if (debounceTimer)
+                    clearTimeout(debounceTimer);
+                debounceTimer = setTimeout(readRegistry, 100);
+            });
+            watcher.on("error", () => {
+                /* intentional no-op: watcher errors are non-fatal */
+            });
+            watchers.push(watcher);
+        }
+        catch {
+            // Directory doesn't exist — no watcher needed
+        }
+    }
+}
+/**
+ * Resolve worktree target URL.
+ * For multi-service entries, `service` selects the subdomain port.
+ * For legacy single-port entries, `service` is ignored.
+ */
+export function getWorktreeTarget(branch, service) {
+    const entry = worktreeMap.get(branch);
+    if (!entry)
+        return null;
+    if ("ports" in entry) {
+        const port = service && service in entry.ports
+            ? entry.ports[service]
+            : Object.values(entry.ports)[0];
+        if (port === undefined)
+            return null;
+        return new URL(`http://localhost:${port}`);
+    }
+    return new URL(`http://localhost:${entry.port}`);
+}
+export function getActiveWorktrees() {
+    return new Map(worktreeMap);
+}
+// ── React hook ──────────────────────────────────────────────
+function subscribe(cb) {
+    listeners.add(cb);
+    return () => {
+        listeners.delete(cb);
+    };
+}
+function getSnapshot() {
+    return worktreeMap;
+}
+export function useWorktrees() {
+    return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+export const __testing = { isValidEntry };
+export function stopRegistry() {
+    for (const w of watchers)
+        w.close();
+    watchers.length = 0;
+    if (debounceTimer) {
+        clearTimeout(debounceTimer);
+        debounceTimer = null;
+    }
+}