dx-devkit 0.0.0-stage → 1.1.0

package/node_modules/@dx/web/dist/dev.js

@@ -0,0 +1,645 @@
+import { spawn } from "node:child_process";
+import { detectStack, ErrorTracker, getProjectPort, isPortOpen, killProcess, mainService, recordRun, serviceName, splitRunnerLine, startOrder, } from "@dx/core";
+const MAX_LINES = 2000;
+// eslint-disable-next-line no-control-regex
+const ANSI = /\x1b\[[0-9;?]*[A-Za-z]|\x1b\][^\x07]*\x07/g;
+const URL_IN_TEXT = /(https?:\/\/(?:localhost|127\.0\.0\.1|\[::1\]):(\d{2,5}))/;
+const procs = new Map();
+const stacks = new Map();
+let lineCounter = 0;
+let localPort;
+// ------------------------------------------------------------ local domains
+/** Tells the dev servers the local domains proxy's port, or undefined when it isn't running. */
+export function setLocalDomainsPort(port) {
+    localPort = port;
+}
+function localUrlOf(host) {
+    if (localPort === undefined)
+        return undefined;
+    return `http://${host}${localPort === 80 ? "" : `:${localPort}`}`;
+}
+/** Every *.localhost name dx serves, and the address it points at. */
+export function localRoutes() {
+    const routes = new Map();
+    for (const p of procs.values()) {
+        if (p.stackKey || !p.child || !p.url)
+            continue;
+        routes.set(`${serviceName(p.project)}.localhost`, { url: p.url, dir: p.dir });
+    }
+    for (const run of stacks.values()) {
+        if (run.phase === "stopped")
+            continue;
+        const base = serviceName(run.name);
+        const main = mainService(run.stack)?.name;
+        for (const svc of serviceInfos(run)) {
+            if (!svc.url || svc.status === "stopped" || svc.status === "failed")
+                continue;
+            routes.set(`${svc.service}.${base}.localhost`, { url: svc.url, dir: run.dir, service: svc.service });
+            if (svc.service === main)
+                routes.set(`${base}.localhost`, { url: svc.url, dir: run.dir, service: svc.service });
+        }
+    }
+    return routes;
+}
+// ------------------------------------------------------------ reading
+export function listDevServers() {
+    const singles = [...procs.values()].filter((p) => !p.stackKey).map(info);
+    const stackInfos = [...stacks.values()].map(stackInfo);
+    return [...singles, ...stackInfos].sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+}
+export function devServer(dir) {
+    const run = stacks.get(key(dir));
+    if (run)
+        return stackInfo(run);
+    const p = procs.get(key(dir));
+    return p && info(p);
+}
+/** The process (or stack service) listening on a port, for matching a request to its server. */
+export function serverForPort(port) {
+    for (const p of procs.values()) {
+        if (!p.child && !p.docker)
+            continue;
+        const urls = p.split ? [...p.subUrls.entries()] : p.url ? [[p.service ?? "", p.url]] : [];
+        for (const [service, url] of urls) {
+            if (portOf(url) !== port)
+                continue;
+            const run = p.stackKey ? stacks.get(p.stackKey) : undefined;
+            return { dir: run?.dir ?? p.dir, service: service || undefined, project: run?.name ?? p.project };
+        }
+    }
+    return undefined;
+}
+export function devLogs(dir, after = 0, service) {
+    const list = procsFor(dir);
+    if (!list.length)
+        return { lines: [] };
+    const lines = list
+        .flatMap((p) => p.lines.filter((l) => l.n > after && (!service || (l.service ?? p.service) === service)).map((l) => (p.service && !l.service ? { ...l, service: p.service } : l)))
+        .sort((a, b) => a.n - b.n);
+    return { lines, server: devServer(dir) };
+}
+/** Errors found in one server's output (a stack's services included), or in every server's when `dir` is empty. */
+export function devErrors(dir, options = {}) {
+    const tops = dir ? [devServer(dir)].filter((x) => !!x) : listDevServers();
+    return tops.map((top) => ({
+        project: top.project,
+        dir: top.dir,
+        errors: errorsOf(procsFor(top.dir), options),
+    }));
+}
+function errorsOf(list, options) {
+    const out = [];
+    for (const p of list) {
+        for (const [svc, tracker] of p.trackers) {
+            tracker.flush();
+            const service = svc || p.service;
+            if (options.service && service !== options.service)
+                continue;
+            for (const e of tracker.errors(options))
+                out.push(service ? { ...e, service } : e);
+        }
+    }
+    return out.sort((a, b) => b.lastLine - a.lastLine);
+}
+// ------------------------------------------------------------ starting
+/** Starts a project: its stack when it has one, else its dev command. */
+export function startDevServer(project, startedBy = "dashboard") {
+    const stack = detectStack(project);
+    if (stack)
+        return startStack(project, stack, startedBy);
+    if (!project.devCommand)
+        throw new Error(`${project.name} has no dev command. Add one in .devrc.json: { "dev": "..." }`);
+    const existing = procs.get(key(project.dir));
+    if (existing && (existing.status === "starting" || existing.status === "ready"))
+        return info(existing);
+    const p = spawnProc({
+        key: key(project.dir),
+        project: project.name,
+        dir: project.dir,
+        command: project.devCommand,
+        url: project.url,
+        port: getProjectPort(project),
+        startedBy,
+    });
+    return info(p);
+}
+function startStack(project, stack, startedBy) {
+    const k = key(project.dir);
+    const existing = stacks.get(k);
+    if (existing && (existing.phase === "starting" || existing.phase === "running"))
+        return stackInfo(existing);
+    for (const p of [...procs.values()])
+        if (p.stackKey === k && !p.child)
+            procs.delete(p.key);
+    const run = { key: k, dir: project.dir, name: project.name, stack, startedBy, phase: "starting", startedAt: new Date().toISOString() };
+    stacks.set(k, run);
+    void runStack(run).catch((err) => {
+        run.note = `Couldn't start the stack: ${err.message}`;
+        run.phase = "running";
+    });
+    return stackInfo(run);
+}
+async function runStack(run) {
+    const { stack } = run;
+    const crashed = new Set();
+    const skipped = [];
+    const docker = stack.services.filter((s) => s.kind === "docker");
+    const waves = stack.runner ? [...(docker.length ? [docker] : []), "runner"] : startOrder(stack);
+    const unavailable = (d) => crashed.has(d) || skipped.some((s) => s.startsWith(`${d} `));
+    for (const wave of waves) {
+        if (run.phase !== "starting")
+            return;
+        const started = [];
+        for (const svc of wave === "runner" ? [] : wave) {
+            const blockedBy = svc.dependsOn.filter(unavailable);
+            if (blockedBy.length) {
+                skipped.push(`${svc.name} (needs ${blockedBy.join(", ")})`);
+                continue;
+            }
+            started.push(startService(run, svc));
+        }
+        if (wave === "runner" && stack.runner) {
+            // Every app service through the project's own runner, after the databases.
+            started.push(spawnProc({
+                key: `${run.key}#*`,
+                project: run.name,
+                dir: stack.dir,
+                command: stack.runner.command,
+                startedBy: run.startedBy,
+                stackKey: run.key,
+                split: stack.services.filter((s) => s.kind === "process"),
+                env: urlEnv(run),
+            }));
+        }
+        await Promise.all(started.map((p) => waitSettled(p, 120_000)));
+        for (const p of started)
+            if (p.status === "failed" && p.service)
+                crashed.add(p.service);
+    }
+    if (run.phase !== "starting")
+        return;
+    run.phase = "running";
+    const notes = [];
+    if (crashed.size)
+        notes.push(`Failed to start: ${[...crashed].join(", ")}.`);
+    if (skipped.length)
+        notes.push(`Not started: ${skipped.join("; ")}.`);
+    run.note = notes.length ? notes.join(" ") : undefined;
+    recordRun("go", crashed.size === 0, `${run.name} stack started (${stack.services.length} services)`, "web", { project: run.name });
+}
+function startService(run, svc) {
+    const env = { ...(svc.env ?? {}), ...urlEnv(run) };
+    delete env.DX_LABEL;
+    return spawnProc({
+        key: `${run.key}#${svc.name}`,
+        project: run.name,
+        dir: svc.dir,
+        command: svc.command,
+        url: svc.kind === "docker" ? undefined : svc.url,
+        port: svc.kind === "docker" ? undefined : portOf(svc.url),
+        startedBy: run.startedBy,
+        stackKey: run.key,
+        service: svc.name,
+        role: svc.role,
+        env,
+        docker: svc.kind === "docker" ? { compose: svc.composeService ?? svc.name, hostPort: svc.hostPort } : undefined,
+    });
+}
+/**
+ * Where the stack's other services are: DX_API_URL is the direct address (for server code, since
+ * not every system resolves *.localhost), DX_API_PUBLIC_URL the local domain (for the browser).
+ */
+function urlEnv(run) {
+    const env = {};
+    const base = serviceName(run.name);
+    for (const svc of serviceInfos(run)) {
+        if (!svc.url || svc.status !== "ready" || !svc.service)
+            continue;
+        const name = svc.service.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+        env[`DX_${name}_URL`] = svc.url;
+        const local = svc.kind === "process" ? localUrlOf(`${svc.service}.${base}.localhost`) : undefined;
+        if (local)
+            env[`DX_${name}_PUBLIC_URL`] = local;
+    }
+    return env;
+}
+function spawnProc(spec) {
+    const p = {
+        ...spec,
+        status: "starting",
+        startedAt: new Date().toISOString(),
+        lastLine: 0,
+        lines: [],
+        trackers: new Map([["", new ErrorTracker()]]),
+        lastOutputAt: Date.now(),
+        subUrls: new Map(),
+    };
+    procs.set(spec.key, p);
+    push(p, "dx", `$ ${spec.command}`);
+    const child = spawn(spec.command, {
+        cwd: spec.dir,
+        shell: true,
+        windowsHide: true,
+        // Its own process group on macOS/Linux, so Stop can end the whole tree (npm → node → vite).
+        detached: process.platform !== "win32",
+        env: { ...process.env, FORCE_COLOR: "0", BROWSER: "none", ...spec.env },
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    p.child = child;
+    p.pid = child.pid;
+    child.stdout?.on("data", (d) => pushChunk(p, "out", d));
+    child.stderr?.on("data", (d) => pushChunk(p, "err", d));
+    child.once("error", (err) => {
+        p.status = "failed";
+        push(p, "dx", `Couldn't start: ${err.message}`);
+    });
+    child.once("exit", (code, signal) => {
+        p.exitCode = code;
+        p.child = undefined;
+        const ms = Date.now() - Date.parse(p.startedAt);
+        if (p.docker && !p.stopping) {
+            // `docker compose up -d` finishes once the container runs; the service is ready when its port opens.
+            if (code !== 0) {
+                p.status = "failed";
+                push(p, "dx", `docker compose exited with ${code ?? signal}. Is Docker running?`);
+                return;
+            }
+            void (async () => {
+                if (p.docker?.hostPort) {
+                    const deadline = Date.now() + 60_000;
+                    while (Date.now() < deadline && !(await isPortOpen(p.docker.hostPort)))
+                        await new Promise((r) => setTimeout(r, 500));
+                }
+                if (p.status === "starting") {
+                    p.status = "ready";
+                    p.url = p.docker?.hostPort ? `http://localhost:${p.docker.hostPort}` : undefined;
+                    push(p, "dx", p.docker?.hostPort ? `Container ready on port ${p.docker.hostPort}.` : "Container started.");
+                }
+            })();
+            return;
+        }
+        p.stoppedAt = new Date().toISOString();
+        const label = p.service ? `${p.project}/${p.service}` : p.project;
+        if (p.stopping) {
+            p.status = "stopped";
+            push(p, "dx", "Stopped.");
+            if (!p.stackKey)
+                recordRun("go", true, `${label} dev stopped from the dashboard`, "web", { project: p.project, ms });
+        }
+        else {
+            p.status = code === 0 ? "stopped" : "failed";
+            push(p, "dx", `Exited with ${code ?? signal}.`);
+            recordRun("go", code === 0, `${label} dev exited with ${code ?? signal}`, "web", { project: p.project, ms });
+        }
+    });
+    if (!p.docker) {
+        void (async () => {
+            // If something else already holds the usual port, the dev server will pick another one and say so.
+            if (p.port !== undefined && (await isPortOpen(p.port))) {
+                push(p, "dx", `Port ${p.port} is already in use by another program; waiting for the dev server to say where it runs.`);
+                p.port = undefined;
+                p.url = undefined;
+            }
+            await watchReady(p);
+        })();
+    }
+    return p;
+}
+/**
+ * Marks a process ready once its port opens. One that never says where it listens (a worker, a
+ * watcher) counts as ready when it's still running and its output has gone quiet.
+ */
+async function watchReady(p) {
+    const deadline = Date.now() + 180_000;
+    while (Date.now() < deadline && p.status === "starting" && p.child) {
+        if (p.port !== undefined && (await isPortOpen(p.port))) {
+            if (p.status === "starting") {
+                p.status = "ready";
+                push(p, "dx", `Ready at ${p.url}`);
+                if (!p.stackKey)
+                    recordRun("go", true, `${p.project} started from the dashboard`, "web", { project: p.project });
+            }
+            return;
+        }
+        const age = Date.now() - Date.parse(p.startedAt);
+        const quiet = Date.now() - p.lastOutputAt;
+        if (p.port === undefined && age > 5000 && quiet > 2500) {
+            p.status = "ready";
+            push(p, "dx", p.split ? "Running." : "Running (it didn't say where it listens).");
+            return;
+        }
+        await new Promise((r) => setTimeout(r, 500));
+    }
+}
+/** Waits until a process is ready, failed or gone. */
+async function waitSettled(p, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (p.status === "starting" && Date.now() < deadline)
+        await new Promise((r) => setTimeout(r, 200));
+}
+// ------------------------------------------------------------ stopping
+export async function stopDevServer(dir) {
+    const run = stacks.get(key(dir));
+    if (run) {
+        await stopStack(run);
+        return stackInfo(run);
+    }
+    const p = procs.get(key(dir));
+    if (p)
+        await stopProc(p);
+    return p && info(p);
+}
+async function stopProc(p) {
+    if (!p.child?.pid)
+        return;
+    p.stopping = true;
+    push(p, "dx", "Stopping…");
+    if (process.platform === "win32") {
+        await killProcess(p.child.pid);
+    }
+    else {
+        try {
+            process.kill(-p.child.pid, "SIGTERM");
+        }
+        catch {
+            p.child.kill("SIGTERM");
+        }
+    }
+}
+async function stopStack(run) {
+    if (run.phase === "stopped")
+        return;
+    run.phase = "stopping";
+    const list = procsFor(run.dir);
+    await Promise.all(list.filter((p) => !p.docker).map(stopProc));
+    // Containers keep running until asked: stop the ones this stack started.
+    const docker = list.filter((p) => p.docker && p.status !== "failed");
+    if (docker.length) {
+        for (const p of docker)
+            push(p, "dx", "Stopping the container…");
+        const code = await new Promise((resolve) => {
+            const child = spawn(`docker compose stop ${docker.map((p) => p.docker.compose).join(" ")}`, { cwd: run.stack.composeFile ? dirOf(run.stack.composeFile) : run.dir, shell: true, windowsHide: true, stdio: "ignore" });
+            child.once("error", () => resolve(1));
+            child.once("exit", (c) => resolve(c ?? 1));
+        });
+        for (const p of docker) {
+            p.status = "stopped";
+            p.stoppedAt = new Date().toISOString();
+            push(p, "dx", code === 0 ? "Container stopped." : "docker compose stop failed; the container may still be running.");
+        }
+    }
+    const exited = list.filter((p) => p.child).map((p) => new Promise((resolve) => p.child?.once("exit", () => resolve())));
+    await Promise.race([Promise.all(exited), new Promise((r) => setTimeout(r, 10_000))]);
+    run.phase = "stopped";
+    run.stoppedAt = new Date().toISOString();
+    recordRun("go", true, `${run.name} stack stopped`, "web", { project: run.name, ms: Date.now() - Date.parse(run.startedAt) });
+}
+/** Stops every dev server; called when the dashboard shuts down. */
+export async function stopAllDevServers() {
+    await Promise.all([...stacks.values()].map(stopStack));
+    await Promise.all([...procs.values()].filter((p) => p.child && !p.stackKey).map(stopProc));
+}
+/** Stops the server (or stack), waits for it to exit, and starts it again. */
+export async function restartDevServer(project, startedBy = "dashboard") {
+    const k = key(project.dir);
+    const run = stacks.get(k);
+    const by = run?.startedBy ?? procs.get(k)?.startedBy ?? startedBy;
+    if (run) {
+        await stopStack(run);
+        clearDevServer(project.dir);
+    }
+    else {
+        const p = procs.get(k);
+        if (p?.child) {
+            const exited = new Promise((resolve) => p.child?.once("exit", () => resolve()));
+            await stopProc(p);
+            await Promise.race([exited, new Promise((r) => setTimeout(r, 10_000))]);
+        }
+        procs.delete(k);
+    }
+    return startDevServer(project, by);
+}
+/** Forgets a stopped server or stack, so its card and output go away. */
+export function clearDevServer(dir) {
+    const k = key(dir);
+    const run = stacks.get(k);
+    if (run) {
+        if (run.phase !== "stopped")
+            return;
+        for (const p of [...procs.values()])
+            if (p.stackKey === k)
+                procs.delete(p.key);
+        stacks.delete(k);
+        return;
+    }
+    const p = procs.get(k);
+    if (p && !p.child)
+        procs.delete(k);
+}
+/** True while any dev server or stack is running. */
+export function anyDevServerRunning() {
+    return [...procs.values()].some((p) => p.child) || [...stacks.values()].some((r) => r.phase !== "stopped");
+}
+/**
+ * Waits for a dev server (or a stack's services) to settle, then says what they printed.
+ * `until: "ready"` waits for starting to finish; `until: "quiet"` waits for output to begin (a
+ * rebuild after a file change), then for it to stop for `quietMs`.
+ */
+export async function waitForDevServer(dir, options = {}) {
+    const quietMs = options.quietMs ?? 1000;
+    const settleMs = options.settleMs ?? 4000;
+    const deadline = Date.now() + (options.timeoutMs ?? 60_000);
+    const sleep = () => new Promise((r) => setTimeout(r, 100));
+    const last = () => Math.max(0, ...procsFor(dir).map((p) => p.lastLine));
+    const after = options.after ?? last();
+    const lastOutput = () => Math.max(0, ...procsFor(dir).map((p) => p.lastOutputAt));
+    const alive = () => procsFor(dir).some((p) => p.child);
+    const run = stacks.get(key(dir));
+    let timedOut = false;
+    if (procsFor(dir).length || run) {
+        const begun = Date.now();
+        if (options.until === "ready") {
+            while ((run?.phase === "starting" || procsFor(dir).some((p) => p.status === "starting")) && Date.now() < deadline)
+                await sleep();
+        }
+        else {
+            while (last() <= after && alive() && Date.now() - begun < settleMs && Date.now() < deadline)
+                await sleep();
+        }
+        while (alive() && last() > after && Date.now() - lastOutput() < quietMs && Date.now() < deadline)
+            await sleep();
+        timedOut = Date.now() >= deadline;
+    }
+    const list = procsFor(dir);
+    for (const p of list)
+        clearTimeout(p.flushTimer);
+    const lines = devLogs(dir, after).lines.slice(-200);
+    return {
+        server: devServer(dir),
+        lines,
+        newErrors: errorsOf(list, { after }),
+        errors: errorsOf(list, {}),
+        sawOutput: lines.length > 0,
+        timedOut,
+    };
+}
+// ------------------------------------------------------------ output
+const partial = new WeakMap();
+function pushChunk(p, stream, chunk) {
+    const carry = partial.get(p) ?? {};
+    const text = (carry[stream] ?? "") + chunk.toString("utf8");
+    const parts = text.split(/\r?\n/);
+    carry[stream] = parts.pop() ?? "";
+    partial.set(p, carry);
+    for (const line of parts)
+        push(p, stream, line);
+}
+function push(p, stream, raw) {
+    let text = raw.replace(ANSI, "").replace(/\r/g, "");
+    let service;
+    if (p.split && stream !== "dx") {
+        const split = splitRunnerLine(text, p.split);
+        service = split.service;
+        text = split.text;
+    }
+    p.lastLine = ++lineCounter;
+    const line = service ? { n: p.lastLine, stream, text, service } : { n: p.lastLine, stream, text };
+    p.lines.push(line);
+    if (p.lines.length > MAX_LINES)
+        p.lines.splice(0, p.lines.length - MAX_LINES);
+    p.lastOutputAt = Date.now();
+    let tracker = p.trackers.get(service ?? "");
+    if (!tracker)
+        p.trackers.set(service ?? "", (tracker = new ErrorTracker()));
+    tracker.push(line);
+    // An error's last line is only known once the output pauses.
+    clearTimeout(p.flushTimer);
+    p.flushTimer = setTimeout(() => {
+        for (const t of p.trackers.values())
+            t.flush();
+    }, 300);
+    p.flushTimer.unref?.();
+    // The URL a dev server prints wins over the guess: it may have moved to another port.
+    if (stream === "dx")
+        return;
+    const m = URL_IN_TEXT.exec(text);
+    if (!m)
+        return;
+    // "Connecting to the API at http://localhost:4000" names another server, not this one's address.
+    if (portInUseByOther(p, Number(m[2])))
+        return;
+    const url = m[1].replace("[::1]", "localhost").replace("127.0.0.1", "localhost");
+    if (p.split) {
+        if (service && !p.subUrls.has(service))
+            p.subUrls.set(service, url);
+        return;
+    }
+    if ((p.status === "starting" && Number(m[2]) !== p.port) || (!p.url && p.child)) {
+        p.url = url;
+        p.port = Number(m[2]);
+        void watchReady(p);
+    }
+}
+// ------------------------------------------------------------ info
+function info(p) {
+    const { project, dir, command, url, pid, status, startedBy, startedAt, stoppedAt, exitCode, lastLine, service, role } = p;
+    const errorCount = errorsOf([p], {}).length;
+    const out = { project, dir, command, url, pid, status, startedBy, errorCount, startedAt, stoppedAt, exitCode, lastLine, service, role };
+    if (!p.stackKey && url && p.child)
+        out.localUrl = localUrlOf(`${serviceName(project)}.localhost`);
+    return out;
+}
+/** A stack's services as the page and agents see them, runner services included. */
+function serviceInfos(run) {
+    const base = serviceName(run.name);
+    const list = procsFor(run.dir);
+    const runner = list.find((p) => p.split);
+    return run.stack.services.map((svc) => {
+        const p = list.find((x) => x.service === svc.name);
+        let i;
+        if (p) {
+            i = info(p);
+        }
+        else if (runner && svc.kind === "process") {
+            const r = info(runner);
+            i = { ...r, command: svc.command, url: runner.subUrls.get(svc.name), errorCount: errorsOf([runner], { service: svc.name }).length, lastLine: r.lastLine };
+        }
+        else {
+            i = { project: run.name, dir: svc.dir, command: svc.command, status: run.phase === "starting" ? "starting" : "stopped", startedBy: run.startedBy, errorCount: 0, startedAt: run.startedAt, lastLine: 0 };
+        }
+        const alive = i.status === "starting" || i.status === "ready";
+        return {
+            ...i,
+            project: run.name,
+            service: svc.name,
+            role: svc.role,
+            kind: svc.kind,
+            localUrl: svc.kind === "process" && i.url && alive ? localUrlOf(`${svc.name}.${base}.localhost`) : undefined,
+        };
+    });
+}
+function stackInfo(run) {
+    const services = serviceInfos(run);
+    const main = mainService(run.stack);
+    const mainInfo = services.find((s) => s.service === main?.name);
+    let status;
+    if (run.phase === "starting")
+        status = "starting";
+    else if (run.phase === "stopped" || run.phase === "stopping")
+        status = "stopped";
+    else if (services.some((s) => s.status === "failed"))
+        status = "failed";
+    else if (services.some((s) => s.status === "starting"))
+        status = "starting";
+    // A watcher that finished (exit 0) doesn't make the stack stopped while the others run.
+    else
+        status = services.some((s) => s.status === "ready") ? "ready" : "stopped";
+    const base = serviceName(run.name);
+    return {
+        project: run.name,
+        dir: run.dir,
+        command: run.stack.runner?.command ?? `${services.length} services`,
+        url: mainInfo?.url,
+        localUrl: mainInfo?.url && status !== "stopped" ? localUrlOf(`${base}.localhost`) : undefined,
+        status,
+        startedBy: run.startedBy,
+        errorCount: services.reduce((n, s) => n + s.errorCount, 0),
+        startedAt: run.startedAt,
+        stoppedAt: run.stoppedAt,
+        lastLine: Math.max(0, ...procsFor(run.dir).map((p) => p.lastLine)),
+        services: services.map(({ kind: _kind, ...s }) => s),
+        stackSource: run.stack.source,
+        note: run.note,
+    };
+}
+function portInUseByOther(p, port) {
+    for (const other of procs.values()) {
+        if (other === p || (!other.child && !other.docker))
+            continue;
+        if (other.port === port || portOf(other.url) === port || [...other.subUrls.values()].some((u) => portOf(u) === port))
+            return true;
+    }
+    return false;
+}
+function procsFor(dir) {
+    const k = key(dir);
+    return [...procs.values()].filter((p) => p.key === k || p.stackKey === k);
+}
+function portOf(url) {
+    if (!url)
+        return undefined;
+    try {
+        const u = new URL(url);
+        return Number(u.port || (u.protocol === "https:" ? 443 : 80));
+    }
+    catch {
+        return undefined;
+    }
+}
+function dirOf(file) {
+    return file.replace(/[\\/][^\\/]+$/, "");
+}
+function key(dir) {
+    return process.platform === "win32" ? dir.toLowerCase() : dir;
+}
+//# sourceMappingURL=dev.js.map