@tdk-landscape/tdk-cli-core 1.3.75 → 1.3.77

package/cli/dist/commands/doctor.js

@@ -1,28 +1,97 @@
-import { execSync } from "node:child_process";
+import { execFileSync, execSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { dirname, join, normalize, relative } from "node:path";
 import chalk from "chalk";
 import { Command } from "commander";
 import { hasVerdaccioLicense } from "../generator/extension-fetch.js";
-import { MASTER_CONFIG_FILES, QUICKSTART_DOCS_URL, REQUIRED_PACKAGE_SCRIPTS, } from "../utils/constants.js";
+import { MASTER_CONFIG_FILES, REQUIRED_PACKAGE_SCRIPTS } from "../utils/constants.js";
 import { isPathDiscovered, readDiscoveryPaths } from "../utils/discovery-paths.js";
 import { checkHealthRoutes, checkHostPorts, checkIngressPorts, checkPrivateNpmRegistry, checkTiltResourceHealth, projectConfigEnablesVerdaccio, summarizeServiceProbes, } from "../utils/doctor-runtime.js";
+import { checkDockerNetworkCapacity, checkFrontendBackendUrls, checkNatsBroker, checkResourcePackageJson, checkServiceUrlPorts, checkTiltInstances, } from "../utils/doctor-wiring.js";
 import { validateEnvFile } from "../utils/env-validator.js";
+import { execAsync, isExecTimeout } from "../utils/exec-async.js";
 import { formatCount } from "../utils/formatting.js";
 import { findProjectRoot } from "../utils/paths.js";
 import { buildHealthTargets, pingHealthTargets } from "../utils/service-urls.js";
 import { discoverResourcesFromRoot } from "../utils/services.js";
+import { findOnPath } from "../utils/which.js";
 export { checkIngressPorts, checkPrivateNpmRegistry, checkTiltResourceHealth, summarizeServiceProbes, summarizeTiltBuildError, } from "../utils/doctor-runtime.js";
 // A wedged Docker daemon makes `docker ps` block forever instead of failing,
 // and doctor is exactly the tool people run when their environment is broken.
 const EXEC_TIMEOUT_MS = 10_000;
+export const DOCTOR_FIXES = {
+    dockerMissing: "See https://docs.docker.com/get-docker/",
+    dockerDaemonDown: "Start Docker Desktop, OrbStack, or Colima, then retry: tdk doctor",
+    tiltMissing: "curl -fsSL https://raw.githubusercontent.com/tilt-dev/tilt/master/scripts/install.sh | bash",
+    bunMissing: "curl -fsSL https://bun.sh/install | bash",
+    port80: "Stop the process bound to port 80, or stop local nginx/caddy. Then: tdk doctor",
+    port5432: "Stop local Postgres or change the host port. Then: tdk doctor",
+    notProject: "tdk project --yes",
+};
+export const WSL2_DOCTOR_MESSAGE = "WSL2 detected. Use Docker Desktop WSL integration. Guide: docs/wsl2.md";
+export const NATIVE_WINDOWS_DOCTOR_MESSAGE = "Native Windows landscape boot is unsupported. Use WSL2 Ubuntu with Docker Desktop integration. Guide: docs/wsl2.md";
+export const MIN_TILT_VERSION = [0, 25, 0];
+export const MIN_BUN_VERSION = [1, 2, 0];
+export function versionMeetsMinimum(raw, minimum) {
+    const version = parseVersion(raw);
+    if (!version)
+        return false;
+    return isAtLeast(version, minimum);
+}
+export function checkWslProjectLocation(projectPath, strict, isWsl = process.platform === "linux" && Boolean(process.env.WSL_DISTRO_NAME)) {
+    if (!isWsl) {
+        return {
+            name: "WSL project location",
+            didPass: true,
+            isSkipped: true,
+            message: "Not running in WSL2 - skipped project filesystem check",
+        };
+    }
+    const normalized = projectPath.replace(/\\/g, "/").replace(/\/+$/, "").toLowerCase();
+    if (normalized !== "/mnt/c" && !normalized.startsWith("/mnt/c/")) {
+        return {
+            name: "WSL project location",
+            didPass: true,
+            message: `${WSL2_DOCTOR_MESSAGE} Project is on the WSL filesystem.`,
+        };
+    }
+    const message = `${WSL2_DOCTOR_MESSAGE} Project is under /mnt/c (${projectPath}); hot reload may be broken. Move it into the WSL filesystem, such as ~/projects.`;
+    return {
+        name: "WSL project location",
+        didPass: !strict,
+        isWarning: !strict,
+        message,
+        fix: "Move the repository under your WSL home directory (for example, ~/projects) and retry tdk doctor.",
+    };
+}
+/** Failures are shown before passing statuses, with a 5432 conflict first. */
+export function orderDoctorResults(results) {
+    const failures = results.filter((result) => !result.didPass && !result.isSkipped);
+    const remaining = results.filter((result) => result.didPass || result.isSkipped);
+    failures.sort((left, right) => {
+        const rank = (result) => result.name === "Host Ports" && /\b5432\b/.test(result.message)
+            ? 0
+            : result.name === "Host Ports"
+                ? 1
+                : result.name === "Ingress Ports"
+                    ? 2
+                    : 3;
+        return rank(left) - rank(right);
+    });
+    return [...failures, ...remaining];
+}
+export function getDoctorOutcomeMessage(inProject, allPassed) {
+    if (!allPassed)
+        return "Doctor failed. Fix the items above, then run: tdk doctor";
+    return inProject ? "Doctor passed. Next: tdk up" : "Doctor passed. Next: tdk project example";
+}
 function isTimeout(err) {
-    return err?.code === "ETIMEDOUT";
+    return isExecTimeout(err);
 }
 function createExecCheck(name, command, successMessage, failureMessage, fixInstructions) {
-    return () => {
+    return async () => {
         try {
-            execSync(command, { stdio: "pipe", timeout: EXEC_TIMEOUT_MS });
+            await execAsync(command, EXEC_TIMEOUT_MS);
             return {
                 name,
                 didPass: true,
@@ -40,10 +109,37 @@ function createExecCheck(name, command, successMessage, failureMessage, fixInstr
         }
     };
 }
-function checkDockerRuntime() {
-    // Check for Docker
+async function succeeds(command) {
+    try {
+        await execAsync(command, EXEC_TIMEOUT_MS);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function checkDockerRuntime() {
+    if (process.platform === "win32") {
+        try {
+            await execAsync("docker ps", EXEC_TIMEOUT_MS);
+            return {
+                name: "Container Runtime",
+                didPass: true,
+                message: "Docker Desktop Linux container engine is running",
+            };
+        }
+        catch {
+            return {
+                name: "Container Runtime",
+                didPass: false,
+                message: "Docker is not running",
+                fix: DOCTOR_FIXES.dockerDaemonDown,
+            };
+        }
+    }
+    const hasDockerCli = Boolean(findOnPath("docker"));
     try {
-        execSync("docker ps", { stdio: "pipe", timeout: EXEC_TIMEOUT_MS });
+        await execAsync("docker ps", EXEC_TIMEOUT_MS);
         return {
             name: "Container Runtime",
             didPass: true,
@@ -55,55 +151,50 @@ function checkDockerRuntime() {
             return {
                 name: "Container Runtime",
                 didPass: false,
-                message: `Docker daemon is not responding (\`docker ps\` hung for ${EXEC_TIMEOUT_MS / 1000}s)`,
-                fix: "Restart the runtime: quit and reopen Docker Desktop, or run `colima restart`",
-            };
-        }
-        // Docker not running, check for Colima
-        try {
-            execSync("colima status", { stdio: "pipe", timeout: EXEC_TIMEOUT_MS });
-            // Colima is running
-            return {
-                name: "Container Runtime",
-                didPass: true,
-                message: "Colima (Docker runtime) is running",
+                message: "Docker daemon is not responding",
+                fix: DOCTOR_FIXES.dockerDaemonDown,
             };
         }
-        catch {
-            // Check if Colima is installed but not running
-            try {
-                execSync("which colima", { stdio: "pipe", timeout: EXEC_TIMEOUT_MS });
-                return {
-                    name: "Container Runtime",
-                    didPass: false,
-                    message: "Colima is installed but not running",
-                    fix: "Start Colima: colima start",
-                };
-            }
-            catch {
-                // Check for Podman
-                try {
-                    execSync("podman ps", { stdio: "pipe", timeout: EXEC_TIMEOUT_MS });
-                    return {
-                        name: "Container Runtime",
-                        didPass: true,
-                        message: "Podman is running",
-                    };
-                }
-                catch {
-                    // No container runtime found
-                    return {
-                        name: "Container Runtime",
-                        didPass: false,
-                        message: "No container runtime (Docker/Colima/Podman) is running",
-                        fix: `Start: colima start (recommended) OR open -a Docker (macOS) OR sudo systemctl start docker (Linux). Setup guide: ${QUICKSTART_DOCS_URL}`,
-                    };
-                }
-            }
-        }
     }
+    // Docker not running: check for Colima, then Podman
+    if (await succeeds("colima status")) {
+        return {
+            name: "Container Runtime",
+            didPass: true,
+            message: "Colima (Docker runtime) is running",
+        };
+    }
+    if (findOnPath("colima")) {
+        return {
+            name: "Container Runtime",
+            didPass: false,
+            message: "Colima is installed but not running",
+            fix: DOCTOR_FIXES.dockerDaemonDown,
+        };
+    }
+    if (await succeeds("podman ps")) {
+        return {
+            name: "Container Runtime",
+            didPass: true,
+            message: "Podman is running",
+        };
+    }
+    if (hasDockerCli) {
+        return {
+            name: "Container Runtime",
+            didPass: false,
+            message: "Docker daemon is not running",
+            fix: DOCTOR_FIXES.dockerDaemonDown,
+        };
+    }
+    return {
+        name: "Container Runtime",
+        didPass: false,
+        message: "Docker is not running",
+        fix: DOCTOR_FIXES.dockerMissing,
+    };
 }
-const checkDockerCompose = createExecCheck("Docker Compose", "docker compose version", "Docker Compose plugin available", "Docker Compose plugin not found", "Install Docker Compose: https://docs.docker.com/compose/install/");
+export const checkDockerCompose = createExecCheck("Docker Compose", "docker compose version", "Docker Compose plugin available", "Docker Compose plugin not found", "Install Docker Compose: https://docs.docker.com/compose/install/");
 // Generated healthchecks use `start_interval`, which older engines/compose reject.
 const MIN_DOCKER_ENGINE_VERSION = [25, 0, 0];
 const MIN_DOCKER_COMPOSE_VERSION = [2, 20, 2];
@@ -123,13 +214,15 @@ function isAtLeast(version, minimum) {
     }
     return true;
 }
-export function checkDockerVersions(exec = execSync) {
-    const run = (command) => String(exec(command, { stdio: "pipe", encoding: "utf-8", timeout: EXEC_TIMEOUT_MS })).trim();
+export async function checkDockerVersions(exec = execAsync) {
+    const run = async (command) => String(await exec(command, EXEC_TIMEOUT_MS)).trim();
     let engineRaw;
     let composeRaw;
     try {
-        engineRaw = run("docker version --format '{{.Server.Version}}'");
-        composeRaw = run("docker compose version --short");
+        [engineRaw, composeRaw] = await Promise.all([
+            run("docker version --format '{{.Server.Version}}'"),
+            run("docker compose version --short"),
+        ]);
     }
     catch {
         return {
@@ -170,7 +263,101 @@ export function checkDockerVersions(exec = execSync) {
         fix: "Update Docker Desktop, or on Linux update docker-ce and the docker-compose-plugin package",
     };
 }
-const checkTilt = createExecCheck("Tilt CLI", "tilt version", "Tilt CLI installed", "Tilt CLI not found", `Install Tilt: brew install tilt (macOS) or see https://docs.tilt.dev/install.html. Setup guide: ${QUICKSTART_DOCS_URL}`);
+export async function checkTilt(exec = execAsync) {
+    let raw;
+    try {
+        raw = String(await exec("tilt version", EXEC_TIMEOUT_MS)).trim();
+    }
+    catch {
+        return {
+            name: "Tilt CLI",
+            didPass: false,
+            message: "Tilt CLI not found",
+            fix: DOCTOR_FIXES.tiltMissing,
+        };
+    }
+    if (!versionMeetsMinimum(raw, MIN_TILT_VERSION)) {
+        return {
+            name: "Tilt CLI",
+            didPass: false,
+            message: `Tilt ${raw || "version unknown"} is below the required v0.25.0 floor`,
+            fix: "Install Tilt v0.25.0 or newer: https://docs.tilt.dev/install.html",
+        };
+    }
+    return { name: "Tilt CLI", didPass: true, message: `Tilt ${raw} is available` };
+}
+export async function checkDockerOperatingSystem(exec = execAsync) {
+    let osType;
+    try {
+        osType = String(await exec("docker info --format '{{.OSType}}'", EXEC_TIMEOUT_MS))
+            .trim()
+            .toLowerCase();
+    }
+    catch {
+        return {
+            name: "Docker OS",
+            didPass: true,
+            isSkipped: true,
+            message: "Docker OS unavailable - daemon failure reported separately",
+        };
+    }
+    if (osType !== "linux") {
+        return {
+            name: "Docker OS",
+            didPass: false,
+            message: `Docker is using the ${osType || "unknown"} engine; TDK requires Linux containers`,
+            fix: "Switch Docker Desktop to Linux containers, enable WSL2 integration, then retry tdk doctor.",
+        };
+    }
+    return { name: "Docker OS", didPass: true, message: "Docker is using Linux containers" };
+}
+export async function checkBun(exec = execAsync) {
+    const projectRoot = findProjectRoot();
+    if (!projectRoot) {
+        return {
+            name: "Bun",
+            didPass: true,
+            isSkipped: true,
+            message: "Not in a project - skipping Bun check",
+        };
+    }
+    const resources = discoverResourcesFromRoot(projectRoot);
+    const hasGeneratedJsServices = resources.some((resource) => resource.config?.appType === "backend" ||
+        resource.config?.appType === "frontend" ||
+        resource.config?.appType === "worker");
+    if (!hasGeneratedJsServices) {
+        return {
+            name: "Bun",
+            didPass: true,
+            isSkipped: true,
+            message: "No generated JS services - skipping Bun check",
+        };
+    }
+    try {
+        const rawVersion = String(await exec("bun --version", EXEC_TIMEOUT_MS)).trim();
+        if (!versionMeetsMinimum(rawVersion, MIN_BUN_VERSION)) {
+            return {
+                name: "Bun",
+                didPass: false,
+                message: `Bun ${rawVersion || "version unknown"} is below the required 1.2.0 floor`,
+                fix: "Install Bun 1.2.0 or newer: https://bun.sh/install",
+            };
+        }
+        return {
+            name: "Bun",
+            didPass: true,
+            message: `Bun ${rawVersion} is available`,
+        };
+    }
+    catch {
+        return {
+            name: "Bun",
+            didPass: false,
+            message: "Bun is not available",
+            fix: DOCTOR_FIXES.bunMissing,
+        };
+    }
+}
 function checkEnvironmentVariables() {
     const projectRoot = findProjectRoot() ?? process.cwd();
     const validation = validateEnvFile(projectRoot);
@@ -712,10 +899,11 @@ function parseDockerStats(raw) {
 function checkContainerResourceHealth() {
     let raw;
     try {
-        raw = execSync('docker stats --no-stream --format "{{.Name}},{{.MemPerc}},{{.CPUPerc}}"', {
+        raw = execFileSync(findOnPath("docker") ?? "docker", ["stats", "--no-stream", "--format", "{{.Name}},{{.MemPerc}},{{.CPUPerc}}"], {
             stdio: "pipe",
             encoding: "utf-8",
             timeout: EXEC_TIMEOUT_MS,
+            windowsHide: process.platform === "win32",
         });
     }
     catch (err) {
@@ -781,8 +969,14 @@ async function checkServiceHealth(timeoutMs) {
 export const doctorCommand = new Command("doctor")
     .description("Check environment readiness for TDK")
     .option("--no-ping", "Skip pinging running services' /health endpoints")
+    .option("--strict", "Fail warnings such as a WSL project under /mnt/c")
     .option("--ping-timeout <ms>", "Per-service ping timeout in milliseconds", String(DEFAULT_PING_TIMEOUT_MS))
     .action(async (options) => {
+    if (process.platform === "win32") {
+        console.error(NATIVE_WINDOWS_DOCTOR_MESSAGE);
+        process.exit(1);
+        return;
+    }
     console.log(`\n${chalk.bold("🔍 TDK Doctor")}\n`);
     console.log("Checking environment...\n");
     const pingTimeout = Number.parseInt(options.pingTimeout, 10);
@@ -791,10 +985,17 @@ export const doctorCommand = new Command("doctor")
         process.exit(1);
     }
     const machineChecks = [
+        () => checkHostPorts(),
+        () => checkIngressPorts(),
         checkDockerRuntime,
+        checkDockerOperatingSystem,
         checkTilt,
         checkDockerCompose,
         checkDockerVersions,
+        checkBun,
+        () => checkWslProjectLocation(findProjectRoot() ?? process.cwd(), options.strict),
+        // Each project needs several networks; a full address pool fails `tdk up` late.
+        () => checkDockerNetworkCapacity(),
     ];
     const projectChecks = [
         checkMasterConfigs,
@@ -806,11 +1007,13 @@ export const doctorCommand = new Command("doctor")
         checkTypeScriptTypeDependencies,
         checkFrontendDockerPreflight,
         checkResourceDiscovery,
+        // Wiring mistakes that otherwise surface minutes into `tdk up`.
+        () => checkResourcePackageJson(),
+        () => checkServiceUrlPorts(),
+        () => checkFrontendBackendUrls(),
+        () => checkNatsBroker(),
+        () => checkTiltInstances(),
         checkEnvironmentVariables,
-        // Preflight: catch "port 80 already allocated" BEFORE claiming ready.
-        checkIngressPorts,
-        // Preflight: a local Postgres or web server on 5432/80/443.
-        () => checkHostPorts(),
         // Preflight: Verdaccio down causes ImageBuild bun install ConnectionRefused.
         async () => {
             const root = findProjectRoot() ?? process.cwd();
@@ -832,52 +1035,46 @@ export const doctorCommand = new Command("doctor")
     // project. Only the machine checks mean anything there; the project checks
     // would all fail with "run tdk project".
     const inProject = Boolean(findProjectRoot());
-    const checks = inProject ? [...machineChecks, ...projectChecks] : machineChecks;
-    let allPassed = true;
-    for (const checkFn of checks) {
-        const result = await checkFn();
-        if (result.isSkipped) {
+    const checks = inProject ? [...machineChecks, ...projectChecks] : [...machineChecks];
+    // Machine checks are independent and mostly wait on child processes, so run
+    // them concurrently. Project checks stay sequential; rendering ranks failures first.
+    const startedMachineChecks = machineChecks.map((checkFn) => Promise.resolve().then(checkFn));
+    const results = [];
+    for (const [index, checkFn] of checks.entries()) {
+        const result = await (startedMachineChecks[index] ?? checkFn());
+        results.push(result);
+    }
+    // Let machine checks finish before process.exit so their probes can clean up.
+    await Promise.allSettled(startedMachineChecks);
+    const allPassed = results.every((result) => result.didPass || result.isSkipped);
+    for (const result of orderDoctorResults(results)) {
+        if (!result.didPass && !result.isSkipped) {
+            console.log(`${chalk.red("✗")} ${result.message}`);
+            if (result.fix)
+                console.log(`${chalk.blue("ℹ")} Fix: ${result.fix}`);
+        }
+        else if (result.isWarning) {
+            console.log(`${chalk.yellow("⚠")} ${chalk.yellow(result.message)}`);
+            if (result.fix)
+                console.log(`${chalk.blue("ℹ")} Fix: ${result.fix}`);
+        }
+        else if (result.isSkipped) {
             console.log(`${chalk.gray("○")} ${chalk.gray(result.message)}`);
-            if (result.fix) {
+            if (result.fix)
                 console.log(`${chalk.blue("ℹ")} ${result.fix}`);
-            }
-        }
-        else if (result.didPass) {
-            console.log(`${chalk.green("✓")} ${result.message}`);
         }
         else {
-            console.log(`${chalk.red("✗")} ${result.message}`);
-            if (result.fix) {
-                console.log(`${chalk.blue("ℹ")} Fix: ${result.fix}`);
-            }
-            allPassed = false;
-            break;
+            console.log(`${chalk.green("✓")} ${result.message}`);
         }
     }
     console.log("");
     if (allPassed && !inProject) {
         console.log(`${chalk.gray("○")} ${chalk.gray("Not in a TDK project, so project checks were skipped")}`);
         console.log("");
-        console.log(`${chalk.green(chalk.bold("✓"))} This machine is ready for TDK`);
-        console.log("");
-        console.log("Next steps:");
-        console.log("  1. mkdir my-app && cd my-app");
-        console.log("  2. tdk project --yes");
-        console.log("  3. tdk resource api --type backend --stack my-app");
-        console.log("  4. tdk up my-app");
-    }
-    else if (allPassed) {
-        console.log(`${chalk.green(chalk.bold("✓"))} Environment ready for TDK`);
-        console.log("");
-        console.log("Next steps:");
-        console.log("  1. Run: tdk up");
-        console.log("  2. Open: http://localhost:10350");
     }
-    else {
-        console.log(`${chalk.red(chalk.bold("✗"))} Environment not ready`);
-        console.log("");
-        console.log("Fix the issues above, then run: tdk doctor");
+    const outcome = getDoctorOutcomeMessage(inProject, allPassed);
+    console.log(`${allPassed ? chalk.green(chalk.bold("✓")) : chalk.red(chalk.bold("✗"))} ${outcome}`);
+    if (!allPassed)
         process.exit(1);
-    }
 });
 //# sourceMappingURL=doctor.js.map

package/cli/dist/commands/eject.js

@@ -0,0 +1,77 @@
+import { existsSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import chalk from "chalk";
+import { Command } from "commander";
+import { confirmOrCancel } from "../utils/command-helpers.js";
+import { runCommand } from "../utils/errors.js";
+import { findProjectRoot } from "../utils/paths.js";
+export const EJECTED_CONTENT = `# Ejected from TDK
+
+These files were generated by TDK. You can keep using Docker and Tilt without the tdk CLI.
+
+Keep:
+- Tiltfile
+- Dockerfiles
+- compose files TDK wrote
+- Traefik / proxy config TDK wrote
+
+Optional to delete later:
+- .tdk/
+- service.json files (only if you no longer want tdk up)
+
+To go back: install TDK and run \`tdk config regenerate\`.
+`;
+export const ejectCommand = new Command("eject")
+    .description("Take ownership of the generated Tilt and Docker files")
+    .option("--dry-run", "List generated files without changing the project", false)
+    .option("--yes", "Skip the confirmation prompt", false)
+    .action(async (options) => {
+    await runCommand(async () => {
+        const projectRoot = findProjectRoot();
+        if (!projectRoot) {
+            throw new Error("tdk eject: no .tdk/project.json in this directory or parents");
+        }
+        const generatedPaths = [".tdk/.tdk-out"];
+        const presentPaths = generatedPaths.filter((path) => existsSync(join(projectRoot, path)));
+        const files = presentPaths.flatMap((path) => {
+            const absolutePath = join(projectRoot, path);
+            if (statSync(absolutePath).isFile())
+                return [path];
+            try {
+                return readdirSync(absolutePath, { recursive: true }).map((entry) => join(path, entry.toString()));
+            }
+            catch {
+                return [path];
+            }
+        });
+        if (!existsSync(join(projectRoot, ".tdk", ".tdk-out", "Tiltfile"))) {
+            throw new Error("Generated Tilt files are missing. Run `tdk project --yes` before ejecting.");
+        }
+        const rootTiltfile = join(projectRoot, "Tiltfile");
+        if (existsSync(rootTiltfile))
+            files.push("Tiltfile");
+        const ejectedPath = join(projectRoot, "EJECTED.md");
+        const willCreate = existsSync(ejectedPath) ? [] : ["EJECTED.md"];
+        if (options.dryRun) {
+            console.log("Files kept:");
+            for (const path of files)
+                console.log(`  ${path}`);
+            console.log("Files created:");
+            for (const path of willCreate)
+                console.log(`  ${path}`);
+            if (willCreate.length === 0)
+                console.log("  (none)");
+            return;
+        }
+        if (!options.yes &&
+            !(await confirmOrCancel("Take ownership of the generated Tilt and Docker files?"))) {
+            return;
+        }
+        if (!existsSync(ejectedPath))
+            writeFileSync(ejectedPath, EJECTED_CONTENT, { flag: "wx" });
+        console.log(chalk.green("Ejected. Tilt and Docker files are yours."));
+        console.log("Next: tilt up");
+        console.log("Read EJECTED.md");
+    });
+});
+//# sourceMappingURL=eject.js.map

package/cli/dist/commands/networks.js

@@ -1,4 +1,4 @@
-import { execSync, spawn } from "node:child_process";
+import { execFileSync, spawn } from "node:child_process";
 import chalk from "chalk";
 import { Command } from "commander";
 import { readProjectConfig } from "../generator/template-engine.js";
@@ -9,10 +9,13 @@ import { colorizeByStatus, DEFAULT_BOX_WIDTH, formatBoxLine, formatPadded, getSt
 import { findProjectRoot } from "../utils/paths.js";
 import { checkPortStatus } from "../utils/port-assignment.js";
 import { isValidPort, sanitizeForShell } from "../utils/validation.js";
+import { findOnPath } from "../utils/which.js";
 function execSafe(command, args, options = {}) {
     return new Promise((resolve, reject) => {
-        const child = spawn(command, args, {
+        const child = spawn(findOnPath(command) ?? command, args, {
             timeout: options.timeout || 5000,
+            shell: false,
+            windowsHide: process.platform === "win32",
         });
         let stdout = "";
         let stderr = "";
@@ -46,7 +49,7 @@ function determineDefaultDomain() {
     }
     const domains = new Set();
     try {
-        const traefikLabels = execSync('docker ps --filter "label=traefik.enable=true" --format "{{.Labels}}" 2>/dev/null', { encoding: "utf-8" });
+        const traefikLabels = execFileSync(findOnPath("docker") ?? "docker", ["ps", "--filter", "label=traefik.enable=true", "--format", "{{.Labels}}"], { encoding: "utf-8", windowsHide: process.platform === "win32" });
         // Capture every Host(`...`) in a rule (multi-host rules included), avoid ReDoS with bounded classes
         const domainRegex = /Host\(`([a-zA-Z0-9_.-]{1,100})`\)/g;
         for (let match = domainRegex.exec(traefikLabels); match !== null; match = domainRegex.exec(traefikLabels)) {
@@ -130,7 +133,9 @@ async function checkServiceStatus(serviceName, port, url) {
             return "running";
         }
         if (portStatus === "unknown") {
-            console.warn(chalk.yellow(`⚠️ Could not check port ${port} (lsof unavailable)`));
+            console.warn(chalk.yellow(process.platform === "win32"
+                ? `⚠️ Could not check port ${port} with the Windows TCP probe`
+                : `⚠️ Could not check port ${port} (port probe unavailable)`));
         }
     }
     try {
@@ -175,6 +180,9 @@ export const networksCommand = new Command("networks")
             stack: s.stack,
             basePath: s.config.basePath,
             url,
+            ...(process.platform === "win32"
+                ? { loopbackUrl: `http://127.0.0.1:80/${basePath}`.replace(/\/$/, "") }
+                : {}),
             port,
             status,
         };
@@ -200,6 +208,8 @@ export const networksCommand = new Command("networks")
     if (options.raw) {
         for (const service of filteredServices) {
             console.log(service.url);
+            if (service.loopbackUrl)
+                console.log(service.loopbackUrl);
         }
         process.exit(0);
     }
@@ -237,6 +247,9 @@ export const networksCommand = new Command("networks")
                 : chalk.gray(service.url); // Gray out URL if stopped
             const statusLabel = service.status !== "running" ? chalk.gray(` [${service.status}]`) : "";
             console.log(`  ${statusEmoji} ${chalk.white(namePart)}  ${urlPart}${statusLabel}`);
+            if (service.loopbackUrl) {
+                console.log(`     ${chalk.gray(`Loopback: ${service.loopbackUrl} (Host: ${new URL(service.url).hostname})`)}`);
+            }
         }
     }
     console.log();