@tdk-landscape/tdk-cli-core 1.3.78 → 1.3.80

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

@@ -0,0 +1,40 @@
+/** Wait for concurrent probes to finish even if one throws, so they can release resources. */
+export async function collectDoctorChecks(machineChecks, projectChecks) {
+    const checks = [];
+    const errors = [];
+    const append = (result) => {
+        if (result.status === "fulfilled")
+            checks.push(result.value);
+        else
+            errors.push({
+                code: "INTERNAL",
+                message: result.reason instanceof Error ? result.reason.message : String(result.reason),
+            });
+    };
+    for (const result of await Promise.allSettled(machineChecks.map((check) => Promise.resolve().then(check)))) {
+        append(result);
+    }
+    for (const check of projectChecks) {
+        for (const result of await Promise.allSettled([Promise.resolve().then(check)]))
+            append(result);
+    }
+    return { checks, errors };
+}
+/** Produce the same readiness decision for human and machine consumers. */
+export function createDoctorReport(checks, inProject, errors = []) {
+    return {
+        schemaVersion: 1,
+        data: {
+            ready: errors.length === 0 &&
+                checks.every((check) => check.didPass || check.isSkipped || check.isWarning),
+            inProject,
+            checks,
+        },
+        errors,
+    };
+}
+/** 0: ready (warnings permitted), 1: blocking findings, 2: usage/internal failure. */
+export function getDoctorExitCode(report) {
+    return report.errors.length > 0 ? 2 : report.data.ready ? 0 : 1;
+}
+//# sourceMappingURL=doctor-report.js.map

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

@@ -376,10 +376,22 @@ function probeAddress(port, host) {
  * it before trying 127.0.0.1 avoids that self-collision on every platform.
  */
 export async function probeHostPort(port) {
-    const wildcard = await probeAddress(port, "0.0.0.0");
-    if (wildcard !== "free")
-        return wildcard;
-    return probeAddress(port, "127.0.0.1");
+    // Several `tdk project` E2E tests can run at once. Their preflight probes
+    // briefly bind the same port, so an EADDRINUSE can be another probe rather
+    // than a service. Retry once after those short-lived binds have closed.
+    for (let attempt = 0; attempt < 2; attempt++) {
+        const wildcard = await probeAddress(port, "0.0.0.0");
+        if (wildcard === "unknown")
+            return wildcard;
+        if (wildcard === "free") {
+            const loopback = await probeAddress(port, "127.0.0.1");
+            if (loopback === "free" || loopback === "unknown")
+                return loopback;
+        }
+        if (attempt === 0)
+            await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    return "in-use";
 }
 /** What an HTTP status from a service's health URL means, in the words a user needs. */
 function describeProbeFailure(probe) {

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

@@ -0,0 +1,62 @@
+import { createServer } from "node:net";
+const DEFAULT_RANGES = {
+    ingressHttp: { start: 8080, end: 8180 },
+    ingressHttps: { start: 8443, end: 8543 },
+    postgres: { start: 15432, end: 15532 },
+};
+const ENV_KEYS = {
+    ingressHttp: "TDK_HTTP_PORT",
+    ingressHttps: "TDK_HTTPS_PORT",
+    postgres: "TDK_POSTGRES_PORT",
+};
+async function isHostPortAvailable(port) {
+    return new Promise((resolve) => {
+        const server = createServer();
+        server.once("error", () => resolve(false));
+        // Docker Desktop and Windows publish these host ports through IPv4 loopback.
+        // Match that target instead of probing wildcard binds that may differ by OS.
+        server.listen(port, "127.0.0.1", () => server.close(() => resolve(true)));
+    });
+}
+function parsePort(name, value) {
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+        throw new Error(`${name} must be an integer between 1 and 65535 (received ${JSON.stringify(value)})`);
+    }
+    return port;
+}
+export async function createHostPortPlan(options = {}) {
+    const env = options.env ?? process.env;
+    const isAvailable = options.isAvailable ?? isHostPortAvailable;
+    const explicitFlags = { ingressHttp: false, ingressHttps: false, postgres: false };
+    const selected = { explicit: explicitFlags };
+    const reserved = new Set();
+    for (const key of ["ingressHttp", "ingressHttps", "postgres"]) {
+        const envValue = env[ENV_KEYS[key]];
+        const explicit = envValue !== undefined && envValue.trim() !== "";
+        const range = options.ranges?.[key] ?? DEFAULT_RANGES[key];
+        const candidates = explicit
+            ? [parsePort(ENV_KEYS[key], envValue)]
+            : Array.from({ length: range.end - range.start + 1 }, (_, index) => range.start + index);
+        let chosen;
+        for (const port of candidates) {
+            if (reserved.has(port))
+                continue;
+            if (await isAvailable(port)) {
+                chosen = port;
+                break;
+            }
+            if (explicit) {
+                throw new Error(`${ENV_KEYS[key]}=${port} is already in use. Choose a free host port and retry.`);
+            }
+        }
+        if (chosen === undefined) {
+            throw new Error(`No available host port in ${range.start}-${range.end} for ${key}. Set ${ENV_KEYS[key]} to a free port and retry.`);
+        }
+        reserved.add(chosen);
+        selected[key] = chosen;
+        explicitFlags[key] = explicit;
+    }
+    return selected;
+}
+//# sourceMappingURL=host-port-plan.js.map

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

@@ -0,0 +1,24 @@
+import { TdkError } from "./errors.js";
+export function createMachineEnvelope(data, errors = []) {
+    return { schemaVersion: 1, data, errors };
+}
+export function toMachineError(error) {
+    if (error instanceof TdkError) {
+        return { error: { code: "COMMAND_FAILED", message: error.message }, exitCode: 1 };
+    }
+    return {
+        error: {
+            code: "INTERNAL",
+            message: error instanceof Error ? error.message : String(error),
+        },
+        exitCode: 2,
+    };
+}
+/** Keep machine stdout parseable when a command fails before it has data to return. */
+export function writeMachineError(error) {
+    const result = toMachineError(error);
+    console.log(JSON.stringify(createMachineEnvelope(null, [result.error])));
+    console.error(result.error.message);
+    process.exit(result.exitCode);
+}
+//# sourceMappingURL=machine-output.js.map

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

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync } from "node:fs";
 export const SERVICE_MANIFEST_SCHEMA_VERSION = 1;
+export const SERVICE_MANIFEST_SCHEMA_URL = "https://tdk-landscape.github.io/schema.service.json";
 const KNOWN_SERVICE_FIELDS = new Set([
     "$schema",
     "apiBasePath",

package/cli/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tdk-cli-internal",
   "private": true,
-  "version": "1.3.78",
+  "version": "1.3.80",
   "description": "TDK CLI - Tilt Development Kit command line interface",
   "keywords": [
     "tdk",

package/engine/schemas/project-schema.json

@@ -0,0 +1,142 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://raw.githubusercontent.com/tdk-landscape/tdk-cli-core/main/engine/schemas/project-schema.json",
+  "title": "TDK Project Configuration",
+  "description": "Editor assistance for .tdk/project.json. TDK's CLI remains the runtime source of truth.",
+  "type": "object",
+  "additionalProperties": true,
+  "required": [
+    "version",
+    "project",
+    "phases",
+    "optional_infra",
+    "discovery"
+  ],
+  "properties": {
+    "version": {
+      "type": "string"
+    },
+    "project": {
+      "type": "object",
+      "additionalProperties": true,
+      "required": [
+        "name",
+        "version"
+      ],
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "version": {
+          "type": "string"
+        }
+      }
+    },
+    "phases": {
+      "type": "object",
+      "additionalProperties": true,
+      "required": [
+        "pre_alpha",
+        "alpha",
+        "beta",
+        "out_of_scope"
+      ],
+      "properties": {
+        "pre_alpha": {
+          "$ref": "#/definitions/phase"
+        },
+        "alpha": {
+          "$ref": "#/definitions/phase"
+        },
+        "beta": {
+          "$ref": "#/definitions/phase"
+        },
+        "out_of_scope": {
+          "$ref": "#/definitions/phase"
+        }
+      }
+    },
+    "stacks": {
+      "type": "object",
+      "additionalProperties": true
+    },
+    "always_enabled_infra": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "optional_infra": {
+      "type": "object",
+      "additionalProperties": true,
+      "required": [
+        "monitoring",
+        "elk",
+        "debezium",
+        "golden_image",
+        "verdaccio"
+      ],
+      "properties": {
+        "monitoring": {
+          "type": "boolean"
+        },
+        "elk": {
+          "type": "boolean"
+        },
+        "debezium": {
+          "type": "boolean"
+        },
+        "golden_image": {
+          "type": "boolean"
+        },
+        "verdaccio": {
+          "type": "boolean"
+        }
+      }
+    },
+    "discovery": {
+      "type": "object",
+      "additionalProperties": true,
+      "required": [
+        "paths"
+      ],
+      "properties": {
+        "paths": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "overrides": {
+      "type": "object",
+      "additionalProperties": true
+    }
+  },
+  "definitions": {
+    "phase": {
+      "type": "object",
+      "additionalProperties": true,
+      "required": [
+        "name",
+        "description",
+        "enabledStacks"
+      ],
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "description": {
+          "type": "string"
+        },
+        "enabledStacks": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        }
+      }
+    }
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tdk-landscape/tdk-cli-core",
-  "version": "1.3.78",
-  "description": "Run your whole microservice landscape locally without Kubernetes. Scaffold services and run them with hot reload, built on Tilt.",
+  "version": "1.3.80",
+  "description": "TDK runs many services on your laptop with Docker + Tilt. Helm still deploys the cluster.",
   "homepage": "https://tdk-landscape.github.io/tdk-website",
   "repository": {
     "type": "git",