@tdk-landscape/tdk-cli-core 1.3.103 → 1.3.105

package/README.md

@@ -2,7 +2,7 @@
 
 [![npm version](https://img.shields.io/npm/v/@tdk-landscape/tdk-cli-core.svg?style=flat&color=blue)](https://www.npmjs.com/package/@tdk-landscape/tdk-cli-core)
 [![unpacked size](https://img.shields.io/npm/unpacked-size/@tdk-landscape/tdk-cli-core)](https://packagephobia.com/result?p=@tdk-landscape/tdk-cli-core)
-[![install size](https://packagephobia.com/badge?p=@tdk-landscape/tdk-cli-core@1.3.81)](https://packagephobia.com/result?p=@tdk-landscape/tdk-cli-core@1.3.81)
+[![install size](https://packagephobia.com/badge?p=@tdk-landscape/tdk-cli-core)](https://packagephobia.com/result?p=@tdk-landscape/tdk-cli-core)
 [![CI](https://github.com/tdk-landscape/tdk-cli-core/actions/workflows/ci.yml/badge.svg)](https://github.com/tdk-landscape/tdk-cli-core/actions/workflows/ci.yml)
 [![Quickstart E2E](https://github.com/tdk-landscape/tdk-cli-core/actions/workflows/quickstart-e2e.yml/badge.svg)](https://github.com/tdk-landscape/tdk-cli-core/actions/workflows/quickstart-e2e.yml)
 [![ERP fixture scale E2E](https://github.com/tdk-landscape/tdk-cli-core/actions/workflows/erp-scale-e2e.yml/badge.svg)](https://github.com/tdk-landscape/tdk-cli-core/actions/workflows/erp-scale-e2e.yml)

package/cli/dist/commands/doctor.js

@@ -4,6 +4,7 @@ import { dirname, join, normalize, relative } from "node:path";
 import chalk from "chalk";
 import { Command } from "commander";
 import { hasVerdaccioLicense } from "../generator/extension-fetch.js";
+import { DEVCONTAINER_DOCKER_FIX, detectHost, isContainerHost, WEBCONTAINER_DOCS, WEBCONTAINER_UP_MESSAGE, } from "../utils/agent-host.js";
 import { MASTER_CONFIG_FILES, REQUIRED_PACKAGE_SCRIPTS } from "../utils/constants.js";
 import { isPathDiscovered, readDiscoveryPaths } from "../utils/discovery-paths.js";
 import { collectDoctorChecks, createDoctorReport, getDoctorExitCode, } from "../utils/doctor-report.js";
@@ -1005,6 +1006,7 @@ export const doctorCommand = new Command("doctor")
     if (!options.json) {
         console.log("TDK doctor checks your local Docker + Tilt development environment; it does not check cluster deployments.");
     }
+    const host = detectHost();
     if (process.platform === "win32") {
         if (options.json) {
             let windowsPortPlan = null;
@@ -1021,12 +1023,27 @@ export const doctorCommand = new Command("doctor")
                     message: NATIVE_WINDOWS_DOCTOR_MESSAGE,
                     fix: "Use WSL2 Ubuntu with Docker Desktop integration. Guide: docs/wsl2.md",
                 },
-            ], Boolean(findProjectRoot()), [], windowsPortPlan)));
+            ], Boolean(findProjectRoot()), [], windowsPortPlan, { ...host, canUp: false })));
         }
         console.error(NATIVE_WINDOWS_DOCTOR_MESSAGE);
         process.exit(1);
         return;
     }
+    if (host.kind === "webcontainer") {
+        const report = createDoctorReport([
+            {
+                name: "Host",
+                didPass: false,
+                message: WEBCONTAINER_UP_MESSAGE,
+                fix: `Use a machine with Docker. Guide: ${WEBCONTAINER_DOCS}`,
+            },
+        ], Boolean(findProjectRoot()), [], undefined, host);
+        if (options.json)
+            console.log(JSON.stringify(report));
+        console.error(WEBCONTAINER_UP_MESSAGE);
+        process.exit(1);
+        return;
+    }
     if (!options.json) {
         console.log(`\n${chalk.bold("🔍 TDK Doctor")}\n`);
         console.log("Checking environment...\n");
@@ -1113,7 +1130,14 @@ export const doctorCommand = new Command("doctor")
     // would all fail with "run tdk project".
     const inProject = Boolean(projectRoot);
     const { checks: results, errors } = await collectDoctorChecks(machineChecks, inProject ? projectChecks : []);
-    const report = createDoctorReport(orderDoctorResults(results), inProject, errors, hostPortPlan);
+    if (isContainerHost(host.kind)) {
+        for (const result of results) {
+            if (result.name === "Container Runtime" && !result.didPass) {
+                result.fix = DEVCONTAINER_DOCKER_FIX;
+            }
+        }
+    }
+    const report = createDoctorReport(orderDoctorResults(results), inProject, errors, hostPortPlan, host);
     const exitCode = getDoctorExitCode(report);
     const allPassed = report.data.ready;
     if (options.json) {

package/cli/dist/commands/down.js

@@ -2,31 +2,40 @@ import chalk from "chalk";
 import { Command } from "commander";
 import { handleDryRun } from "../utils/command-helpers.js";
 import { handleTiltFailure, withTiltCheck } from "../utils/errors.js";
+import { createJsonEmitter } from "../utils/json-output.js";
 import { buildTiltDownArgs, runTilt } from "../utils/tilt.js";
 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("--dry-run", "Show what would be stopped without stopping", false)
+    .option("--json", "Print one JSON object on stdout; implies quiet human output", false)
     .action(async (options) => {
+    const emit = options.json ? createJsonEmitter("DOWN_FAILED", "tdk down") : undefined;
     await withTiltCheck(async () => {
+        if (emit && options.dryRun) {
+            emit({ ok: true, dryRun: true });
+            return;
+        }
         if (handleDryRun(options, "not stopping resources", "tilt down")) {
             return;
         }
         const tiltArgs = buildTiltDownArgs({
             force: options.force,
         });
-        console.log(chalk.blue("Stopping all tilt resources..."));
-        if (options.verbose) {
+        if (!options.json)
+            console.log(chalk.blue("Stopping all tilt resources..."));
+        if (options.verbose && !options.json) {
             console.log(chalk.gray("Running: tilt down -f .tdk/.tdk-out/Tiltfile"));
         }
         const result = await runTilt("down", tiltArgs, {
-            verbose: options.verbose,
-            inheritStdio: true,
+            verbose: options.verbose && !options.json,
+            inheritStdio: !options.json,
         });
         if (result.exitCode !== 0) {
             handleTiltFailure("down", result.exitCode);
         }
+        emit?.({ ok: true });
     });
 });
 //# sourceMappingURL=down.js.map

package/cli/dist/commands/status.js

@@ -3,7 +3,10 @@ import { Command } from "commander";
 import { createDiscoveryContext } from "../utils/discovery-context.js";
 import { runCommand } from "../utils/errors.js";
 import { formatCount, showDetail, showStep } from "../utils/formatting.js";
+import { getHostPortPlan } from "../utils/host-port-config.js";
 import { createMachineEnvelope, writeMachineError } from "../utils/machine-output.js";
+import { findProjectRoot } from "../utils/paths.js";
+import { buildServicePorts, buildStackPorts } from "../utils/status-ports.js";
 import { getTiltfilePath, isTiltAvailable, runTilt } from "../utils/tilt.js";
 export const statusCommand = new Command("status")
     .description("Show status of resources and stacks")
@@ -51,6 +54,14 @@ export const statusCommand = new Command("status")
             }
         }
         if (options.json) {
+            let portPlan = null;
+            try {
+                const root = findProjectRoot();
+                portPlan = root ? await getHostPortPlan(root, { inspectDocker: false }) : null;
+            }
+            catch {
+                // Port planning is best effort; stack ports then list only the Tilt UI.
+            }
             const errors = queryError ? [{ code: "TILT_STATUS_UNAVAILABLE", message: queryError }] : [];
             const data = {
                 tilt: {
@@ -63,7 +74,9 @@ export const statusCommand = new Command("status")
                     stack: resource.stack ?? null,
                     type: resource.type ?? "unknown",
                     port: resource.port ?? null,
+                    ...buildServicePorts(resource, portPlan?.ingressHttp),
                 })),
+                ports: buildStackPorts(portPlan, process.env.TILT_PORT ? Number.parseInt(process.env.TILT_PORT, 10) : undefined),
                 stacks: discovery.stacks.map((stack) => ({
                     name: stack.name,
                     resourceCount: stack.resourceCount,

package/cli/dist/commands/ui.js

@@ -12,7 +12,7 @@ const HelpPanel = ({ onClose }) => (_jsxs(Box, { borderStyle: "single", borderCo
 const LoadingScreen = ({ progress, message }) => (_jsxs(Box, { flexDirection: "column", padding: 2, children: [_jsx(Text, { bold: true, color: "cyan", children: "\u2593\u2592\u2591 TDK NEON EDITION \u2591\u2592\u2593" }), _jsx(Box, { marginY: 1 }), _jsxs(Text, { children: ["Loading: ", message] }), _jsxs(Box, { marginY: 1, borderStyle: "single", borderColor: "gray", width: 50, children: [_jsx(Box, { width: progress / 2, backgroundColor: "cyan", children: _jsx(Text, { children: " ".repeat(progress / 2) }) }), _jsxs(Text, { children: [" ", progress, "%"] })] })] }));
 // biome-ignore lint/correctness/noUnusedFunctionParameters: reserved callback prop kept in the component API
 const ErrorScreen = ({ error, onRetry }) => (_jsxs(Box, { flexDirection: "column", padding: 2, alignItems: "center", children: [_jsx(Text, { bold: true, color: "red", children: "Could Not Load Services" }), _jsx(Box, { marginY: 1 }), _jsxs(Text, { color: "red", children: ["\u2717 ", error] }), _jsx(Box, { marginY: 1 }), _jsx(Text, { color: "gray", children: "Troubleshooting:" }), _jsx(Text, { color: "gray", children: " 1. Check that every service.json is valid JSON" }), _jsx(Text, { color: "gray", children: " 2. Run tdk from your project (the folder with the Tiltfile)" }), _jsx(Text, { color: "gray", children: " 3. Try: tdk status --verbose" }), _jsx(Box, { marginY: 1 }), _jsx(Text, { color: "cyan", children: "Press [r] to retry or [q] to quit" })] }));
-const EmptyState = ({ message }) => (_jsxs(Box, { flexDirection: "column", padding: 2, alignItems: "center", children: [_jsx(Text, { bold: true, color: "yellow", children: "No Services Found" }), _jsx(Box, { marginY: 1 }), _jsx(Text, { color: "gray", children: "\u25C9 No service.json files found" }), _jsx(Box, { marginY: 1 }), _jsx(Text, { children: "To get started:" }), _jsx(Text, { children: " 1. Run: tdk init" }), _jsx(Text, { children: " 2. Or create services manually" }), _jsx(Box, { marginY: 1 }), _jsx(Text, { color: "cyan", children: "Press [r] to refresh or [q] to quit" }), message && (_jsx(Box, { paddingX: 1, height: 1, children: _jsxs(Text, { color: "cyan", children: ["\u2593\u2592\u2591 ", message, " \u2591\u2592\u2593"] }) }))] }));
+const EmptyState = ({ message }) => (_jsxs(Box, { flexDirection: "column", padding: 2, alignItems: "center", children: [_jsx(Text, { bold: true, color: "yellow", children: "No Services Found" }), _jsx(Box, { marginY: 1 }), _jsx(Text, { color: "gray", children: "\u25C9 No service.json files found" }), _jsx(Box, { marginY: 1 }), _jsx(Text, { children: "To get started:" }), _jsx(Text, { children: " 1. Run: tdk project" }), _jsx(Text, { children: " 2. Run: tdk resource api --type backend" }), _jsx(Box, { marginY: 1 }), _jsx(Text, { color: "cyan", children: "Press [r] to refresh or [q] to quit" }), message && (_jsx(Box, { paddingX: 1, height: 1, children: _jsxs(Text, { color: "cyan", children: ["\u2593\u2592\u2591 ", message, " \u2591\u2592\u2593"] }) }))] }));
 const TUIApp = () => {
     const { exit } = useApp();
     const { stdout } = useStdout();

package/cli/dist/commands/up.js

@@ -3,12 +3,14 @@ import { join } from "node:path";
 import chalk from "chalk";
 import { Command } from "commander";
 import { ensureProjectRuntimeAssets } from "../generator/template-engine.js";
+import { DEVCONTAINER_DOCKER_FIX, detectHost, isContainerHost, WEBCONTAINER_UP_MESSAGE, } from "../utils/agent-host.js";
 import { handleDryRun } from "../utils/command-helpers.js";
 import { completeEnvFile } from "../utils/env-validator.js";
 import { errorFactories, handleTiltFailure, requireProjectRoot, runCommand, showErrorAndExit, withTiltCheck, } from "../utils/errors.js";
 import { formatCount } from "../utils/formatting.js";
 import { exportHostPortPlan, getHostPortPlan, writeSavedHostPortPlan, } from "../utils/host-port-config.js";
 import { formatHostPortPlan } from "../utils/host-port-plan.js";
+import { createJsonEmitter } from "../utils/json-output.js";
 import { findProjectRoot } from "../utils/paths.js";
 import { findAvailablePort } from "../utils/port-assignment.js";
 import { isApiServiceType } from "../utils/resource-kind.js";
@@ -17,6 +19,7 @@ import { discoverResources, discoverStacks, getResourcesForStack, stackExists, }
 import { buildSmokePlans, formatSmokeFailure, runSmokePlans } from "../utils/smoke.js";
 import { buildTiltUpArgs, runTilt } from "../utils/tilt.js";
 import { stopTiltOnPort } from "../utils/tilt-process.js";
+import { waitForTiltResourcesReady } from "../utils/up-readiness.js";
 import { enableDiscoveredStacks } from "./project.js";
 export function formatUpSuccess(port, appUrls = []) {
     return [
@@ -34,6 +37,20 @@ export function nativeWindowsUpRefusal(platform, allowNativeWindows) {
         return null;
     return "Landscape startup needs Ubuntu on WSL2. Native Windows is inspect-only.";
 }
+/** Why `tdk up` cannot work on this host, or null when it may proceed. Docker reachability is only probed in container hosts. */
+export async function hostUpRefusal(host = detectHost(), dockerReachable = defaultDockerReachable) {
+    if (host.kind === "webcontainer")
+        return WEBCONTAINER_UP_MESSAGE;
+    if (isContainerHost(host.kind) && !(await dockerReachable()))
+        return DEVCONTAINER_DOCKER_FIX;
+    return null;
+}
+async function defaultDockerReachable() {
+    const { execFile } = await import("node:child_process");
+    return new Promise((resolve) => {
+        execFile("docker", ["ps"], { timeout: 10_000 }, (error) => resolve(!error));
+    });
+}
 function waitForTiltUi(port, timeoutMs = 30_000) {
     return new Promise((resolve) => {
         const deadline = Date.now() + timeoutMs;
@@ -64,7 +81,16 @@ export const upCommand = new Command("up")
     .option("-q, --quiet", "Suppress non-essential output", false)
     .option("--dry-run", "Show what would be started without starting", false)
     .option("-f, --force", "Kill existing Tilt process before starting", false)
+    .option("--json", "Print one JSON object on stdout when the stack is ready or the command fails; implies --quiet", false)
     .action(async (stackName, options) => {
+    const emit = options.json ? createJsonEmitter("UP_FAILED", "tdk up") : undefined;
+    if (options.json)
+        options.quiet = true;
+    const hostRefusal = options.dryRun ? null : await hostUpRefusal();
+    if (hostRefusal) {
+        emit?.({ ok: false }, [{ code: "HOST_UNSUPPORTED", message: hostRefusal }]);
+        showErrorAndExit(hostRefusal);
+    }
     const platformRefusal = nativeWindowsUpRefusal(process.platform, process.env.TDK_ALLOW_NATIVE_WINDOWS);
     if (platformRefusal)
         showErrorAndExit(platformRefusal);
@@ -152,6 +178,16 @@ export const upCommand = new Command("up")
             console.log(chalk.blue(formatHostPortPlan(hostPortPlan)));
             console.log(chalk.gray("Override with TDK_HTTP_PORT, TDK_HTTPS_PORT, or TDK_POSTGRES_PORT."));
         }
+        if (emit && options.dryRun) {
+            emit({
+                ok: true,
+                dryRun: true,
+                stack: stackName ?? null,
+                services: serviceNames,
+                command: dryRunCommand,
+            });
+            return;
+        }
         if (handleDryRun(options, "not starting services", dryRunCommand)) {
             return;
         }
@@ -191,7 +227,7 @@ export const upCommand = new Command("up")
             console.log(chalk.gray(`Using Tiltfile: .tdk/.tdk-out/Tiltfile`));
         }
         const tiltRun = runTilt("up", tiltArgs, {
-            verbose: options.verbose,
+            verbose: options.verbose && !options.json,
             quiet: options.quiet,
             inheritStdio: !options.quiet, // Suppress tilt output in quiet mode
         });
@@ -202,12 +238,29 @@ export const upCommand = new Command("up")
         let printedSuccess = false;
         const successOutput = (async () => {
             const uiReady = await waitForTiltUi(port);
+            // JSON consumers get success only after every non-deferred resource is built and running, not when the UI port opens.
+            let jsonReady = false;
+            if (uiReady && emit) {
+                const readiness = await waitForTiltResourcesReady(port);
+                if (readiness.ready) {
+                    jsonReady = true;
+                }
+                else {
+                    const detail = readiness.failures.map((f) => `${f.name}: ${f.message}`).join("; ");
+                    emit({ ok: false, tiltUrl: `http://localhost:${port}`, failures: readiness.failures }, [
+                        {
+                            code: readiness.timedOut ? "UP_TIMEOUT" : "UP_RESOURCE_FAILED",
+                            message: `${readiness.timedOut ? "Timed out waiting for resources" : "Resources failed"}${detail ? ` (${detail})` : ""}. Tilt is still running; inspect it or run: tdk down`,
+                        },
+                    ]);
+                }
+            }
             if (uiReady && !options.quiet) {
                 for (const line of formatUpSuccess(port))
                     console.log(chalk.blue(line));
                 printedSuccess = true;
             }
-            if (uiReady && smokePlans.length > 0) {
+            if (uiReady && smokePlans.length > 0 && (!emit || jsonReady)) {
                 if (!options.quiet) {
                     console.log(chalk.gray(`Smoke check: ${smokePlans.map((p) => p.name).join(", ")}`));
                 }
@@ -224,8 +277,20 @@ export const upCommand = new Command("up")
                         console.error(chalk.red(formatSmokeFailure(smokeResult)));
                     }
                 }
-                if (smokeFailed)
+                if (smokeFailed) {
                     stopTiltOnPort(port);
+                    emit?.({ ok: false }, [
+                        { code: "UP_SMOKE_FAILED", message: "A smoke check failed; Tilt was stopped" },
+                    ]);
+                }
+            }
+            if (uiReady && jsonReady && !smokeFailed) {
+                emit?.({
+                    ok: true,
+                    stack: stackName ?? null,
+                    services: serviceNames,
+                    tiltUrl: `http://localhost:${port}`,
+                });
             }
         })();
         const result = await tiltRun;

package/cli/dist/utils/agent-host.js

@@ -0,0 +1,35 @@
+import { existsSync } from "node:fs";
+export const WEBCONTAINER_DOCS = "docs/agent-hosts.md";
+export const WEBCONTAINER_UP_MESSAGE = `WebContainers cannot run TDK: there is no Docker daemon or Tilt. Run \`tdk up\` on a machine with Docker. See ${WEBCONTAINER_DOCS}.`;
+export const DEVCONTAINER_DOCKER_FIX = `Docker is not reachable from this Dev Container. Mount the host Docker socket (-v /var/run/docker.sock:/var/run/docker.sock) or add the docker-outside-of-docker feature to devcontainer.json, then retry. Docker-in-docker is not supported. See ${WEBCONTAINER_DOCS}.`;
+function defaultInputs() {
+    return {
+        env: process.env,
+        versions: process.versions,
+        platform: process.platform,
+        fileExists: existsSync,
+    };
+}
+/** Classify where the CLI is running. Informational: Docker reachability is still decided by the runtime checks. */
+export function detectHost(inputs = defaultInputs()) {
+    const { env, versions, platform, fileExists } = inputs;
+    if (versions.webcontainer) {
+        return { kind: "webcontainer", canUp: false };
+    }
+    if (env.CODESPACES === "true")
+        return { kind: "codespaces", canUp: true };
+    if (env.REMOTE_CONTAINERS || (fileExists("/.dockerenv") && env.DEVCONTAINER)) {
+        return { kind: "devcontainer", canUp: true };
+    }
+    // Mirrors nativeWindowsUpRefusal in commands/up.ts: native Windows is inspect-only unless explicitly overridden.
+    if (platform === "win32") {
+        return { kind: "native-windows", canUp: env.TDK_ALLOW_NATIVE_WINDOWS === "1" };
+    }
+    if (platform === "linux" && env.WSL_DISTRO_NAME)
+        return { kind: "wsl2", canUp: true };
+    return { kind: "local", canUp: true };
+}
+export function isContainerHost(kind) {
+    return kind === "devcontainer" || kind === "codespaces";
+}
+//# sourceMappingURL=agent-host.js.map

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

@@ -20,8 +20,12 @@ export async function collectDoctorChecks(machineChecks, projectChecks) {
     }
     return { checks, errors };
 }
+function containerRuntimeReachable(checks) {
+    const runtime = checks.find((check) => check.name === "Container Runtime");
+    return runtime ? runtime.didPass : null;
+}
 /** Produce the same readiness decision for human and machine consumers. */
-export function createDoctorReport(checks, inProject, errors = [], portPlan) {
+export function createDoctorReport(checks, inProject, errors = [], portPlan, host) {
     return {
         schemaVersion: 1,
         data: {
@@ -29,6 +33,15 @@ export function createDoctorReport(checks, inProject, errors = [], portPlan) {
                 checks.every((check) => check.didPass || check.isSkipped || check.isWarning),
             inProject,
             checks,
+            ...(host
+                ? {
+                    host: {
+                        ...host,
+                        containerRuntimeReachable: containerRuntimeReachable(checks),
+                        canUp: host.canUp && containerRuntimeReachable(checks) !== false,
+                    },
+                }
+                : {}),
             ...(portPlan !== undefined
                 ? {
                     ports: {

package/cli/dist/utils/json-output.js

@@ -0,0 +1,27 @@
+import { writeSync } from "node:fs";
+/**
+ * Returns an emitter that writes at most one `{schemaVersion, data, errors}` object to stdout. If the process
+ * exits before anything was emitted (a preflight `process.exit`, Tilt ending early), a failure object is written
+ * so a JSON consumer never sees an empty stdout. Uses writeSync because `process.exit` does not flush async writes.
+ */
+export function createJsonEmitter(failureCode, command) {
+    let emitted = false;
+    const emit = (data, errors = []) => {
+        if (emitted)
+            return;
+        emitted = true;
+        writeSync(1, `${JSON.stringify({ schemaVersion: 1, data, errors })}\n`);
+    };
+    process.once("exit", (code) => {
+        emit({ ok: false }, [
+            {
+                code: failureCode,
+                message: code === 0
+                    ? `${command} exited before reporting a result`
+                    : `${command} exited with code ${code}`,
+            },
+        ]);
+    });
+    return emit;
+}
+//# sourceMappingURL=json-output.js.map

package/cli/dist/utils/service-manifest.js

@@ -19,6 +19,7 @@ const KNOWN_SERVICE_FIELDS = new Set([
     "backendName",
     "basePath",
     "build",
+    "buildContext",
     "databaseName",
     "dependencies",
     "dev",

package/cli/dist/utils/status-ports.js

@@ -0,0 +1,32 @@
+import { STANDARD_PORTS } from "./constants.js";
+import { isApiServiceType } from "./resource-kind.js";
+import { resolveServicePath, resolveSubdomainBases } from "./service-urls.js";
+export function buildServicePorts(resource, ingressHttp) {
+    const appType = resource.config?.appType;
+    const routable = appType === "frontend" || isApiServiceType(appType);
+    let url = null;
+    if (routable) {
+        const { appBase, apiBase } = resolveSubdomainBases(ingressHttp);
+        url = `${isApiServiceType(appType) ? apiBase : appBase}${resolveServicePath(resource)}`;
+    }
+    return { url, containerPort: resource.port ?? resource.config?.port ?? null, hostPort: null };
+}
+/** Ports a client should forward or open: ingress, Tilt UI, and the published datastore. Not one per service. */
+export function buildStackPorts(plan, tiltPort) {
+    const ports = [];
+    if (plan) {
+        ports.push({ name: "ingress-http", hostPort: plan.ingressHttp, purpose: "Traefik HTTP ingress" }, { name: "ingress-https", hostPort: plan.ingressHttps, purpose: "Traefik HTTPS ingress" });
+    }
+    // `tdk up` may move Tilt off 10350 and records that only in its own process, so this is the default or TILT_PORT.
+    const validTiltPort = tiltPort !== undefined && Number.isInteger(tiltPort) && tiltPort > 0;
+    ports.push({
+        name: "tilt-ui",
+        hostPort: validTiltPort ? tiltPort : STANDARD_PORTS.tiltUi,
+        purpose: "Tilt UI",
+    });
+    if (plan) {
+        ports.push({ name: "postgres", hostPort: plan.postgres, purpose: "Published Postgres" });
+    }
+    return ports;
+}
+//# sourceMappingURL=status-ports.js.map

package/cli/dist/utils/up-readiness.js

@@ -0,0 +1,48 @@
+import { execFile } from "node:child_process";
+import { getDeferredResourceNames, parseTiltResourceFailures } from "./doctor-runtime.js";
+import { findOnPath } from "./which.js";
+function tiltGetUiResources(port) {
+    return new Promise((resolve) => {
+        execFile(findOnPath("tilt") ?? "tilt", ["get", "uiresources", "-o", "json", "--port", String(port)], { timeout: 15_000, maxBuffer: 16 * 1024 * 1024 }, (error, stdout) => resolve(error ? null : stdout));
+    });
+}
+/**
+ * Waits until every non-deferred Tilt resource is built and running. Resolves not-ready as soon as the rest has settled
+ * with an errored resource, or at the deadline. Sablier-deferred resources are excluded: they stay idle by design.
+ */
+export async function waitForTiltResourcesReady(port, options = {}) {
+    const timeoutMs = options.timeoutMs ?? Number(process.env.TDK_UP_READY_TIMEOUT_MS ?? 900_000);
+    const intervalMs = options.intervalMs ?? 2_000;
+    const fetchJson = options.fetchJson ?? tiltGetUiResources;
+    const deferred = options.deferred ?? getDeferredResourceNames();
+    const deadline = Date.now() + timeoutMs;
+    let last = { ready: false, failures: [], pending: 0, timedOut: false };
+    for (;;) {
+        const text = await fetchJson(port);
+        if (text) {
+            try {
+                const parsed = parseTiltResourceFailures(text, deferred);
+                last = {
+                    ready: parsed.failures.length === 0 && parsed.pendingCount === 0 && parsed.okCount > 0,
+                    failures: parsed.failures.map((failure) => ({
+                        name: failure.name,
+                        message: failure.error || `${failure.updateStatus}/${failure.runtimeStatus}`,
+                    })),
+                    pending: parsed.pendingCount,
+                    timedOut: false,
+                };
+                if (last.ready)
+                    return last;
+                if (last.failures.length > 0 && last.pending === 0)
+                    return last;
+            }
+            catch {
+                /* Tilt may emit partial output while starting; retry. */
+            }
+        }
+        if (Date.now() >= deadline)
+            return { ...last, ready: false, timedOut: true };
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+}
+//# sourceMappingURL=up-readiness.js.map

package/cli/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tdk-cli-internal",
   "private": true,
-  "version": "1.3.103",
+  "version": "1.3.105",
   "description": "TDK CLI — start services on your laptop.",
   "keywords": [
     "tdk",

package/discovery/manifest/loading.star

@@ -233,7 +233,12 @@ def _apply_manifest_defaults(manifest, resource_path):
     # Validate custom dockerfile exists if specified
     if 'dockerfile' in result:
         custom_dockerfile = result['dockerfile']
-        dockerfile_path = resource_path + '/' + custom_dockerfile
+        # With a bring-your-own buildContext the dockerfile is relative to that context.
+        build_context = result.get('buildContext')
+        if build_context and build_context != '.':
+            dockerfile_path = resource_path + '/' + build_context + '/' + custom_dockerfile
+        else:
+            dockerfile_path = resource_path + '/' + custom_dockerfile
         # BUG FIX: Run check from project root since Tilt may run from .tdk/.tdk-out/
         project_root = os.environ.get('TDK_PROJECT_ROOT', '')
         if project_root:

package/engine/schemas/service-schema.json

@@ -162,6 +162,10 @@
       "description": "Custom Dockerfile path relative to resource directory. Optional for bring-your-own type.",
       "type": "string"
     },
+    "buildContext": {
+      "description": "Docker build context for a bring-your-own resource, relative to the resource directory. Defaults to the resource directory. When set, dockerfile is relative to this context.",
+      "type": "string"
+    },
     "exposeViaProxy": {
       "description": "Whether this bring-your-own resource receives a Traefik route. Defaults to true.",
       "type": "boolean"

package/engine/topologies/platform/docker/compose/compose.star

@@ -207,6 +207,12 @@ def _generate_single_backend_entry(resource_path, resource_name, res, manifest,
             # context instead of the project root used by generated TDK apps.
             context_prefix = '/'.join(['..'] * (len(resource_path.split('/')) + 1))
             build_context = context_prefix + '/' + full_resource_path
+            # `buildContext` (relative to the service directory) moves the context
+            # to the source tree an imported Dockerfile lives in; `dockerfile` is then
+            # relative to that context, as in Compose.
+            custom_context = manifest.get('buildContext')
+            if custom_context and custom_context != '.':
+                build_context = build_context + '/' + custom_context
             dockerfile = manifest.get('dockerfile', 'Dockerfile')
             if dockerfile.startswith('./'):
                 dockerfile = dockerfile[2:]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tdk-landscape/tdk-cli-core",
-  "version": "1.3.103",
+  "version": "1.3.105",
   "description": "TDK CLI — start services on your laptop.",
   "homepage": "https://tdk-landscape.github.io/tdk-website",
   "repository": {