@tdk-landscape/tdk-cli-core 1.3.147 → 1.3.149

package/CHANGELOG.md

@@ -4,6 +4,7 @@ Notable changes to the `tdk` CLI. Versions match [npm](https://www.npmjs.com/pac
 
 ## Unreleased
 
+- `healthCheckPath` is optional for `appType: "bring-your-own"` in `service.json`, so a service that is not HTTP (Postgres, Redis, MinIO, an SMTP relay) no longer needs a made-up `"/"` to validate. Without it TDK sends no HTTP probe to the service and gives its Traefik route no health check; the container counts as healthy once Docker reports it running. `port` stays required, and a set `healthCheckPath` behaves as before. Fixes #1086.
 - `tdk up` now publishes Traefik on host port 80 (and 443) when they are free, so routed URLs read `http://app.<project>.localhost/<app>` instead of `...localhost:8080/<app>`. It always wanted 80 but only ever tried 8080-8180. On macOS the free-port check treated the kernel's refusal of a non-root bind below 1024 as "busy", although Docker Desktop publishes those ports itself; that also made `TDK_HTTP_PORT=80` fail with "already in use". A project whose saved plan is on 8080 moves to 80 on its next `tdk up` once 80 is free. On Linux and WSL2 a non-root user cannot check port 80, so the 8080-8180 range is kept there. Printed URLs no longer end in `:80`.
 - TDK MCP tools now accept an absolute `projectPath` so a projectless MCP client can run doctor, inspect services and logs, and manage the intended project without depending on the server launch directory.
 - Shared platform stacks (postgres, traefik, proxy, messaging, infisical, monitoring, cdc, elk) now run in Compose projects named `<project>-<stack>` (for example `tdk-erp-system-database-management`) instead of the directory-named `database-management`, `tdk-out` and so on. Two TDK projects on one Docker daemon no longer share them.

package/cli/dist/commands/doctor.js

@@ -18,7 +18,7 @@ import { checkDockerNetworkCapacity, checkDuplicateResourceNames, checkDuplicate
 import { validateEnvFile } from "../utils/env-validator.js";
 import { execAsync, isExecTimeout } from "../utils/exec-async.js";
 import { formatCount } from "../utils/formatting.js";
-import { getHostPortPlan } from "../utils/host-port-config.js";
+import { getHostPortPlan, resolveRuntimeIngressPort } from "../utils/host-port-config.js";
 import { createHostPortPlan } from "../utils/host-port-plan.js";
 import { findProjectRoot, getPackageVersion } from "../utils/paths.js";
 import { EnvUnreadableError, envSecretValues, redactSecrets, redactValue, } from "../utils/secret-redaction.js";
@@ -137,17 +137,25 @@ function isTimeout(err) {
     return isExecTimeout(err);
 }
 function createExecCheck(name, command, successMessage, failureMessage, fixInstructions) {
-    return async () => {
+    return async (exec = execAsync) => {
         try {
-            await execAsync(command, EXEC_TIMEOUT_MS);
+            await exec(command, EXEC_TIMEOUT_MS);
             return {
                 name,
                 didPass: true,
                 message: successMessage,
             };
         }
-        catch {
-            // Error details not needed - failure message tells user what to fix
+        catch (err) {
+            // A timeout means the command exists but did not answer in time, which is not the same as missing.
+            if (isTimeout(err)) {
+                return {
+                    name,
+                    didPass: false,
+                    message: `${name} did not respond within ${EXEC_TIMEOUT_MS / 1000}s`,
+                    fix: fixInstructions,
+                };
+            }
             return {
                 name,
                 didPass: false,
@@ -1131,9 +1139,13 @@ export const doctorCommand = new Command("doctor")
     ];
     // Runs last: needs routable services (and working Traefik) to mean anything.
     if (options.ping) {
-        projectChecks.push(() => checkServiceHealth(pingTimeout, hostPortPlan?.ingressHttp));
-        projectChecks.push(() => checkServiceSmoke(pingTimeout, hostPortPlan?.ingressHttp));
-        projectChecks.push(() => checkAdvertisedEndpoints(pingTimeout, hostPortPlan?.ingressHttp));
+        // Probe the port a running stack is actually on, not the one the next `tdk up` would pick.
+        const pingPort = projectRoot
+            ? resolveRuntimeIngressPort(projectRoot, hostPortPlan?.ingressHttp)
+            : hostPortPlan?.ingressHttp;
+        projectChecks.push(() => checkServiceHealth(pingTimeout, pingPort));
+        projectChecks.push(() => checkServiceSmoke(pingTimeout, pingPort));
+        projectChecks.push(() => checkAdvertisedEndpoints(pingTimeout, pingPort));
     }
     // Right after installing, people run `tdk doctor` before they have a
     // project. Only the machine checks mean anything there; the project checks

package/cli/dist/commands/import.js

@@ -3,10 +3,11 @@
 import { spawn } from "node:child_process";
 import { Command } from "commander";
 /**
- * The importer lives in its own repo so detectors can ship without a CLI release. Until it is
- * published to npm it is run from git; `TDK_IMPORT_PACKAGE` overrides the package spec.
+ * The importer lives in its own repo so it can ship without a CLI release, and is run from npm at a
+ * pinned version so a push to its main branch cannot change what `tdk import` does. Move the pin
+ * when a new importer is published. `TDK_IMPORT_PACKAGE` overrides the package spec.
  */
-export const IMPORT_PACKAGE = "github:tdk-landscape/tdk-import";
+export const IMPORT_PACKAGE = "@tdk-landscape/tdk-import@0.2.1";
 export function importInvocation(args, env = process.env, platform = process.platform) {
     const pkg = env.TDK_IMPORT_PACKAGE || IMPORT_PACKAGE;
     return {
@@ -31,8 +32,8 @@ export function runImport(args, spawnFn = spawn) {
     });
 }
 export const importCommand = new Command("import")
-    .description("Import the services a directory describes (runs tdk-import)")
-    .argument("[args...]", "Passed to tdk-import: [dir] --dry-run --yes --force --only <ids>")
+    .description("Import the services in a directory's root docker-compose.yml (runs tdk-import)")
+    .argument("[args...]", "Passed to tdk-import: [dir] --dry-run --yes --force")
     .allowUnknownOption()
     .helpOption(false)
     .action(async (args) => {

package/cli/dist/commands/status.js

@@ -10,6 +10,7 @@ import { getHostPortPlan } from "../utils/host-port-config.js";
 import { createMachineEnvelope, writeMachineError } from "../utils/machine-output.js";
 import { findProjectRoot } from "../utils/paths.js";
 import { deriveServiceStates } from "../utils/service-runtime-state.js";
+import { groupSharedPostgres, readProjectName } from "../utils/shared-infra.js";
 import { buildServicePorts, buildStackPorts } from "../utils/status-ports.js";
 import { isTiltAvailable, runTilt } from "../utils/tilt.js";
 import { getTiltPollingPort } from "../utils/tilt-startup.js";
@@ -25,6 +26,11 @@ export const statusCommand = new Command("status")
     const action = async () => {
         // Discover first: outside a project this fails before any status line is printed.
         const discovery = createDiscoveryContext();
+        const projectRoot = findProjectRoot();
+        const projectName = projectRoot ? readProjectName(projectRoot) : null;
+        const sharedInfraGroup = projectName
+            ? groupSharedPostgres(projectName, discovery.stacks)
+            : null;
         let tiltAvailable = false;
         try {
             tiltAvailable = await isTiltAvailable();
@@ -121,6 +127,7 @@ export const statusCommand = new Command("status")
                     resources: stack.resources.map((resource) => resource.name),
                 })),
                 unassignedResources: discovery.unassignedResources.map((resource) => resource.name),
+                sharedInfra: sharedInfraGroup,
             };
             console.log(JSON.stringify(createMachineEnvelope(data, errors)));
             if (errors.length > 0) {
@@ -151,6 +158,14 @@ export const statusCommand = new Command("status")
                 }
             }
         }
+        if (sharedInfraGroup) {
+            console.log();
+            console.log(chalk.bold("Shared infrastructure:"));
+            showDetail(`${sharedInfraGroup.name} (one instance, ${formatCount(sharedInfraGroup.databases.length, "database")})`);
+            for (const database of sharedInfraGroup.databases) {
+                showDetail(`  ${database.name} (stack ${database.stack}): ${database.services.join(", ")}`);
+            }
+        }
         if (serviceStates && Object.keys(serviceStates).length > 0) {
             console.log();
             console.log(chalk.bold("Services:"));

package/cli/dist/components/BaseTooltip.js

@@ -10,12 +10,12 @@ export const BaseTooltip = ({ content, shortcut, visible, maxWidth = 40, wrapTex
     const lines = wrapText ? wrapContent(content, maxWidth) : [content];
     return (_jsxs(Box, { flexDirection: "column", borderStyle: theme.ascii ? undefined : "single", borderColor: theme.warning, paddingX: 1, paddingY: 1, backgroundColor: theme.ascii ? undefined : "black", marginTop: marginTop, children: [lines.map((line, i) => (_jsxs(Text, { color: theme.warning, bold: theme.highContrast, children: [prefix, line] }, i))), shortcut && (_jsxs(Box, { marginTop: 1, children: [_jsx(Text, { color: theme.muted, children: "Press " }), _jsx(Text, { color: theme.accent, bold: true, children: shortcut.startsWith("[") ? shortcut : `[${shortcut}]` }), _jsx(Text, { color: theme.muted, children: " to use" })] }))] }));
 };
-function wrapContent(content, maxWidth) {
+export function wrapContent(content, maxWidth) {
     const words = content.split(" ");
     const lines = [];
     let currentLine = "";
     for (const word of words) {
-        if ((currentLine + word).length > maxWidth - 2) {
+        if (currentLine && (currentLine + word).length > maxWidth - 2) {
             lines.push(currentLine.trim());
             currentLine = `${word} `;
         }

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

@@ -518,8 +518,8 @@ export function summarizeAdvertisedProbes(probes) {
         name: "Advertised Endpoints",
         didPass: true,
         isWarning: true,
-        message: `${formatCount(dead.length, "advertised link")} returns 404:\n    ${details}`,
-        fix: 'Nothing handles this path, so the link is dead. Add a route for it, or declare a read-only "smoke" step on a real route in service.json. The URL tdk networks and the TDK App print stays the same until the CLI changes how it reports it.',
+        message: `${formatCount(dead.length, "advertised link")} ${dead.length === 1 ? "returns" : "return"} 404 (the service may be healthy, but nothing answers at this exact path):\n    ${details}`,
+        fix: 'Nothing handles this exact path, so opening the link shows a 404 even when /health is fine. If this API has no root route, you can leave it. Otherwise add a GET route for it (for example one that returns the service name), or declare a read-only "smoke" step on a real route in service.json. The URL tdk networks and the TDK App print stays the same until the CLI changes how it reports it.',
     };
 }
 /**

package/cli/dist/utils/host-port-config.js

@@ -1,8 +1,8 @@
 // Copyright (c) 2026 TDK Landscape contributors
 // SPDX-License-Identifier: MIT
 import { execFileSync } from "node:child_process";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { join, resolve, sep } from "node:path";
 import { PROJECT_JSON } from "./constants.js";
 import { createHostPortPlan, isHostPortAvailable, PREFERRED_HOST_PORTS, } from "./host-port-plan.js";
 const CONFIG_PATH = join(".tdk", ".tdk-out", "host-ports.json");
@@ -47,6 +47,47 @@ export function exportHostPortPlan(plan) {
     process.env.TDK_HTTPS_PORT = String(plan.ingressHttps);
     process.env.TDK_POSTGRES_PORT = String(plan.postgres);
 }
+const COMPOSE_WORKING_DIR_LABEL = "com.docker.compose.project.working_dir";
+/**
+ * True when a container whose Compose working directory is inside this project publishes the port. A container-name prefix is not
+ * enough: tdk_shop_ also matches the containers of a different project called tdk-shop-extra. Compose records the directory each
+ * project was started from, so that identifies the project exactly. Containers without the label never count.
+ */
+export function isPortHeldByProjectContainers(dockerPs, projectRoot, port) {
+    const roots = new Set([resolve(projectRoot)]);
+    try {
+        roots.add(realpathSync(projectRoot));
+    }
+    catch {
+        // The project root is already known to exist; keep the unresolved path.
+    }
+    return dockerPs.split("\n").some((line) => {
+        const [, ports = "", workingDir = ""] = line.split("|");
+        if (!workingDir || !ports.includes(`:${port}->`))
+            return false;
+        return [...roots].some((root) => workingDir === root || workingDir.startsWith(`${root}${sep}`));
+    });
+}
+/**
+ * The HTTP ingress port to probe while a stack is running. getHostPortPlan moves a saved fallback port (8080) back to the
+ * preferred one (80) as soon as that is free, which is right for the next `tdk up` but wrong for a running stack: Traefik is still
+ * bound to the saved port, so probing the planned one finds nothing and every runtime check is skipped. When this project's own
+ * containers hold the saved port, probe that one.
+ */
+export function resolveRuntimeIngressPort(projectRoot, plannedPort, readDockerPs = () => execFileSync("docker", ["ps", "--format", `{{.Names}}|{{.Ports}}|{{.Label "${COMPOSE_WORKING_DIR_LABEL}"}}`], { encoding: "utf-8", timeout: 5000 })) {
+    const saved = readSavedHostPortPlan(projectRoot);
+    if (!saved || saved.ingressHttp === plannedPort)
+        return plannedPort;
+    try {
+        if (isPortHeldByProjectContainers(readDockerPs(), projectRoot, saved.ingressHttp)) {
+            return saved.ingressHttp;
+        }
+    }
+    catch {
+        // Docker unavailable: keep the planned port.
+    }
+    return plannedPort;
+}
 /** Reuse this project's last selection when its ports are still free or held by its own containers. */
 export async function getHostPortPlan(projectRoot, options = {}) {
     const saved = readSavedHostPortPlan(projectRoot);

package/cli/dist/utils/shared-infra.js

@@ -0,0 +1,45 @@
+// Copyright (c) 2026 TDK Landscape contributors
+// SPDX-License-Identifier: MIT
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { DATABASE_MANAGEMENT_FEATURE, PROJECT_JSON } from "./constants.js";
+import { POSTGRES_DEPENDENCY_NAMES } from "./shared-platform-postgres.js";
+/** A resource uses the shared database when its features or dependsOn ask for it. */
+export function usesSharedPostgres(resource) {
+    const config = resource.config;
+    if (!config)
+        return false;
+    // service.json is not type-checked here, so a malformed value must not throw inside `tdk status`.
+    if (Array.isArray(config.featuresEnabled) &&
+        config.featuresEnabled.includes(DATABASE_MANAGEMENT_FEATURE))
+        return true;
+    const dependsOn = Array.isArray(config.dependsOn) ? config.dependsOn : [];
+    return dependsOn.some((name) => POSTGRES_DEPENDENCY_NAMES.includes(name));
+}
+export function groupSharedPostgres(projectName, stacks) {
+    const prefix = projectName.replace(/-/g, "_");
+    const databases = [];
+    for (const stack of [...stacks].sort((a, b) => a.name.localeCompare(b.name))) {
+        const services = stack.resources.filter(usesSharedPostgres).map((resource) => resource.name);
+        if (services.length === 0)
+            continue;
+        databases.push({
+            name: `${prefix}_${stack.name.replace(/-/g, "_")}`,
+            stack: stack.name,
+            services: services.sort(),
+        });
+    }
+    if (databases.length === 0)
+        return null;
+    return { name: "postgres", databases };
+}
+/** `project.name` from `.tdk/project.json`, or null when the project file is missing or unreadable. */
+export function readProjectName(projectRoot) {
+    try {
+        const parsed = JSON.parse(readFileSync(join(projectRoot, ".tdk", PROJECT_JSON), "utf-8"));
+        return typeof parsed?.project?.name === "string" ? parsed.project.name : null;
+    }
+    catch {
+        return null;
+    }
+}