@tdk-landscape/tdk-cli-core 1.3.120 → 1.3.122

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

@@ -2,11 +2,13 @@ import { execFileSync, execSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { createServer } from "node:net";
 import { join } from "node:path";
+import { STANDARD_PORTS } from "./constants.js";
 import { formatCount } from "./formatting.js";
 import { findProjectRoot } from "./paths.js";
 import { isApiServiceType } from "./resource-kind.js";
 import { getProjectName } from "./service-urls.js";
 import { discoverResources, discoverResourcesFromRoot } from "./services.js";
+import { isTiltResourcePending } from "./tilt-resource-state.js";
 import { findOnPath } from "./which.js";
 const EXEC_TIMEOUT_MS = 10_000;
 const REGISTRY_PROBE_TIMEOUT_MS = 3_000;
@@ -119,11 +121,7 @@ export function parseTiltResourceFailures(jsonText, deferredNames = new Set()) {
             okCount += 1;
             continue;
         }
-        if (name !== "(Tiltfile)" &&
-            (updateStatus === "pending" ||
-                runtimeStatus === "pending" ||
-                updateStatus === "none" ||
-                runtimeStatus === "none")) {
+        if (name !== "(Tiltfile)" && isTiltResourcePending(updateStatus, runtimeStatus)) {
             if (deferredNames.has(name)) {
                 deferredCount += 1;
             }
@@ -593,7 +591,9 @@ export function checkTiltResourceHealth(exec = execSync) {
     const hasRegistryFailure = ordered.some((failure) => isRegistryRelatedBuildError(failure.error) ||
         isRegistryRelatedBuildError(summarizeTiltBuildError(failure.error)));
     const hasKafkaRuntimeFailure = described.some(({ why }) => /Kafka broker unreachable|kafka:9092/i.test(why));
-    let fix = "Open http://localhost:10350, inspect the red resources, fix the listed errors, then `tilt trigger <resource>` or re-run `tdk up`.";
+    let fix = "Open the Tilt UI URL printed by tdk up (default port " +
+        STANDARD_PORTS.tiltUi +
+        " when TILT_PORT is unset), inspect the red resources, fix the listed errors, then `tilt trigger <resource>` or re-run `tdk up`.";
     if (hasPortConflict) {
         fix =
             "Free the conflicting host port (usually 80/443): `docker ps --filter publish=80` then `docker stop <other-traefik>`. Re-trigger Traefik in the Tilt UI or run `tdk up` again.";

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

@@ -1,6 +1,6 @@
 import { execFileSync, execSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join, relative } from "node:path";
+import { basename, dirname, join, relative } from "node:path";
 import { BACKEND_LANGUAGES } from "../backend-languages/registry.js";
 import { execAsync } from "./exec-async.js";
 import { formatCount } from "./formatting.js";
@@ -328,6 +328,67 @@ function listSourceFiles(dir) {
 }
 const LOCALHOST_PORT = /(?:localhost|127\.0\.0\.1):(\d{2,5})\b/g;
 const COMMENT_LINE = /^\s*(?:\/\/|\/\*|\*|<!--|#)/;
+/**
+ * Two API backends in one stack used to share the stack-scoped Traefik routers (`/api/<stack>-management`), so the same rule
+ * matched both and Traefik chose between them arbitrarily. The engine now counts the routable backends of a stack inside one
+ * service directory (the same grouping as here: resources in one directory that name the same stack). When there are two or more,
+ * it drops the stack routers for all of them. A backend that sets its own `traefik.host` / `traefik.pathPrefix` keeps a router
+ * for just that route; the others are left with `/api/<name>` only. This check warns about the backends that lose the stack path
+ * and about two backends that set the same explicit route.
+ */
+export function checkSharedStackRoutes(projectRoot = findProjectRoot() ?? process.cwd()) {
+    const groups = new Map();
+    for (const resource of discoverResourcesFromRoot(projectRoot)) {
+        const config = resource.config;
+        const routable = isApiServiceType(config?.appType) ||
+            (config?.appType === "bring-your-own" && config.exposeViaProxy !== false);
+        if (!routable)
+            continue;
+        const directory = dirname(resource.path);
+        const stack = config?.stack ?? basename(directory);
+        const key = `${directory}\0${stack}`;
+        const group = groups.get(key) ?? { stack, resources: [] };
+        group.resources.push(resource);
+        groups.set(key, group);
+    }
+    const problems = [];
+    for (const { stack, resources } of groups.values()) {
+        if (resources.length < 2)
+            continue;
+        const explicit = (resource) => Boolean(resource.config?.traefik?.host || resource.config?.traefik?.pathPrefix);
+        const lost = resources.filter((resource) => !explicit(resource)).map((r) => r.name);
+        if (lost.length > 0) {
+            problems.push(`stack "${stack}": ${lost.sort().join(", ")} lose the shared /api/${stack}-management route because ${resources.length} backends share the stack; they are routed at /api/<name> only`);
+        }
+        for (const field of ["host", "pathPrefix"]) {
+            const byValue = new Map();
+            for (const resource of resources) {
+                const value = resource.config?.traefik?.[field];
+                if (value)
+                    byValue.set(value, [...(byValue.get(value) ?? []), resource.name]);
+            }
+            for (const [value, names] of byValue) {
+                if (names.length > 1) {
+                    problems.push(`stack "${stack}": ${names.sort().join(" and ")} both set traefik.${field} "${value}", so Traefik cannot tell them apart`);
+                }
+            }
+        }
+    }
+    if (problems.length === 0) {
+        return {
+            name: "Stack API routes",
+            didPass: true,
+            message: "No two backends in one service directory compete for one stack route",
+        };
+    }
+    return {
+        name: "Stack API routes",
+        didPass: false,
+        isWarning: true,
+        message: problems.join("\n    "),
+        fix: 'Call each backend at /api/<name>, move one backend to its own stack, or give each its own "traefik.pathPrefix" in service.json',
+    };
+}
 export function checkFrontendBackendUrls(projectRoot = findProjectRoot() ?? process.cwd()) {
     const resources = discoverResourcesFromRoot(projectRoot);
     const byPort = new Map([...backendPorts(resources)].map(([name, port]) => [port, name]));

package/cli/dist/utils/errors.js

@@ -2,6 +2,7 @@ import chalk from "chalk";
 import { QUICKSTART_DOCS_URL } from "./constants.js";
 import { getContainerRuntimeStatus } from "./docker.js";
 import { findProjectRoot } from "./paths.js";
+import { suggestClosest } from "./suggestions.js";
 import { isTiltAvailable } from "./tilt.js";
 export function getErrorMessage(err) {
     return err instanceof Error ? err.message : String(err);
@@ -30,6 +31,16 @@ export class TdkError extends Error {
         process.exit(this.exitCode);
     }
 }
+function closestNameSuggestions(names, candidates, includeInput = false) {
+    const suggestions = new Set();
+    for (const name of names) {
+        const closest = suggestClosest(name, candidates);
+        if (closest) {
+            suggestions.add(includeInput ? `Did you mean "${closest}" for "${name}"?` : `Did you mean "${closest}"?`);
+        }
+    }
+    return [...suggestions];
+}
 export const errorFactories = {
     tiltNotInstalled: () => new TdkError("Tilt CLI is not installed", [
         "Install Tilt: `brew install tilt` (macOS)",
@@ -47,14 +58,21 @@ export const errorFactories = {
         "Quit and reopen Docker Desktop, or run `colima restart`",
         "Then verify with: `docker ps`",
     ]),
-    stackNotFound: (name) => new TdkError(`Stack "${name}" not found`, [
+    stackNotFound: (name, stackNames = []) => new TdkError(`Stack "${name}" not found`, [
+        ...closestNameSuggestions([name], stackNames),
         "Run `tdk stacks` to see available stacks",
         "Run `tdk stack` to assign resources to a stack",
     ]),
-    resourceNotFound: (name) => new TdkError(`Resource "${name}" not found`, [
+    resourceNotFound: (name, resourceNames = []) => new TdkError(`Resource "${name}" not found`, [
+        ...closestNameSuggestions([name], resourceNames),
         "Run `tdk resources` to list all resources",
         "Check the resource name spelling",
     ]),
+    unknownServices: (names, validNames) => {
+        // Service selectors are Tilt resource names, so share the resource suggestion path.
+        const suggestions = closestNameSuggestions(names, validNames, names.length > 1);
+        return new TdkError(`Unknown service ${names.join(", ")}. Valid names: ${validNames.join(", ")}`, suggestions, 2);
+    },
     directoryExists: (path) => new TdkError(`Directory already exists: ${path}`, [
         "Use `--path` to specify a different location",
         "Remove the existing directory if no longer needed",

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

@@ -1,4 +1,5 @@
 import { createServer } from "node:net";
+import { hasLocalListener } from "./port-listener-probe.js";
 export const DEFAULT_HOST_PORT_RANGES = {
     ingressHttp: { start: 8080, end: 8180 },
     ingressHttps: { start: 8443, end: 8543 },
@@ -11,6 +12,8 @@ const ENV_KEYS = {
 };
 const REQUESTED_PORTS = { ingressHttp: 80, ingressHttps: 443, postgres: 5432 };
 export async function isHostPortAvailable(port) {
+    if (await hasLocalListener(port))
+        return false;
     return new Promise((resolve) => {
         const server = createServer();
         server.once("error", () => resolve(false));

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

@@ -4,7 +4,14 @@ export function createMachineEnvelope(data, errors = []) {
 }
 export function toMachineError(error) {
     if (error instanceof TdkError) {
-        return { error: { code: "COMMAND_FAILED", message: error.message }, exitCode: 1 };
+        return {
+            error: {
+                code: "COMMAND_FAILED",
+                message: error.message,
+                ...(error.suggestions.length > 0 ? { suggestions: error.suggestions } : {}),
+            },
+            exitCode: error.exitCode,
+        };
     }
     return {
         error: {

package/cli/dist/utils/port-conflict-fix.js

@@ -0,0 +1,24 @@
+/** The env var that moves each host port TDK publishes. Services publish no host ports, so only these conflict. */
+const PORT_ENV_VARS = {
+    "80": "TDK_HTTP_PORT",
+    "443": "TDK_HTTPS_PORT",
+    "5432": "TDK_POSTGRES_PORT",
+};
+/**
+ * The next step for a host port another process already holds. The occupant is not named: finding it needs the OS, so
+ * the command that finds it is given instead.
+ */
+export function portConflictFix(message) {
+    // The raw Docker error can reach the report when the readiness check fails before the summary runs.
+    const match = message.match(/^host port (\d+) is already allocated$/) ??
+        message.match(/Bind for [^ ]+:(\d+) failed: port is already allocated/i);
+    if (!match)
+        return null;
+    const port = match[1];
+    const find = `find it with: lsof -nP -iTCP:${port} -sTCP:LISTEN`;
+    const envVar = PORT_ENV_VARS[port];
+    if (!envVar)
+        return `Fix: stop the process using port ${port} (${find})`;
+    return `Fix: stop the process using port ${port} (${find}), or set ${envVar} to a free port and run tdk up`;
+}
+//# sourceMappingURL=port-conflict-fix.js.map

package/cli/dist/utils/port-fallback-notice.js

@@ -0,0 +1,18 @@
+const PORT_KEYS = [
+    { key: "ingressHttp", label: "HTTP", env: "TDK_HTTP_PORT" },
+    { key: "ingressHttps", label: "HTTPS", env: "TDK_HTTPS_PORT" },
+    { key: "postgres", label: "Postgres", env: "TDK_POSTGRES_PORT" },
+];
+/** One line per port TDK moved off the one it wanted. Ports the user set explicitly are never listed. */
+export function formatPortFallbackNotice(plan) {
+    const lines = [];
+    for (const { key, label, env } of PORT_KEYS) {
+        const requested = plan.requested[key];
+        const chosen = plan[key];
+        if (plan.explicit[key] || chosen === requested)
+            continue;
+        lines.push(`${label}: wanted ${requested}, using ${chosen} (${plan.reason[key]}). To force ${requested}: ${env}=${requested} tdk up`);
+    }
+    return lines;
+}
+//# sourceMappingURL=port-fallback-notice.js.map

package/cli/dist/utils/port-listener-probe.js

@@ -0,0 +1,19 @@
+import { connect } from "node:net";
+/**
+ * True when something already accepts connections on 127.0.0.1:port. Binding a socket to find out is not enough:
+ * on macOS a bind on 127.0.0.1 succeeds even while another process listens on the same port, so a busy port such as
+ * 5432 looked free and `tdk doctor` passed before Docker failed to publish it.
+ */
+export function hasLocalListener(port, timeoutMs = 500) {
+    return new Promise((resolve) => {
+        const socket = connect({ port, host: "127.0.0.1" });
+        const finish = (result) => {
+            socket.destroy();
+            resolve(result);
+        };
+        socket.setTimeout(timeoutMs, () => finish(false));
+        socket.once("connect", () => finish(true));
+        socket.once("error", () => finish(false));
+    });
+}
+//# sourceMappingURL=port-listener-probe.js.map

package/cli/dist/utils/secret-redaction.js

@@ -0,0 +1,55 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { parseEnv } from "./env-validator.js";
+export const REDACTED = "[REDACTED]";
+export class EnvUnreadableError extends Error {
+    path;
+    constructor(path, reason) {
+        super(`Could not read ${path}: ${reason}`);
+        this.path = path;
+        this.name = "EnvUnreadableError";
+    }
+}
+/**
+ * Shorter values are left alone: masking a two-letter value would hit ordinary words in every log line. The cost is
+ * that a short secret in .env is not masked, so keep real secrets at least this long.
+ */
+export const MIN_REDACTED_VALUE_LENGTH = 8;
+/**
+ * Values of the project's own .env file, longest first so a value that contains another is masked whole. Throws when the
+ * file exists but cannot be read: continuing without the values would print secrets unmasked.
+ */
+export function envSecretValues(projectRoot) {
+    const envPath = join(projectRoot, ".env");
+    if (!existsSync(envPath))
+        return [];
+    let content;
+    try {
+        content = readFileSync(envPath, "utf-8");
+    }
+    catch (error) {
+        throw new EnvUnreadableError(envPath, error instanceof Error ? error.message : String(error));
+    }
+    const values = [...parseEnv(content).values()].filter((value) => value.length >= MIN_REDACTED_VALUE_LENGTH);
+    return [...new Set(values)].sort((a, b) => b.length - a.length);
+}
+export function redactSecrets(text, secrets) {
+    let result = text;
+    for (const secret of secrets)
+        result = result.split(secret).join(REDACTED);
+    return result;
+}
+/** Redacts every string inside a JSON-shaped value, so the output stays valid JSON. */
+export function redactValue(value, secrets) {
+    if (secrets.length === 0)
+        return value;
+    if (typeof value === "string")
+        return redactSecrets(value, secrets);
+    if (Array.isArray(value))
+        return value.map((item) => redactValue(item, secrets));
+    if (value !== null && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactValue(item, secrets)]));
+    }
+    return value;
+}
+//# sourceMappingURL=secret-redaction.js.map

package/cli/dist/utils/service-config-checks.js

@@ -0,0 +1,188 @@
+import { relative } from "node:path";
+import chalk from "chalk";
+import { checkDuplicateResourceNames } from "./doctor-wiring.js";
+import { formatCount } from "./formatting.js";
+import { findProjectRoot } from "./paths.js";
+import { SERVICE_MANIFEST_SCHEMA_VERSION } from "./service-manifest.js";
+import { discoverResourcesFromRoot } from "./services.js";
+function filePath(projectRoot, resource) {
+    return relative(projectRoot, resource.configPath) || resource.configPath;
+}
+/** The dependsOn names a service declares: none when absent, null when it is not an array of strings. */
+function declaredDependsOn(resource) {
+    const value = resource.config?.dependsOn;
+    if (value === undefined)
+        return [];
+    if (Array.isArray(value) && value.every((entry) => typeof entry === "string"))
+        return value;
+    return null;
+}
+/** Each cycle once, as service names starting from the alphabetically first, ending where it started. */
+function findDependencyCycles(resources) {
+    const known = new Set(resources.map((r) => r.name));
+    const edges = new Map(resources.map((r) => [r.name, (declaredDependsOn(r) ?? []).filter((dep) => known.has(dep))]));
+    const cycles = new Map();
+    const state = new Map();
+    const stack = [];
+    const visit = (name) => {
+        state.set(name, "visiting");
+        stack.push(name);
+        for (const dep of edges.get(name) ?? []) {
+            if (state.get(dep) === "visiting") {
+                const loop = stack.slice(stack.indexOf(dep));
+                const start = loop.indexOf([...loop].sort()[0] ?? dep);
+                const ordered = [...loop.slice(start), ...loop.slice(0, start)];
+                cycles.set(ordered.join(">"), [...ordered, ordered[0] ?? dep]);
+            }
+            else if (!state.has(dep)) {
+                visit(dep);
+            }
+        }
+        stack.pop();
+        state.set(name, "done");
+    };
+    for (const name of [...edges.keys()].sort()) {
+        if (!state.has(name))
+            visit(name);
+    }
+    return [...cycles.values()];
+}
+/** A dependsOn that is not a list of service names cannot be followed, so say so instead of failing later. */
+export function checkDependsOnShape(projectRoot = findProjectRoot() ?? process.cwd()) {
+    const problems = discoverResourcesFromRoot(projectRoot).flatMap((resource) => declaredDependsOn(resource) === null
+        ? [
+            `${filePath(projectRoot, resource)} dependsOn ${JSON.stringify(resource.config?.dependsOn)}: expected an array of service names`,
+        ]
+        : []);
+    if (problems.length === 0) {
+        return {
+            name: "dependsOn",
+            didPass: true,
+            message: "Every dependsOn is a list of service names",
+        };
+    }
+    return {
+        name: "dependsOn",
+        didPass: false,
+        message: `${formatCount(problems.length, "invalid dependsOn", "invalid dependsOn")}:\n    ${problems.join("\n    ")}`,
+        fix: 'Write "dependsOn" as an array of service names, for example ["postgres", "api"]',
+    };
+}
+/** Services that wait on each other can never both start. A dependsOn name that is not a service is left to the unknown-name check. */
+export function checkCircularDependencies(projectRoot = findProjectRoot() ?? process.cwd()) {
+    const resources = discoverResourcesFromRoot(projectRoot);
+    const byName = new Map(resources.map((r) => [r.name, r]));
+    const cycles = findDependencyCycles(resources);
+    if (cycles.length === 0) {
+        return {
+            name: "Circular dependencies",
+            didPass: true,
+            message: "No service depends on itself through dependsOn",
+        };
+    }
+    const lines = cycles.map((cycle) => {
+        const first = byName.get(cycle[0] ?? "");
+        const next = cycle[1] ?? "";
+        return `${first ? filePath(projectRoot, first) : cycle[0]} dependsOn "${next}": circular dependency ${cycle.join(" -> ")}`;
+    });
+    return {
+        name: "Circular dependencies",
+        didPass: false,
+        message: `${cycles.length} ${cycles.length === 1 ? "circular dependency" : "circular dependencies"}:\n    ${lines.join("\n    ")}`,
+        fix: 'Remove one "dependsOn" entry in each cycle so the services no longer wait on each other, or move what they share into a third service',
+    };
+}
+/** A port outside 1-65535 can never be bound, and `tdk up` would otherwise find out only when Docker fails. */
+export function checkServicePorts(projectRoot = findProjectRoot() ?? process.cwd()) {
+    const problems = discoverResourcesFromRoot(projectRoot).flatMap((resource) => {
+        const port = resource.config?.port;
+        if (port === undefined)
+            return [];
+        if (typeof port === "number" && Number.isInteger(port) && port >= 1 && port <= 65535)
+            return [];
+        return [
+            `${filePath(projectRoot, resource)} port ${JSON.stringify(port)}: not an integer from 1 to 65535`,
+        ];
+    });
+    if (problems.length === 0) {
+        return { name: "Service ports", didPass: true, message: "Every declared port is valid" };
+    }
+    return {
+        name: "Service ports",
+        didPass: false,
+        message: `${formatCount(problems.length, "invalid port")}:\n    ${problems.join("\n    ")}`,
+        fix: 'Set "port" to the port the service listens on, an integer from 1 to 65535',
+    };
+}
+/**
+ * A service.json with no schemaVersion is how every project began, so this is a warning: it keeps working, and only
+ * `tdk config migrate` writes the field. A version this tdk does not know is reported the same way, with a different fix.
+ */
+export function checkSchemaVersions(projectRoot = findProjectRoot() ?? process.cwd(), strict = false) {
+    const missing = [];
+    const unsupported = [];
+    for (const resource of discoverResourcesFromRoot(projectRoot)) {
+        const version = resource.config?.schemaVersion;
+        if (version === SERVICE_MANIFEST_SCHEMA_VERSION)
+            continue;
+        const file = filePath(projectRoot, resource);
+        if (version === undefined)
+            missing.push(`${file} schemaVersion: missing`);
+        else
+            unsupported.push(`${file} schemaVersion ${JSON.stringify(version)}: this tdk supports ${SERVICE_MANIFEST_SCHEMA_VERSION}`);
+    }
+    if (missing.length === 0 && unsupported.length === 0) {
+        return {
+            name: "schemaVersion",
+            didPass: true,
+            message: "Every service.json has a supported schemaVersion",
+        };
+    }
+    const fixes = [
+        ...(missing.length > 0 ? ["Run `tdk config migrate` to add the missing schemaVersion"] : []),
+        ...(unsupported.length > 0
+            ? ["A version this tdk does not support cannot be migrated: upgrade tdk"]
+            : []),
+    ];
+    return {
+        name: "schemaVersion",
+        didPass: false,
+        isWarning: !strict,
+        message: `${formatCount(missing.length + unsupported.length, "service.json file")} without a supported schemaVersion:\n    ${[...missing, ...unsupported].join("\n    ")}`,
+        fix: fixes.join(". "),
+    };
+}
+/** Prints the schemaVersion warning once. It never stops anything: the project keeps working as it is. */
+export function warnSchemaVersions(projectRoot) {
+    const check = checkSchemaVersions(projectRoot);
+    if (check.didPass)
+        return;
+    console.warn(chalk.yellow(`⚠ ${check.message}`));
+    if (check.fix)
+        console.warn(chalk.gray(`  ${check.fix}`));
+}
+/**
+ * Runs before anything starts (also under --dry-run, like the drift gate): duplicate service names, circular
+ * dependsOn and invalid ports exit with 1 and say which file, which field, and how to fix it.
+ */
+export function enforceServiceConfigGate(projectRoot, options = {}, exit = process.exit) {
+    const failed = [
+        checkDuplicateResourceNames(projectRoot),
+        checkDependsOnShape(projectRoot),
+        checkCircularDependencies(projectRoot),
+        checkServicePorts(projectRoot),
+    ].filter((check) => !check.didPass);
+    if (failed.length === 0)
+        return;
+    const text = failed
+        .map((check) => `${check.message}${check.fix ? `\nFix: ${check.fix}` : ""}`)
+        .join("\n");
+    options.onInvalid?.(text);
+    for (const check of failed) {
+        console.error(chalk.red(`✗ ${check.message}`));
+        if (check.fix)
+            console.error(chalk.gray(`  Fix: ${check.fix}`));
+    }
+    exit(1);
+}
+//# sourceMappingURL=service-config-checks.js.map

package/cli/dist/utils/service-runtime-state.js

@@ -0,0 +1,67 @@
+import { buildStartupReport, transitiveDependencies } from "./startup-report.js";
+import { isTiltResourcePending } from "./tilt-resource-state.js";
+import { onlyEnabledResources } from "./up-readiness.js";
+/**
+ * The one answer to "is this service ready?" for `tdk status` and `tdk ui`, from Tilt's resources and the `dependsOn`
+ * in service.json. A service whose own process is up is still not ready while something it depends on has failed or
+ * is still starting. Services Tilt does not list are absent: the caller shows them as unknown.
+ */
+export function deriveServiceStates(jsonText, dependsOn, deferred = new Set()) {
+    const report = buildStartupReport(jsonText, dependsOn, deferred);
+    const failed = new Map(report.failed.map((entry) => [entry.name, entry.message]));
+    const blocked = new Map(report.blocked.map((entry) => [entry.name, entry.because]));
+    const starting = new Set(report.starting);
+    const items = JSON.parse(onlyEnabledResources(jsonText)).items ?? [];
+    const direct = new Map();
+    for (const item of items) {
+        const name = item.metadata?.name;
+        if (!name || name === "(Tiltfile)")
+            continue;
+        if (failed.has(name)) {
+            direct.set(name, { status: "error", reason: failed.get(name) });
+        }
+        else if (blocked.has(name)) {
+            const because = blocked.get(name) ?? [];
+            direct.set(name, {
+                status: "error",
+                reason: `${because.join(", ")} failed`,
+                blockedBy: because,
+            });
+        }
+        else if (starting.has(name)) {
+            direct.set(name, { status: "pending" });
+        }
+        else if (deferred.has(name) &&
+            isTiltResourcePending(item.status?.updateStatus ?? "", item.status?.runtimeStatus ?? "")) {
+            direct.set(name, { status: "unknown", reason: "starts on its first request" });
+        }
+        else {
+            direct.set(name, { status: "ready" });
+        }
+    }
+    const result = {};
+    for (const [name, state] of direct) {
+        if (state.status !== "ready") {
+            result[name] = state;
+            continue;
+        }
+        const deps = [...transitiveDependencies(name, dependsOn)].filter((dep) => direct.has(dep));
+        const failedDeps = deps.filter((dep) => direct.get(dep)?.status === "error").sort();
+        const waitingDeps = deps.filter((dep) => direct.get(dep)?.status === "pending").sort();
+        if (failedDeps.length > 0) {
+            result[name] = {
+                status: "error",
+                reason: `${failedDeps.join(", ")} failed`,
+                blockedBy: failedDeps,
+            };
+        }
+        else if (waitingDeps.length > 0) {
+            result[name] = { status: "pending", reason: `waiting for ${waitingDeps.join(", ")}` };
+        }
+        else {
+            result[name] = state;
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=service-runtime-state.js.map

package/cli/dist/utils/services.js

@@ -6,6 +6,7 @@ import { errorFactories } from "./errors.js";
 import { formatCount } from "./formatting.js";
 import { findProjectRoot } from "./paths.js";
 import { validateServiceManifest } from "./service-manifest.js";
+import { deriveStackStatus } from "./stack-status.js";
 import { includes } from "./validation.js";
 const RESOURCE_JSON_FILENAME = "service.json";
 function findServiceJsonFiles(dir, maxDepth = 5, currentDepth = 0) {
@@ -338,21 +339,7 @@ export function getStackMetadata(stack) {
     const timestamps = resourcesMetadata.map((r) => new Date(r.createdAt).getTime());
     const earliestTimestamp = Math.min(...timestamps);
     const latestTimestamp = Math.max(...timestamps);
-    const totalResources = resourcesMetadata.length;
-    let overallStatus = "unknown";
-    if (totalResources > 0) {
-        const readyCount = resourcesMetadata.filter((r) => r.status === "ready").length;
-        const ratio = readyCount / totalResources;
-        if (ratio > 0.9) {
-            overallStatus = "healthy";
-        }
-        else if (ratio > 0.5) {
-            overallStatus = "degraded";
-        }
-        else {
-            overallStatus = "error";
-        }
-    }
+    const overallStatus = deriveStackStatus(resourcesMetadata.map((r) => r.status));
     const metadata = {
         name: stack.name,
         resourceCount: resourcesMetadata.length,

package/cli/dist/utils/single-flight.js

@@ -0,0 +1,20 @@
+/**
+ * Runs a load and applies its result, but starts nothing while a previous load is still running. A poll on a timer
+ * therefore never overlaps itself: results cannot arrive out of order, and a slow Tilt cannot make every poll get
+ * superseded before it finishes.
+ */
+export function singleFlight(apply) {
+    let running = false;
+    return async (load) => {
+        if (running)
+            return;
+        running = true;
+        try {
+            apply(await load());
+        }
+        finally {
+            running = false;
+        }
+    };
+}
+//# sourceMappingURL=single-flight.js.map

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

@@ -0,0 +1,15 @@
+/**
+ * A stack with no known service status has not been checked, so it is "unknown", not "error". Once any service has a
+ * status, the share of ready services decides it.
+ */
+export function deriveStackStatus(statuses) {
+    if (statuses.length === 0 || statuses.every((status) => status === "unknown"))
+        return "unknown";
+    const ratio = statuses.filter((status) => status === "ready").length / statuses.length;
+    if (ratio > 0.9)
+        return "healthy";
+    if (ratio > 0.5)
+        return "degraded";
+    return "error";
+}
+//# sourceMappingURL=stack-status.js.map