@tdk-landscape/tdk-cli-core 1.3.157 → 1.3.159

package/cli/dist/commands/doctor.js

@@ -1017,6 +1017,7 @@ export const doctorCommand = new Command("doctor")
     .option("--strict", "Fail warnings such as a WSL project under /mnt/c")
     .option("--fix", "Repair this project's unused Docker networks and leftover doctor probes", false)
     .option("--dry-run", "With --fix: list the repairs without changing anything", false)
+    .option("--scope <scope>", "With --fix: project (default) or machine, which also removes unused networks of other TDK projects", "project")
     .option("-y, --yes", "With --fix: apply every repair without asking", false)
     .option("--ping-timeout <ms>", "Per-service ping timeout in milliseconds", String(DEFAULT_PING_TIMEOUT_MS))
     .action(async (options) => {
@@ -1032,8 +1033,14 @@ export const doctorCommand = new Command("doctor")
         process.exit(2);
         return;
     }
-    if ((options.dryRun || options.yes) && !options.fix) {
-        const message = `${options.dryRun ? "--dry-run" : "--yes"} only applies with --fix`;
+    const scopeInvalid = !["project", "machine"].includes(options.scope);
+    const scopeWithoutFix = options.scope !== "project" && !options.fix;
+    if (scopeInvalid || scopeWithoutFix || ((options.dryRun || options.yes) && !options.fix)) {
+        const message = scopeInvalid
+            ? `--scope must be project or machine, got "${options.scope}"`
+            : scopeWithoutFix
+                ? "--scope only applies with --fix"
+                : `${options.dryRun ? "--dry-run" : "--yes"} only applies with --fix`;
         if (options.json)
             console.log(JSON.stringify(createDoctorReport([], false, [{ code: "USAGE", message }])));
         console.error(message);
@@ -1100,9 +1107,10 @@ export const doctorCommand = new Command("doctor")
                 }
             }
             const tiltPids = projectRoot ? projectTiltPids(projectRoot) : [];
-            const planned = await planDoctorFixes(projectName, undefined, tiltPids.length > 0
-                ? `Tilt is running for this project (pid ${tiltPids.join(", ")}); run tdk down first`
-                : undefined);
+            const planned = await planDoctorFixes(projectName, undefined, {
+                tiltPids,
+                machine: options.scope === "machine",
+            });
             fixActions = await applyDoctorFixes(planned, {
                 dryRun: options.dryRun,
                 confirm: options.yes || (!options.json && process.stdin.isTTY)

package/cli/dist/commands/down.js

@@ -46,7 +46,7 @@ function pruneNetworksOrWarn(json) {
 export const downCommand = new Command("down")
     .description("Stop all tilt resources")
     .option("-v, --verbose", "Enable verbose output", false)
-    .option("-f, --force", "Skip confirmation", false)
+    .option("-f, --force", "Skip confirmation (no-op; accepted for script compatibility)", false)
     .option("--prune-networks", "Also remove this project's Docker networks (only those no container is attached to)", false)
     .option("--dry-run", "Show what would be stopped without stopping", false)
     .option("--json", "Print one JSON object on stdout; implies quiet human output", false)

package/cli/dist/commands/up.js

@@ -29,7 +29,7 @@ import { buildSmokePlans, formatSmokeFailure, runSmokePlans } from "../utils/smo
 import { buildStartupReport, formatStartupReport, isStartupStalled, } from "../utils/startup-report.js";
 import { evaluateTdkVersionFloor } from "../utils/tdk-version.js";
 import { buildTiltUpArgs, runTilt } from "../utils/tilt.js";
-import { findTiltPortOwner, isForeignTilt } from "../utils/tilt-port-owner.js";
+import { classifyTiltPorts } from "../utils/tilt-port-owner.js";
 import { stopTiltOnPort } from "../utils/tilt-process.js";
 import { parseTiltPort, resolveTiltPort, secondUpAction, stopTiltForUp, } from "../utils/tilt-startup.js";
 import { findUnknownServices, resolveOnlySelection } from "../utils/up-only.js";
@@ -369,20 +369,7 @@ export const upCommand = new Command("up")
         const basePort = STANDARD_PORTS.tiltUi;
         const watchedPort = configuredTiltPort ?? basePort;
         const candidatePorts = options.only ? [...new Set([basePort, watchedPort])] : [watchedPort];
-        const running = [];
-        const foreign = [];
-        for (const candidate of candidatePorts) {
-            if ((await tiltGetUiResources(candidate)) === null)
-                continue;
-            // A Tilt on this port may belong to another project; that is not "this environment is running".
-            const owner = findTiltPortOwner(candidate);
-            if (owner && isForeignTilt(owner, projectRoot)) {
-                foreign.push({ port: candidate, root: owner.root });
-            }
-            else {
-                running.push(candidate);
-            }
-        }
+        const { running, foreign } = await classifyTiltPorts(candidatePorts, projectRoot, async (candidate) => (await tiltGetUiResources(candidate)) !== null);
         if (foreign.length > 0 && configuredTiltPort !== undefined) {
             const other = foreign[0];
             const message = `TILT_PORT=${other?.port} is used by another project's Tilt (${other?.root}). Choose a free port, or run tdk down in that project.`;

package/cli/dist/utils/doctor-fix.js

@@ -1,10 +1,13 @@
 // Copyright (c) 2026 TDK Landscape contributors
 // SPDX-License-Identifier: MIT
 import { execFile } from "node:child_process";
-import { realpathSync } from "node:fs";
+import { realpathSync, statfsSync } from "node:fs";
+import { homedir } from "node:os";
 import { join } from "node:path";
 import { promisify } from "node:util";
-import { findProjectTiltUpPids, projectNetworkNames } from "./down-cleanup.js";
+import { DISK_WARN_GIB } from "./doctor-host.js";
+import { findProjectTiltUpPids, projectNetworkNames, tdkNetworkOwner, tdkNetworkPrefixes, } from "./down-cleanup.js";
+import { tiltGetUiResources } from "./up-readiness.js";
 import { findAllOnPath } from "./which.js";
 const execFilePromise = promisify(execFile);
 const DOCKER_TIMEOUT_MS = 15_000;
@@ -22,6 +25,51 @@ function firstLine(error) {
     const stderr = String(error.stderr ?? error).trim();
     return stderr.split(/\r?\n/)[0] ?? "";
 }
+const STALE_TILT_MIN_AGE_S = 120;
+/** `ps -o etime=` ("[[dd-]hh:]mm:ss") in seconds. */
+export function parseElapsed(etime) {
+    const match = /^\s*(?:(?:(\d+)-)?(\d+):)?(\d+):(\d+)\s*$/.exec(etime);
+    if (!match)
+        return null;
+    const [, days = "0", hours = "0", minutes = "0", seconds = "0"] = match;
+    return ((Number(days) * 24 + Number(hours)) * 60 + Number(minutes)) * 60 + Number(seconds);
+}
+/**
+ * Whether any of `ports` answers as a Tilt UI. A busy Tilt can miss one request, and a wrong "stale" ends in a kill,
+ * so a port gets a second try before it counts as silent.
+ */
+export async function anyTiltAnswers(ports, probe = tiltGetUiResources, attempts = 2, wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms))) {
+    for (let attempt = 0; attempt < attempts; attempt++) {
+        if (attempt > 0)
+            await wait(1000);
+        for (const port of ports) {
+            if ((await probe(port)) !== null)
+                return true;
+        }
+    }
+    return false;
+}
+async function tiltProcessStatus(pid) {
+    if (process.platform === "win32")
+        return "unknown";
+    try {
+        const { stdout: etime } = await execFilePromise("ps", ["-p", String(pid), "-o", "etime="], {
+            encoding: "utf-8",
+            timeout: 5000,
+        });
+        const age = parseElapsed(etime);
+        // A Tilt that is still starting has not bound its port yet.
+        if (age === null || age < STALE_TILT_MIN_AGE_S)
+            return "unknown";
+        const { stdout } = await execFilePromise("lsof", ["-nP", "-a", "-p", String(pid), "-iTCP", "-sTCP:LISTEN", "-Fn"], { encoding: "utf-8", timeout: 5000 });
+        const ports = [...stdout.matchAll(/^n.*:(\d+)$/gm)].map((m) => Number(m[1]));
+        return (await anyTiltAnswers(ports)) ? "healthy" : "stale";
+    }
+    catch {
+        // No lsof, or the process is gone: do not guess.
+        return "unknown";
+    }
+}
 export function createDockerFixDeps(run = runDocker) {
     return {
         async listNetworks() {
@@ -58,6 +106,54 @@ export function createDockerFixDeps(run = runDocker) {
                 throw new Error(firstLine(error));
             }
         },
+        freeDiskGib() {
+            try {
+                const stats = statfsSync(homedir());
+                return (Number(stats.bavail) * Number(stats.bsize)) / 1024 ** 3;
+            }
+            catch {
+                return null;
+            }
+        },
+        async reclaimable() {
+            let buildCache = null;
+            try {
+                const df = await run(["system", "df", "--format", "{{.Type}}\t{{.Reclaimable}}"]);
+                for (const line of df.split(/\r?\n/)) {
+                    const [type, size] = line.split("\t");
+                    // "1.531GB" or "1.5GB (39%)"; the percentage is of the whole, not useful here.
+                    if (type === "Build Cache" && size)
+                        buildCache = size.replace(/\s*\(.*\)/, "").trim();
+                }
+            }
+            catch {
+                // Leave unknown.
+            }
+            let danglingImages = 0;
+            try {
+                const ids = await run(["images", "-q", "-f", "dangling=true"]);
+                danglingImages = ids.split(/\r?\n/).filter(Boolean).length;
+            }
+            catch {
+                // Leave zero.
+            }
+            return { buildCache, danglingImages };
+        },
+        async prune(kind) {
+            try {
+                // Never `volume prune`, never `-a`: only the build cache and untagged images.
+                await run(kind === "builder" ? ["builder", "prune", "-f"] : ["image", "prune", "-f"]);
+            }
+            catch (error) {
+                throw new Error(firstLine(error));
+            }
+        },
+        async tiltStatus(pid) {
+            return tiltProcessStatus(pid);
+        },
+        stopProcess(pid) {
+            process.kill(pid, "SIGTERM");
+        },
         isProcessAlive(pid) {
             try {
                 process.kill(pid, 0);
@@ -72,17 +168,66 @@ export function createDockerFixDeps(run = runDocker) {
 }
 export const dockerFixDeps = createDockerFixDeps();
 /**
- * What `--fix` would do. Only unused networks that are either a leftover doctor probe or one of this project's own
- * (the exact names the engine creates, and only while `projectBusy` is unset) are planned; another project's networks are never listed here.
+ * What `--fix` would do: stop this project's stale Tilt; remove unused networks that are a leftover doctor probe or
+ * this project's own (the exact names the engine creates, skipped while its Tilt runs). Other TDK projects' unused
+ * networks are planned only with `context.machine`, each naming its owner.
  */
-export async function planDoctorFixes(projectName, deps = dockerFixDeps, projectBusy) {
-    const networks = await deps.listNetworks();
+export async function planDoctorFixes(projectName, deps = dockerFixDeps, context = {}) {
     const actions = [];
+    // A Tilt that has run a while without serving its UI is stale and may be stopped; any other Tilt of this project is
+    // running or starting, and its networks are not to be touched.
+    const liveTilt = [];
+    for (const pid of context.tiltPids ?? []) {
+        if ((await deps.tiltStatus(pid)) === "stale") {
+            actions.push({
+                id: `stop-tilt:${pid}`,
+                check: "Tilt processes",
+                scope: "project",
+                command: `kill -TERM ${pid}`,
+                status: "planned",
+                reason: "this project's Tilt is running but its UI does not answer",
+            });
+        }
+        else {
+            liveTilt.push(pid);
+        }
+    }
+    const projectBusy = liveTilt.length > 0
+        ? `Tilt is running for this project (pid ${liveTilt.join(", ")}); run tdk down first`
+        : undefined;
+    const networks = await deps.listNetworks();
+    const freeGib = deps.freeDiskGib();
+    if (freeGib !== null && freeGib < DISK_WARN_GIB) {
+        const { buildCache, danglingImages } = await deps.reclaimable();
+        const low = `${freeGib.toFixed(1)} GB free`;
+        if (buildCache && !/^0(\.0+)?\s*B$/i.test(buildCache)) {
+            actions.push({
+                id: "prune:builder",
+                check: "Disk Space",
+                scope: "host",
+                command: "docker builder prune -f",
+                status: "planned",
+                reason: `${low}; ${buildCache} of build cache reclaimable`,
+            });
+        }
+        if (danglingImages > 0) {
+            actions.push({
+                id: "prune:images",
+                check: "Disk Space",
+                scope: "host",
+                command: "docker image prune -f",
+                status: "planned",
+                reason: `${low}; ${danglingImages} untagged image${danglingImages === 1 ? "" : "s"}`,
+            });
+        }
+    }
     const own = new Set(projectName ? projectNetworkNames(projectName) : []);
+    const prefixes = tdkNetworkPrefixes(networks.map((network) => network.name));
     for (const network of networks) {
         const probe = PROBE_NETWORK.exec(network.name);
         let scope;
         let check;
+        let reason = "unused network";
         if (probe) {
             scope = "probe";
             check = "Orphaned probe networks";
@@ -91,6 +236,11 @@ export async function planDoctorFixes(projectName, deps = dockerFixDeps, project
             scope = "project";
             check = "Docker networks";
         }
+        else if (context.machine && tdkNetworkOwner(network.name, prefixes)) {
+            scope = "machine";
+            check = "Docker networks";
+            reason = `unused network of project "${tdkNetworkOwner(network.name, prefixes)}"`;
+        }
         else {
             continue;
         }
@@ -100,7 +250,7 @@ export async function planDoctorFixes(projectName, deps = dockerFixDeps, project
             scope,
             command: `docker network rm ${network.name}`,
             status: "planned",
-            reason: "unused network",
+            reason,
         };
         if (network.containers > 0) {
             action.status = "skipped";
@@ -147,9 +297,18 @@ export async function applyDoctorFixes(actions, options, deps = dockerFixDeps) {
             results.push({ ...action, status: "skipped", reason: "not confirmed" });
             continue;
         }
-        const name = action.id.slice("remove-network:".length);
         try {
-            await deps.removeNetwork(name);
+            if (action.id.startsWith("prune:")) {
+                await deps.prune(action.id === "prune:builder" ? "builder" : "images");
+                results.push({ ...action, status: "applied", reason: "pruned" });
+                continue;
+            }
+            if (action.id.startsWith("stop-tilt:")) {
+                deps.stopProcess(Number(action.id.slice("stop-tilt:".length)));
+                results.push({ ...action, status: "applied", reason: "stopped" });
+                continue;
+            }
+            await deps.removeNetwork(action.id.slice("remove-network:".length));
             results.push({ ...action, status: "applied", reason: "removed" });
         }
         catch (error) {

package/cli/dist/utils/down-cleanup.js

@@ -17,6 +17,32 @@ export function projectNetworkNames(projectName) {
     const prefix = projectName.replace(/-/g, "_");
     return PROJECT_NETWORK_SUFFIXES.map((suffix) => `${prefix}_${suffix}`);
 }
+/**
+ * Prefixes of TDK projects among `networkNames`, from the networks the engine creates. Generic suffixes such as
+ * `backend` also occur in non-TDK compose projects, so a prefix counts only if it has a Traefik network, which
+ * only TDK creates.
+ */
+export function tdkNetworkPrefixes(networkNames) {
+    const prefixes = new Set();
+    for (const name of networkNames) {
+        for (const marker of ["traefik-public", "traefik-private"]) {
+            if (name.endsWith(`_${marker}`))
+                prefixes.add(name.slice(0, -(marker.length + 1)));
+        }
+    }
+    return prefixes;
+}
+/** The TDK project prefix a network belongs to (`umami` for `umami_backend`), or null. */
+export function tdkNetworkOwner(name, prefixes) {
+    for (const suffix of PROJECT_NETWORK_SUFFIXES) {
+        if (name.endsWith(`_${suffix}`)) {
+            const prefix = name.slice(0, -(suffix.length + 1));
+            if (prefixes.has(prefix))
+                return prefix;
+        }
+    }
+    return null;
+}
 /**
  * Remove this project's own networks. Only the exact names the engine creates are touched, and `docker network rm`
  * itself refuses a network that still has containers attached, so another project's networks and in-use networks

package/cli/dist/utils/tilt-port-owner.js

@@ -47,3 +47,17 @@ function canonical(path) {
 export function isForeignTilt(owner, projectRoot) {
     return owner !== null && canonical(owner.root) !== canonical(projectRoot);
 }
+/** Split the candidate Tilt UI ports that answer into this project's and other projects'. */
+export async function classifyTiltPorts(candidatePorts, projectRoot, isServing, ownerOf = findTiltPortOwner) {
+    const result = { running: [], foreign: [] };
+    for (const port of candidatePorts) {
+        if (!(await isServing(port)))
+            continue;
+        const owner = ownerOf(port);
+        if (owner && isForeignTilt(owner, projectRoot))
+            result.foreign.push({ port, root: owner.root });
+        else
+            result.running.push(port);
+    }
+    return result;
+}

package/cli/dist/utils/tilt.js

@@ -92,9 +92,9 @@ export function buildTiltUpArgs(serviceNames, options = {}) {
 export function buildTiltDownArgs(options = {}) {
     const args = [];
     addTiltfilePath(args);
-    if (options.force) {
-        args.push("--force");
-    }
+    // Note: `tilt down` has no `--force` flag. The `-f/--force` option is accepted
+    // by `tdk down` for script compatibility and skipping confirmation, but must
+    // not be passed to `tilt down` as Tilt will exit with an "unknown flag: --force" error.
     // `tilt down` re-evaluates the Tiltfile and removes only the resources that evaluation registers. Without `--focus`
     // the Tiltfile falls back to its default phase and never registers a stack's own compose project, so `tdk up shop`
     // containers survived `tdk down`. Pass the same selection `tdk up` used (every stack) after `--`.