@reopt-ai/dev-proxy 1.1.1

package/dist/commands/doctor.js

@@ -0,0 +1,334 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from "react";
+import { existsSync, readFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { resolve } from "node:path";
+import * as dns from "node:dns";
+import * as net from "node:net";
+import { Box, Text, render, useApp } from "ink";
+import { config, CONFIG_DIR, GLOBAL_CONFIG_PATH } from "../proxy/config.js";
+import { getEntryPorts, readProjectConfig } from "../cli/config-io.js";
+import { Header, Check, Section } from "../cli/output.js";
+function checkConfigSection() {
+    const results = [];
+    // config.json exists + valid JSON
+    let configExists = false;
+    if (existsSync(GLOBAL_CONFIG_PATH)) {
+        try {
+            JSON.parse(readFileSync(GLOBAL_CONFIG_PATH, "utf-8"));
+            configExists = true;
+            results.push({ ok: true, label: "config.json exists and is valid JSON" });
+        }
+        catch {
+            results.push({ ok: false, label: "config.json exists but is not valid JSON" });
+        }
+    }
+    else {
+        results.push({ ok: false, label: "config.json not found" });
+    }
+    // domain is set
+    if (configExists && config.domain && config.domain !== "localhost") {
+        results.push({ ok: true, label: `domain is set: ${config.domain}` });
+    }
+    else {
+        results.push({
+            ok: false,
+            warn: true,
+            label: `domain: ${config.domain || "not set"}`,
+        });
+    }
+    // projects count
+    results.push({
+        ok: config.projects.length > 0,
+        warn: config.projects.length === 0,
+        label: `${String(config.projects.length)} project(s) registered`,
+    });
+    return results;
+}
+function checkProjectsSection() {
+    const results = [];
+    for (const project of config.projects) {
+        const exists = existsSync(project.configPath);
+        results.push({
+            ok: exists,
+            label: exists
+                ? `.dev-proxy.json exists: ${project.path}`
+                : `.dev-proxy.json missing: ${project.path}`,
+        });
+        if (exists) {
+            const routeCount = Object.keys(project.routes).length;
+            const worktreeCount = Object.keys(project.worktrees).length;
+            results.push({
+                ok: routeCount > 0,
+                warn: routeCount === 0,
+                label: `  ${String(routeCount)} route(s), ${String(worktreeCount)} worktree(s)`,
+            });
+        }
+    }
+    return results;
+}
+function checkTlsSection() {
+    const results = [];
+    // mkcert installed
+    try {
+        execFileSync("which", ["mkcert"], { stdio: "pipe" });
+        results.push({ ok: true, label: "mkcert is installed" });
+    }
+    catch {
+        results.push({ ok: false, label: "mkcert is not installed" });
+    }
+    // cert files
+    const certsDir = resolve(CONFIG_DIR, "certs");
+    const certFile = resolve(certsDir, "cert.pem");
+    const keyFile = resolve(certsDir, "key.pem");
+    const certExists = existsSync(certFile);
+    const keyExists = existsSync(keyFile);
+    results.push({
+        ok: certExists && keyExists,
+        label: certExists && keyExists
+            ? `cert files exist in ${certsDir}`
+            : `cert files missing in ${certsDir}`,
+    });
+    return results;
+}
+function collectSubdomains(projects) {
+    const subs = new Set();
+    for (const project of projects) {
+        for (const sub of Object.keys(project.routes)) {
+            if (sub !== "*") {
+                subs.add(sub);
+            }
+        }
+    }
+    return [...subs];
+}
+function withTimeout(promise, ms) {
+    return Promise.race([
+        promise,
+        new Promise((_, reject) => {
+            setTimeout(() => {
+                reject(new Error("timeout"));
+            }, ms);
+        }),
+    ]);
+}
+async function checkDns(subdomains, domain) {
+    const results = [];
+    for (const sub of subdomains) {
+        const hostname = `${sub}.${domain}`;
+        try {
+            const { address } = await withTimeout(dns.promises.lookup(hostname, { family: 4 }), 5000);
+            results.push({
+                ok: address === "127.0.0.1",
+                warn: address !== "127.0.0.1",
+                label: address === "127.0.0.1"
+                    ? `${hostname} → 127.0.0.1`
+                    : `${hostname} → ${address} (expected 127.0.0.1)`,
+            });
+        }
+        catch {
+            results.push({ ok: false, label: `${hostname} does not resolve` });
+        }
+    }
+    return results;
+}
+function checkPort(port) {
+    return new Promise((res) => {
+        const server = net.createServer();
+        server.once("error", () => {
+            res({ ok: false, label: `:${String(port)} is in use` });
+        });
+        server.listen(port, () => {
+            server.close(() => {
+                res({ ok: true, label: `:${String(port)} is available` });
+            });
+        });
+    });
+}
+// ── Worktree checks ──────────────────────────────────────────
+function checkWorktreeConfig(projects) {
+    const results = [];
+    for (const project of projects) {
+        const cfg = readProjectConfig(project.path);
+        const worktrees = cfg.worktrees ?? {};
+        const wtConfig = cfg.worktreeConfig;
+        const entries = Object.entries(worktrees);
+        if (entries.length === 0)
+            continue;
+        // Port conflict check — across all worktrees in this project
+        const portMap = new Map();
+        for (const [branch, entry] of entries) {
+            for (const p of getEntryPorts(entry)) {
+                const existing = portMap.get(p) ?? [];
+                existing.push(branch);
+                portMap.set(p, existing);
+            }
+        }
+        for (const [port, branches] of portMap) {
+            if (branches.length > 1) {
+                results.push({
+                    ok: false,
+                    label: `port ${port} used by multiple worktrees: ${branches.join(", ")}`,
+                });
+            }
+        }
+        if ([...portMap.values()].every((b) => b.length === 1)) {
+            results.push({ ok: true, label: `no port conflicts in ${project.path}` });
+        }
+        // worktreeConfig validation
+        if (wtConfig) {
+            const [min, max] = wtConfig.portRange;
+            if (min >= max) {
+                results.push({
+                    ok: false,
+                    label: `invalid portRange [${min}, ${max}] — min must be less than max`,
+                });
+            }
+            else {
+                results.push({ ok: true, label: `portRange [${min}, ${max}] is valid` });
+            }
+            // services vs routes cross-check
+            if (wtConfig.services) {
+                const routeKeys = new Set(Object.keys(cfg.routes ?? {}));
+                for (const svc of Object.keys(wtConfig.services)) {
+                    if (!routeKeys.has(svc) && svc !== "*") {
+                        results.push({
+                            ok: false,
+                            warn: true,
+                            label: `service "${svc}" not found in routes`,
+                        });
+                    }
+                }
+            }
+        }
+        // Per-worktree directory + env file checks
+        if (wtConfig) {
+            for (const [branch, entry] of entries) {
+                const dirPattern = wtConfig.directory.replace("{branch}", branch);
+                const worktreeDir = resolve(project.path, dirPattern);
+                // Directory exists
+                if (existsSync(worktreeDir)) {
+                    results.push({ ok: true, label: `${branch}: directory exists` });
+                    // .env.local exists (if services defined)
+                    if (wtConfig.services) {
+                        const envFile = wtConfig.envFile ?? ".env.local";
+                        const envPath = resolve(worktreeDir, envFile);
+                        if (existsSync(envPath)) {
+                            results.push({ ok: true, label: `${branch}: ${envFile} exists` });
+                        }
+                        else {
+                            results.push({
+                                ok: false,
+                                warn: true,
+                                label: `${branch}: ${envFile} missing — run 'dev-proxy worktree create' to regenerate`,
+                            });
+                        }
+                    }
+                }
+                else {
+                    // Skip "main" — it's the project root, not a worktree directory
+                    if (branch !== "main") {
+                        results.push({
+                            ok: false,
+                            warn: true,
+                            label: `${branch}: directory not found at ${worktreeDir}`,
+                        });
+                    }
+                }
+                // Check if worktree ports are reachable
+                // (done async below)
+                void entry; // used in async check
+            }
+        }
+    }
+    return results;
+}
+function checkWorktreePort(port, branch, service) {
+    const label = service ? `${branch}/${service} :${port}` : `${branch} :${port}`;
+    return new Promise((res) => {
+        const socket = net.createConnection({ port, host: "127.0.0.1" }, () => {
+            socket.destroy();
+            res({ ok: true, label: `${label} is responding` });
+        });
+        socket.on("error", () => {
+            socket.destroy();
+            res({ ok: false, warn: true, label: `${label} is not responding` });
+        });
+        socket.setTimeout(2000, () => {
+            socket.destroy();
+            res({ ok: false, warn: true, label: `${label} timed out` });
+        });
+    });
+}
+async function checkWorktreePorts(projects) {
+    const checks = [];
+    for (const project of projects) {
+        const cfg = readProjectConfig(project.path);
+        const worktrees = cfg.worktrees ?? {};
+        for (const [branch, entry] of Object.entries(worktrees)) {
+            if ("ports" in entry) {
+                for (const [svc, port] of Object.entries(entry.ports)) {
+                    checks.push(checkWorktreePort(port, branch, svc));
+                }
+            }
+            else {
+                checks.push(checkWorktreePort(entry.port, branch));
+            }
+        }
+    }
+    if (checks.length === 0)
+        return [];
+    return Promise.all(checks);
+}
+function Doctor() {
+    const { exit } = useApp();
+    const [asyncChecks, setAsyncChecks] = useState(null);
+    const configChecks = checkConfigSection();
+    const projectChecks = checkProjectsSection();
+    const tlsChecks = checkTlsSection();
+    const worktreeChecks = checkWorktreeConfig(config.projects);
+    useEffect(() => {
+        let cancelled = false;
+        void (async () => {
+            const subdomains = collectSubdomains(config.projects);
+            const [dnsResults, httpPort, httpsPort, wtPorts] = await Promise.all([
+                checkDns(subdomains, config.domain),
+                checkPort(config.port),
+                checkPort(config.httpsPort),
+                checkWorktreePorts(config.projects),
+            ]);
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- mutated in cleanup
+            if (!cancelled) {
+                setAsyncChecks({
+                    dns: dnsResults,
+                    ports: [httpPort, httpsPort],
+                    worktreePorts: wtPorts,
+                });
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, []);
+    useEffect(() => {
+        if (asyncChecks) {
+            setTimeout(exit, 0);
+        }
+    }, [asyncChecks, exit]);
+    const allChecks = [
+        ...configChecks,
+        ...projectChecks,
+        ...tlsChecks,
+        ...worktreeChecks,
+        ...(asyncChecks?.dns ?? []),
+        ...(asyncChecks?.ports ?? []),
+        ...(asyncChecks?.worktreePorts ?? []),
+    ];
+    const passed = allChecks.filter((c) => c.ok).length;
+    const warnings = allChecks.filter((c) => !c.ok && c.warn).length;
+    const failed = allChecks.filter((c) => !c.ok && !c.warn).length;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Header, { text: "dev-proxy doctor" }), _jsx(Section, { title: "Config", children: configChecks.map((c) => (_jsx(Check, { ok: c.ok, warn: c.warn, label: c.label }, c.label))) }), _jsx(Section, { title: "Projects", children: projectChecks.length > 0 ? (projectChecks.map((c) => (_jsx(Check, { ok: c.ok, warn: c.warn, label: c.label }, c.label)))) : (_jsx(Check, { ok: false, warn: true, label: "no projects registered" })) }), _jsx(Section, { title: "DNS", children: asyncChecks ? (asyncChecks.dns.length > 0 ? (asyncChecks.dns.map((c) => (_jsx(Check, { ok: c.ok, warn: c.warn, label: c.label }, c.label)))) : (_jsx(Check, { ok: true, label: "no subdomains to check" }))) : (_jsx(Text, { dimColor: true, children: "    checking..." })) }), _jsx(Section, { title: "TLS", children: tlsChecks.map((c) => (_jsx(Check, { ok: c.ok, warn: c.warn, label: c.label }, c.label))) }), _jsx(Section, { title: "Ports", children: asyncChecks ? (asyncChecks.ports.map((c) => (_jsx(Check, { ok: c.ok, warn: c.warn, label: c.label }, c.label)))) : (_jsx(Text, { dimColor: true, children: "    checking..." })) }), (worktreeChecks.length > 0 || (asyncChecks?.worktreePorts.length ?? 0) > 0) && (_jsxs(Section, { title: "Worktrees", children: [worktreeChecks.map((c) => (_jsx(Check, { ok: c.ok, warn: c.warn, label: c.label }, c.label))), asyncChecks
+                        ? asyncChecks.worktreePorts.map((c) => (_jsx(Check, { ok: c.ok, warn: c.warn, label: c.label }, c.label)))
+                        : worktreeChecks.length > 0 && (_jsx(Text, { dimColor: true, children: "    checking ports..." }))] })), asyncChecks && (_jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: ["  ", String(allChecks.length), " checks:", " ", _jsxs(Text, { color: "green", children: [String(passed), " passed"] }), warnings > 0 && (_jsxs(Text, { children: [", ", _jsxs(Text, { color: "yellow", children: [String(warnings), " warnings"] })] })), failed > 0 && (_jsxs(Text, { children: [", ", _jsxs(Text, { color: "red", children: [String(failed), " failed"] })] }))] }) }))] }));
+}
+render(_jsx(Doctor, {}));

package/dist/commands/help.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, render } from "ink";
+import { ExitOnRender } from "../cli/output.js";
+function Help() {
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, children: [_jsx(ExitOnRender, {}), _jsx(Text, { bold: true, children: "dev-proxy" }), _jsx(Text, { dimColor: true, children: " subdomain-based reverse proxy with traffic inspector" }), _jsx(Text, { children: "" }), _jsx(Text, { bold: true, children: "Usage" }), _jsxs(Text, { children: ["  ", "$ dev-proxy [command]"] }), _jsx(Text, { children: "" }), _jsx(Text, { bold: true, children: "Commands" }), _jsxs(Text, { children: ["  (none)              ", _jsx(Text, { dimColor: true, children: "Start proxy and open traffic inspector" })] }), _jsxs(Text, { children: ["  init                ", _jsx(Text, { dimColor: true, children: "Interactive setup wizard" })] }), _jsxs(Text, { children: ["  status              ", _jsx(Text, { dimColor: true, children: "Show current configuration and routing table" })] }), _jsxs(Text, { children: ["  doctor              ", _jsx(Text, { dimColor: true, children: "Run environment diagnostics" })] }), _jsxs(Text, { children: ["  config              ", _jsx(Text, { dimColor: true, children: "View or modify global settings" })] }), _jsxs(Text, { children: ["  project             ", _jsx(Text, { dimColor: true, children: "Manage registered projects" })] }), _jsxs(Text, { children: ["  worktree            ", _jsx(Text, { dimColor: true, children: "Manage worktree port mappings" })] }), _jsx(Text, { children: "" }), _jsx(Text, { bold: true, children: "Options" }), _jsxs(Text, { children: ["  --help, -h          ", _jsx(Text, { dimColor: true, children: "Show this help" })] }), _jsxs(Text, { children: ["  --version, -v       ", _jsx(Text, { dimColor: true, children: "Show version" })] }), _jsx(Text, { children: "" }), _jsx(Text, { bold: true, children: "Examples" }), _jsxs(Text, { children: ["  ", _jsx(Text, { color: "cyan", children: "$ dev-proxy" }), "                          ", _jsx(Text, { dimColor: true, children: "Start the proxy" })] }), _jsxs(Text, { children: ["  ", _jsx(Text, { color: "cyan", children: "$ dev-proxy init" }), "                     ", _jsx(Text, { dimColor: true, children: "Set up a new project" })] }), _jsxs(Text, { children: ["  ", _jsx(Text, { color: "cyan", children: "$ dev-proxy project add ." }), "            ", _jsx(Text, { dimColor: true, children: "Register current directory" })] }), _jsxs(Text, { children: ["  ", _jsx(Text, { color: "cyan", children: "$ dev-proxy worktree create feature-auth" })] }), _jsxs(Text, { children: ["  ", _jsx(Text, { color: "cyan", children: "$ dev-proxy worktree destroy feature-auth" })] }), _jsxs(Text, { children: ["  ", _jsx(Text, { color: "cyan", children: "$ dev-proxy doctor" }), "                   ", _jsx(Text, { dimColor: true, children: "Check your setup" })] }), _jsx(Text, { children: "" }), _jsx(Text, { bold: true, children: "Documentation" }), _jsxs(Text, { children: ["  ", "https://github.com/reopt-ai/dev-proxy"] })] }));
+}
+render(_jsx(Help, {}));

package/dist/commands/init.js

@@ -0,0 +1,199 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { render, Box, Text, useInput } from "ink";
+import TextInput from "ink-text-input";
+import { existsSync, mkdirSync } from "node:fs";
+import { resolve, isAbsolute } from "node:path";
+import { platform } from "node:os";
+import { execFileSync } from "node:child_process";
+import { CONFIG_DIR, GLOBAL_CONFIG_PATH, PROJECT_CONFIG_NAME, isValidPort, isValidSubdomain, readGlobalConfig, writeGlobalConfig, writeProjectConfig, } from "../cli/config-io.js";
+import { ExitOnRender } from "../cli/output.js";
+// ── Completed Step Display ───────────────────────────────────
+function CompletedStep({ label, value }) {
+    return (_jsxs(Text, { children: ["  ", _jsx(Text, { color: "green", children: "\u2713" }), _jsx(Text, { bold: true, children: ` ${label}: ` }), _jsx(Text, { children: value })] }));
+}
+// ── Route Input ──────────────────────────────────────────────
+function RouteInput({ onAdd, onDone, }) {
+    const [value, setValue] = useState("");
+    const [error, setError] = useState("");
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: "    " }), _jsx(TextInput, { value: value, placeholder: "subdomain=port (empty to finish)", onChange: (v) => {
+                            setValue(v);
+                            setError("");
+                        }, onSubmit: (v) => {
+                            const trimmed = v.trim();
+                            if (!trimmed) {
+                                onDone();
+                                return;
+                            }
+                            const eq = trimmed.indexOf("=");
+                            if (eq === -1) {
+                                setError("Expected format: subdomain=port (e.g. api=4000)");
+                                return;
+                            }
+                            const sub = trimmed.slice(0, eq).trim();
+                            if (!isValidSubdomain(sub)) {
+                                setError(`Invalid subdomain "${sub}" — use lowercase alphanumeric and hyphens only`);
+                                return;
+                            }
+                            const portStr = trimmed.slice(eq + 1).trim();
+                            const portNum = parseInt(portStr, 10);
+                            if (!isValidPort(portNum)) {
+                                setError(`Invalid port "${portStr}" — must be 1-65535`);
+                                return;
+                            }
+                            onAdd(sub, portStr);
+                            setValue("");
+                            setError("");
+                        } })] }), error && (_jsxs(Text, { color: "red", children: ["      ", error] }))] }));
+}
+// ── Prompt ───────────────────────────────────────────────────
+function Prompt({ label, defaultValue, onSubmit, }) {
+    const [value, setValue] = useState("");
+    return (_jsxs(Box, { children: [_jsx(Text, { children: "  " }), _jsx(Text, { bold: true, children: label }), defaultValue && _jsx(Text, { dimColor: true, children: ` (${defaultValue})` }), _jsx(Text, { children: ": " }), _jsx(TextInput, { value: value, onChange: setValue, onSubmit: (v) => {
+                    const trimmed = v.trim();
+                    onSubmit(trimmed ? trimmed : (defaultValue ?? ""));
+                } })] }));
+}
+// ── Confirm Step ─────────────────────────────────────────────
+function ConfirmOverwrite({ path, onConfirm, }) {
+    useInput((input) => {
+        const key = input.toLowerCase();
+        if (key === "y")
+            onConfirm(true);
+        else if (key === "n")
+            onConfirm(false);
+    });
+    return (_jsxs(Text, { children: ["  ", _jsx(Text, { color: "yellow", children: "\u26A0" }), _jsx(Text, { children: ` ${path} exists. Overwrite? ` }), _jsx(Text, { dimColor: true, children: "[y/N]" })] }));
+}
+// ── Main Wizard ──────────────────────────────────────────────
+function InitWizard() {
+    const [step, setStep] = useState("domain");
+    const [domain, setDomain] = useState("");
+    const [httpPort, setHttpPort] = useState("");
+    const [httpsPort, setHttpsPort] = useState("");
+    const [projectPath, setProjectPath] = useState("");
+    const [routes, setRoutes] = useState([]);
+    const [wildcard, setWildcard] = useState("");
+    const [messages, setMessages] = useState([]);
+    const addMessage = (msg) => {
+        setMessages((prev) => [...prev, msg]);
+    };
+    const writeConfigs = (overwriteProject) => {
+        try {
+            mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+        catch (err) {
+            addMessage(`Failed to create ${CONFIG_DIR}: ${err.message}`);
+            setStep("done");
+            return;
+        }
+        const absPath = isAbsolute(projectPath)
+            ? projectPath
+            : resolve(process.cwd(), projectPath);
+        let globalConfig;
+        const existing = readGlobalConfig();
+        if (existsSync(GLOBAL_CONFIG_PATH)) {
+            globalConfig = {
+                domain: existing.domain ?? domain,
+                port: existing.port ?? parseInt(httpPort, 10),
+                httpsPort: existing.httpsPort ?? parseInt(httpsPort, 10),
+                projects: existing.projects ?? [],
+            };
+            if (!globalConfig.projects.includes(absPath)) {
+                globalConfig.projects.push(absPath);
+                addMessage(`Added project to ${GLOBAL_CONFIG_PATH}`);
+            }
+            else {
+                addMessage(`Project already registered`);
+            }
+        }
+        else {
+            globalConfig = {
+                domain,
+                port: parseInt(httpPort, 10),
+                httpsPort: parseInt(httpsPort, 10),
+                projects: [absPath],
+            };
+            addMessage(`Created ${GLOBAL_CONFIG_PATH}`);
+        }
+        try {
+            writeGlobalConfig(globalConfig);
+        }
+        catch (err) {
+            addMessage(`Failed to write ${GLOBAL_CONFIG_PATH}: ${err.message}`);
+        }
+        // Project config
+        const projectConfigPath = resolve(absPath, PROJECT_CONFIG_NAME);
+        const routeMap = {};
+        for (const r of routes) {
+            routeMap[r.subdomain] = `http://localhost:${r.port}`;
+        }
+        if (wildcard) {
+            routeMap["*"] = `http://localhost:${wildcard}`;
+        }
+        if (!existsSync(projectConfigPath) || overwriteProject) {
+            try {
+                writeProjectConfig(absPath, { routes: routeMap, worktrees: {} });
+                addMessage(`Created ${projectConfigPath}`);
+            }
+            catch (err) {
+                addMessage(`Failed to write ${projectConfigPath}: ${err.message}`);
+            }
+        }
+        else {
+            addMessage(`Skipped ${projectConfigPath}`);
+        }
+        setStep("done");
+    };
+    // DNS + mkcert info for done screen
+    const hasMkcert = (() => {
+        try {
+            execFileSync("which", ["mkcert"], { stdio: "ignore" });
+            return true;
+        }
+        catch {
+            // Expected: mkcert is simply not installed
+            return false;
+        }
+    })();
+    const absProjectPath = projectPath
+        ? isAbsolute(projectPath)
+            ? projectPath
+            : resolve(process.cwd(), projectPath)
+        : "";
+    const projectConfigExists = absProjectPath && existsSync(resolve(absProjectPath, PROJECT_CONFIG_NAME));
+    return (_jsxs(Box, { flexDirection: "column", paddingTop: 1, paddingBottom: 1, children: [_jsx(Text, { bold: true, children: "  dev-proxy init" }), _jsx(Text, { dimColor: true, children: "  " + "\u2500".repeat(44) }), _jsx(Text, { children: "" }), domain && step !== "domain" && _jsx(CompletedStep, { label: "Domain", value: domain }), httpPort && step !== "httpPort" && (_jsx(CompletedStep, { label: "HTTP", value: `:${httpPort}` })), httpsPort && step !== "httpsPort" && (_jsx(CompletedStep, { label: "HTTPS", value: `:${httpsPort}` })), projectPath && step !== "projectPath" && (_jsx(CompletedStep, { label: "Project", value: absProjectPath })), routes.length > 0 && step !== "routes" && (_jsx(Box, { flexDirection: "column", children: routes.map((r) => (_jsx(CompletedStep, { label: r.subdomain, value: `:${r.port}` }, r.subdomain))) })), wildcard && step !== "wildcard" && (_jsx(CompletedStep, { label: "*", value: `:${wildcard}` })), step === "domain" && (_jsx(Prompt, { label: "Domain", defaultValue: "localhost", onSubmit: (v) => {
+                    setDomain(v);
+                    setStep("httpPort");
+                } })), step === "httpPort" && (_jsx(Prompt, { label: "HTTP port", defaultValue: "3000", onSubmit: (v) => {
+                    const num = parseInt(v, 10);
+                    if (!isValidPort(num))
+                        return;
+                    setHttpPort(v);
+                    setStep("httpsPort");
+                } })), step === "httpsPort" && (_jsx(Prompt, { label: "HTTPS port", defaultValue: "3443", onSubmit: (v) => {
+                    const num = parseInt(v, 10);
+                    if (!isValidPort(num))
+                        return;
+                    setHttpsPort(v);
+                    setStep("projectPath");
+                } })), step === "projectPath" && (_jsx(Prompt, { label: "Project path", defaultValue: process.cwd(), onSubmit: (v) => {
+                    setProjectPath(v);
+                    setStep("routes");
+                } })), step === "routes" && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "  Add routes (subdomain=port, empty to finish):" }), routes.map((r) => (_jsxs(Text, { children: ["    ", _jsx(Text, { color: "cyan", children: r.subdomain }), _jsx(Text, { dimColor: true, children: " \u279C " }), _jsx(Text, { children: `:${r.port}` })] }, r.subdomain))), _jsx(RouteInput, { onAdd: (sub, port) => {
+                            setRoutes((prev) => [...prev, { subdomain: sub, port }]);
+                        }, onDone: () => {
+                            setStep("wildcard");
+                        } })] })), step === "wildcard" && (_jsx(Prompt, { label: "Default port for unmatched subdomains (empty to skip)", onSubmit: (v) => {
+                    setWildcard(v);
+                    if (projectConfigExists) {
+                        setStep("confirm");
+                    }
+                    else {
+                        writeConfigs(false);
+                    }
+                } })), step === "confirm" && (_jsx(ConfirmOverwrite, { path: resolve(absProjectPath, PROJECT_CONFIG_NAME), onConfirm: (yes) => {
+                    writeConfigs(yes);
+                } })), step === "done" && (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: "" }), messages.map((msg, i) => (_jsxs(Text, { children: ["  ", _jsx(Text, { color: "green", children: "\u2713" }), _jsx(Text, { children: ` ${msg}` })] }, i))), domain !== "localhost" && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "  DNS Setup" }), _jsx(Text, { dimColor: true, children: "  " + "\u2500".repeat(44) }), platform() === "darwin" ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { dimColor: true, children: "  Recommended: dnsmasq (automatic wildcard)" }), _jsx(Text, { color: "cyan", children: `    brew install dnsmasq` }), _jsx(Text, { color: "cyan", children: `    echo "address=/${domain}/127.0.0.1" >> $(brew --prefix)/etc/dnsmasq.conf` }), _jsx(Text, { color: "cyan", children: `    sudo brew services start dnsmasq` }), _jsx(Text, { color: "cyan", children: `    sudo mkdir -p /etc/resolver` }), _jsx(Text, { color: "cyan", children: `    echo "nameserver 127.0.0.1" | sudo tee /etc/resolver/${domain}` })] })) : (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { dimColor: true, children: "  Add to /etc/hosts:" }), routes.map((r) => (_jsx(Text, { color: "cyan", children: `    127.0.0.1 ${r.subdomain}.${domain}` }, r.subdomain)))] }))] })), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { bold: true, children: "  TLS" }), _jsx(Text, { dimColor: true, children: "  " + "\u2500".repeat(44) }), hasMkcert ? (_jsxs(Text, { children: ["  ", _jsx(Text, { color: "green", children: "\u2713" }), _jsx(Text, { children: " mkcert detected \u2014 TLS certs auto-generated on first run" })] })) : (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: ["  ", _jsx(Text, { color: "yellow", children: "\u26A0" }), _jsx(Text, { children: " mkcert not found \u2014 HTTPS will be disabled" })] }), _jsx(Text, { dimColor: true, children: "    Install: brew install mkcert && mkcert -install" })] }))] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { dimColor: true, children: "  " + "\u2500".repeat(44) }), _jsxs(Text, { children: ["  ", _jsx(Text, { bold: true, children: "Done!" }), _jsx(Text, { children: " Run " }), _jsx(Text, { color: "cyan", children: "dev-proxy" }), _jsx(Text, { children: " to start." })] })] }), _jsx(ExitOnRender, {})] }))] }));
+}
+render(_jsx(InitWizard, {}));

package/dist/commands/project.js

@@ -0,0 +1,69 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { Box, Text, render } from "ink";
+import { PROJECT_CONFIG_NAME, readGlobalConfig, writeGlobalConfig, writeProjectConfig, readProjectConfig, } from "../cli/config-io.js";
+import { Header, Row, SuccessMessage, ErrorMessage, ExitOnRender, } from "../cli/output.js";
+// ── List projects ────────────────────────────────────────────
+function ProjectList() {
+    const cfg = readGlobalConfig();
+    const projects = cfg.projects ?? [];
+    if (projects.length === 0) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ExitOnRender, {}), _jsx(Header, { text: "Registered Projects" }), _jsx(Text, { dimColor: true, children: "    (none)" })] }));
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ExitOnRender, {}), _jsx(Header, { text: "Registered Projects" }), projects.map((p) => {
+                const pc = readProjectConfig(p);
+                const routeCount = Object.keys(pc.routes ?? {}).length;
+                const worktreeCount = Object.keys(pc.worktrees ?? {}).length;
+                return (_jsx(Row, { label: p, value: `${routeCount} route(s), ${worktreeCount} worktree(s)`, pad: 40 }, p));
+            })] }));
+}
+// ── Add project ──────────────────────────────────────────────
+function ProjectAdd({ projectPath }) {
+    const absPath = resolve(projectPath);
+    const cfg = readGlobalConfig();
+    const projects = cfg.projects ?? [];
+    if (projects.includes(absPath)) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ExitOnRender, {}), _jsx(ErrorMessage, { message: `Project already registered: ${absPath}` })] }));
+    }
+    // Create .dev-proxy.json template if it doesn't exist
+    const projectConfigPath = resolve(absPath, PROJECT_CONFIG_NAME);
+    if (!existsSync(projectConfigPath)) {
+        writeProjectConfig(absPath, { routes: {}, worktrees: {} });
+    }
+    cfg.projects = [...projects, absPath];
+    writeGlobalConfig(cfg);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ExitOnRender, {}), _jsx(SuccessMessage, { message: `Added project: ${absPath}` })] }));
+}
+// ── Remove project ───────────────────────────────────────────
+function ProjectRemove({ projectPath }) {
+    const absPath = resolve(projectPath);
+    const cfg = readGlobalConfig();
+    const projects = cfg.projects ?? [];
+    if (!projects.includes(absPath)) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ExitOnRender, {}), _jsx(ErrorMessage, { message: `Project not found: ${absPath}`, hint: "Run 'dev-proxy project list' to see registered projects" })] }));
+    }
+    cfg.projects = projects.filter((p) => p !== absPath);
+    writeGlobalConfig(cfg);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ExitOnRender, {}), _jsx(SuccessMessage, { message: `Removed project: ${absPath}` })] }));
+}
+// ── Entry point ──────────────────────────────────────────────
+const args = process.argv.slice(3);
+const subcommand = args[0];
+if (subcommand === "add") {
+    const path = args[1] ?? process.cwd();
+    render(_jsx(ProjectAdd, { projectPath: path }));
+}
+else if (subcommand === "remove") {
+    const path = args[1];
+    if (!path) {
+        render(_jsx(ErrorMessage, { message: "Usage: dev-proxy project remove <path>" }));
+    }
+    else {
+        render(_jsx(ProjectRemove, { projectPath: path }));
+    }
+}
+else {
+    // "list" or no subcommand → default to list
+    render(_jsx(ProjectList, {}));
+}

package/dist/commands/status.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, render } from "ink";
+import { config } from "../proxy/config.js";
+import { Header, Section, Row, RouteRow, ExitOnRender } from "../cli/output.js";
+function formatTarget(target) {
+    try {
+        const url = new URL(target);
+        if (url.protocol === "http:" && url.hostname === "localhost") {
+            return `localhost:${url.port || "80"}`;
+        }
+    }
+    catch {
+        // not a URL, return as-is
+    }
+    return target;
+}
+function Status() {
+    const allRoutes = [];
+    const allWorktrees = [];
+    for (const project of config.projects) {
+        for (const [sub, target] of Object.entries(project.routes)) {
+            allRoutes.push({ sub, target: formatTarget(target) });
+        }
+        for (const [name, wt] of Object.entries(project.worktrees)) {
+            allWorktrees.push({ name, entry: wt });
+        }
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ExitOnRender, {}), _jsx(Header, { text: "dev-proxy status" }), _jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Row, { label: "Domain", value: config.domain }), _jsx(Row, { label: "HTTP", value: `:${String(config.port)}` }), _jsx(Row, { label: "HTTPS", value: `:${String(config.httpsPort)}` })] }), _jsx(Section, { title: `Routes (${String(allRoutes.length)})`, children: allRoutes.map((r) => (_jsx(RouteRow, { sub: r.sub, target: r.target }, `${r.sub}-${r.target}`))) }), _jsx(Section, { title: `Projects (${String(config.projects.length)})`, children: config.projects.map((p) => (_jsx(Text, { children: `    ${p.path}` }, p.path))) }), _jsx(Section, { title: `Worktrees (${String(allWorktrees.length)})`, children: allWorktrees.map((w) => "ports" in w.entry ? (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: `    ${w.name}` }), Object.entries(w.entry.ports).map(([svc, p]) => (_jsx(RouteRow, { sub: `  ${svc}`, target: `:${String(p)}` }, svc)))] }, w.name)) : (_jsx(RouteRow, { sub: w.name, target: `:${String(w.entry.port)}` }, w.name))) })] }));
+}
+render(_jsx(Status, {}));

package/dist/commands/version.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createRequire } from "node:module";
+import { Text, render } from "ink";
+import { ExitOnRender } from "../cli/output.js";
+const require = createRequire(import.meta.url);
+const pkg = require("../../package.json");
+function Version() {
+    return (_jsxs(Text, { children: [_jsx(ExitOnRender, {}), "dev-proxy v", pkg.version] }));
+}
+render(_jsx(Version, {}));