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

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

@@ -0,0 +1,73 @@
+import { parseTiltResourceFailures, summarizeTiltBuildError } from "./doctor-runtime.js";
+import { portConflictFix } from "./port-conflict-fix.js";
+import { isTiltResourcePending } from "./tilt-resource-state.js";
+import { onlyEnabledResources } from "./up-readiness.js";
+export function transitiveDependencies(name, dependsOn) {
+    const seen = new Set();
+    const visit = (current) => {
+        for (const dep of dependsOn[current] ?? []) {
+            if (seen.has(dep))
+                continue;
+            seen.add(dep);
+            visit(dep);
+        }
+    };
+    visit(name);
+    return seen;
+}
+function isPending(item) {
+    return isTiltResourcePending(item.status?.updateStatus ?? "", item.status?.runtimeStatus ?? "");
+}
+export function buildStartupReport(jsonText, dependsOn, deferred = new Set()) {
+    const enabledJson = onlyEnabledResources(jsonText);
+    const failures = parseTiltResourceFailures(enabledJson, deferred).failures;
+    const failed = failures.map((failure) => ({
+        name: failure.name,
+        message: failure.error
+            ? summarizeTiltBuildError(failure.error)
+            : `${failure.updateStatus}/${failure.runtimeStatus}`,
+    }));
+    const failedNames = new Set(failed.map((entry) => entry.name));
+    const items = JSON.parse(enabledJson).items ?? [];
+    const blocked = [];
+    const starting = [];
+    for (const item of items) {
+        const name = item.metadata?.name ?? "unknown";
+        if (name === "(Tiltfile)" || failedNames.has(name) || deferred.has(name) || !isPending(item)) {
+            continue;
+        }
+        const because = [...transitiveDependencies(name, dependsOn)]
+            .filter((dep) => failedNames.has(dep))
+            .sort();
+        if (because.length > 0)
+            blocked.push({ name, because });
+        else
+            starting.push(name);
+    }
+    return { failed, blocked, starting };
+}
+/** A failure exists and everything still pending is blocked by it, so waiting longer cannot help. */
+export function isStartupStalled(jsonText, dependsOn, deferred = new Set()) {
+    const report = buildStartupReport(jsonText, dependsOn, deferred);
+    return report.failed.length > 0 && report.starting.length === 0;
+}
+export function formatStartupReport(report, timedOut) {
+    const lines = [];
+    for (const { name, message } of report.failed) {
+        lines.push(`✗ ${name} failed: ${message}`);
+        const fix = portConflictFix(message);
+        if (fix)
+            lines.push(`  ${fix}`);
+    }
+    for (const { name, because } of report.blocked) {
+        lines.push(`✗ ${name} is not ready because ${because.join(", ")} failed`);
+    }
+    if (report.starting.length > 0) {
+        lines.push(`${timedOut ? "Timed out waiting for" : "Still starting:"} ${report.starting.join(", ")}`);
+    }
+    if (lines.length > 0) {
+        lines.push("The environment is not ready. Tilt is still running; inspect it or run: tdk down");
+    }
+    return lines;
+}
+//# sourceMappingURL=startup-report.js.map

package/cli/dist/utils/suggestions.js

@@ -0,0 +1,58 @@
+function levenshteinDistance(left, right) {
+    let previousRow = Array.from({ length: right.length + 1 }, (_, index) => index);
+    for (let leftIndex = 1; leftIndex <= left.length; leftIndex++) {
+        const currentRow = [leftIndex];
+        for (let rightIndex = 1; rightIndex <= right.length; rightIndex++) {
+            const substitutionCost = left[leftIndex - 1] === right[rightIndex - 1] ? 0 : 1;
+            currentRow[rightIndex] = Math.min(currentRow[rightIndex - 1] + 1, previousRow[rightIndex] + 1, previousRow[rightIndex - 1] + substitutionCost);
+        }
+        previousRow = currentRow;
+    }
+    return previousRow[right.length];
+}
+function isAdjacentTransposition(left, right) {
+    if (left.length !== right.length)
+        return false;
+    for (let index = 0; index < left.length - 1; index++) {
+        if (left[index] !== right[index] &&
+            left[index] === right[index + 1] &&
+            left[index + 1] === right[index] &&
+            left.slice(0, index) === right.slice(0, index) &&
+            left.slice(index + 2) === right.slice(index + 2)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Bases the threshold on the longer name and caps it at two edits.
+ * An adjacent transposition counts as one typo; ties use deterministic code-unit order.
+ */
+export function suggestClosest(input, candidates) {
+    if (input.length < 2 || candidates.length === 0)
+        return undefined;
+    // stackExists and findUnknownServices are case-sensitive, so case-only mismatches need the canonical spelling.
+    if (candidates.includes(input))
+        return undefined;
+    const normalizedInput = input.toLowerCase();
+    let closest;
+    let closestDistance = Number.POSITIVE_INFINITY;
+    for (const candidate of candidates) {
+        if (candidate.length === 0)
+            continue;
+        const normalizedCandidate = candidate.toLowerCase();
+        const distance = isAdjacentTransposition(normalizedInput, normalizedCandidate)
+            ? 1
+            : levenshteinDistance(normalizedInput, normalizedCandidate);
+        const threshold = Math.max(1, Math.min(2, Math.floor(Math.max(normalizedInput.length, normalizedCandidate.length) / 3)));
+        if (distance > threshold)
+            continue;
+        if (distance < closestDistance ||
+            (distance === closestDistance && (closest === undefined || candidate < closest))) {
+            closest = candidate;
+            closestDistance = distance;
+        }
+    }
+    return closest;
+}
+//# sourceMappingURL=suggestions.js.map

package/cli/dist/utils/tilt-events.js

@@ -0,0 +1,195 @@
+import { STANDARD_PORTS } from "./constants.js";
+import { runTilt } from "./tilt.js";
+export class TiltEventsLoadError extends Error {
+    kind;
+    constructor(message, kind) {
+        super(message);
+        this.kind = kind;
+        this.name = "TiltEventsLoadError";
+    }
+}
+function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+// Tilt-controlled text is rendered in the terminal, so drop ANSI/OSC escape sequences and
+// other control characters (keeping tab/newline for later whitespace normalization).
+const ESC = String.fromCharCode(0x1b);
+const BEL = String.fromCharCode(0x07);
+const ANSI_SEQUENCE = new RegExp(`${ESC}(?:\\[[0-?]*[ -/]*[@-~]|\\][^${BEL}${ESC}]*(?:${BEL}|${ESC}\\\\)?|[@-Z\\\\-_])`, "g");
+// A regex literal would trip noControlCharactersInRegex, so this stays a string; keep the autofix from rewriting it.
+// biome-ignore lint/complexity/useRegexLiterals: the control-character range must stay in a string
+const CONTROL_CHARS = new RegExp("[\\u0000-\\u0008\\u000b-\\u001f\\u007f-\\u009f]", "g");
+export function stripTerminalControls(value) {
+    return value.replace(ANSI_SEQUENCE, "").replace(CONTROL_CHARS, "");
+}
+function readString(value) {
+    if (typeof value !== "string")
+        return undefined;
+    const cleaned = stripTerminalControls(value).trim();
+    return cleaned || undefined;
+}
+function readStringArray(value) {
+    return Array.isArray(value)
+        ? value.flatMap((item) => {
+            const cleaned = readString(item);
+            return cleaned ? [cleaned] : [];
+        })
+        : [];
+}
+export function parseTiltUiResourceList(value) {
+    const list = asRecord(value);
+    if (!list || !Array.isArray(list.items)) {
+        throw new Error("Tilt returned an invalid UIResource list");
+    }
+    const resources = [];
+    const events = [];
+    for (const value of list.items) {
+        const item = asRecord(value);
+        const metadata = asRecord(item?.metadata);
+        const resourceName = readString(metadata?.name);
+        if (!item || !resourceName)
+            continue;
+        const status = asRecord(item.status);
+        resources.push({
+            name: resourceName,
+            runtimeStatus: readString(status?.runtimeStatus),
+            updateStatus: readString(status?.updateStatus),
+            hasPendingChanges: typeof status?.hasPendingChanges === "boolean" ? status.hasPendingChanges : undefined,
+        });
+        const history = Array.isArray(status?.buildHistory) ? status.buildHistory : [];
+        for (const [buildIndex, value] of history.entries()) {
+            const build = asRecord(value);
+            if (!build)
+                continue;
+            const error = readString(build.error);
+            const warnings = readStringArray(build.warnings);
+            const details = [error, ...warnings].filter((entry) => Boolean(entry));
+            const spanId = readString(build.spanID);
+            events.push({
+                id: `${resourceName}:build:${spanId ?? String(buildIndex)}`,
+                resourceName,
+                kind: error ? "failed" : warnings.length ? "warning" : "success",
+                title: error
+                    ? "Build failed"
+                    : warnings.length
+                        ? "Build completed with warnings"
+                        : "Build completed",
+                occurredAt: readString(build.finishTime) ?? readString(build.startTime),
+                details: details.length ? details.join("; ") : undefined,
+            });
+        }
+        const currentBuild = asRecord(status?.currentBuild);
+        if (currentBuild) {
+            events.push({
+                id: `${resourceName}:current-build`,
+                resourceName,
+                kind: "running",
+                title: "Build in progress",
+                occurredAt: readString(currentBuild.startTime),
+            });
+        }
+        const pendingSince = readString(status?.pendingBuildSince);
+        if (!currentBuild && (status?.queued === true || pendingSince)) {
+            events.push({
+                id: `${resourceName}:queued`,
+                resourceName,
+                kind: "warning",
+                title: "Update queued",
+                occurredAt: pendingSince,
+            });
+        }
+        const lastDeployTime = readString(status?.lastDeployTime);
+        const deployTimestamp = lastDeployTime ? Date.parse(lastDeployTime) : Number.NaN;
+        const matchingBuild = events.some((event) => event.resourceName === resourceName &&
+            event.kind === "success" &&
+            event.occurredAt !== undefined &&
+            Date.parse(event.occurredAt) === deployTimestamp);
+        if (lastDeployTime && !matchingBuild) {
+            events.push({
+                id: `${resourceName}:last-deploy`,
+                resourceName,
+                kind: "success",
+                title: "Last deployed",
+                occurredAt: lastDeployTime,
+            });
+        }
+        const conditions = Array.isArray(status?.conditions) ? status.conditions : [];
+        for (const [conditionIndex, value] of conditions.entries()) {
+            const condition = asRecord(value);
+            if (!condition)
+                continue;
+            const type = readString(condition.type);
+            const state = readString(condition.status);
+            const reason = readString(condition.reason);
+            const message = readString(condition.message);
+            if ((!type && !reason && !message) || (state === "True" && !reason && !message))
+                continue;
+            const detail = [reason, message]
+                .filter((entry) => Boolean(entry))
+                .join(": ");
+            events.push({
+                id: `${resourceName}:condition:${conditionIndex}:${type ?? "status"}`,
+                resourceName,
+                kind: state === "False" ? "warning" : "status",
+                title: `Condition ${type ?? "status"}${state ? `: ${state}` : ""}`,
+                occurredAt: readString(condition.lastTransitionTime),
+                details: detail || undefined,
+            });
+        }
+    }
+    events.sort((left, right) => {
+        if (left.kind === "running" && right.kind !== "running")
+            return -1;
+        if (right.kind === "running" && left.kind !== "running")
+            return 1;
+        const leftTime = left.occurredAt ? Date.parse(left.occurredAt) : Number.NaN;
+        const rightTime = right.occurredAt ? Date.parse(right.occurredAt) : Number.NaN;
+        if (Number.isNaN(leftTime)) {
+            return Number.isNaN(rightTime) ? left.resourceName.localeCompare(right.resourceName) : 1;
+        }
+        if (Number.isNaN(rightTime))
+            return -1;
+        return rightTime - leftTime;
+    });
+    return { resources, events };
+}
+export async function loadTiltEvents() {
+    const port = process.env.TILT_PORT ?? String(STANDARD_PORTS.tiltUi);
+    let result;
+    try {
+        result = await runTilt("get", ["uiresources", "-o", "json", "--port", port], {
+            inheritStdio: false,
+            timeoutMs: 10_000,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const kind = /ENOENT|not found|no such file|connection refused|failed to connect|could not connect|unable to connect|Tilt is not running/i.test(message)
+            ? "unavailable"
+            : "error";
+        throw new TiltEventsLoadError(message, kind);
+    }
+    if (result.exitCode !== 0) {
+        const message = result.stderr.trim() || `tilt get exited with code ${result.exitCode}`;
+        const kind = /connection refused|failed to connect|could not connect|unable to connect|Tilt is not running|no running Tilt/i.test(message)
+            ? "unavailable"
+            : "error";
+        throw new TiltEventsLoadError(message, kind);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(result.stdout);
+    }
+    catch {
+        throw new TiltEventsLoadError("Tilt returned invalid UIResource JSON", "error");
+    }
+    try {
+        return parseTiltUiResourceList(parsed);
+    }
+    catch (error) {
+        throw new TiltEventsLoadError(error instanceof Error ? error.message : "Tilt returned an invalid UIResource list", "error");
+    }
+}
+//# sourceMappingURL=tilt-events.js.map

package/cli/dist/utils/tilt-resource-state.js

@@ -0,0 +1,12 @@
+/**
+ * A Tilt resource that is not built and running yet: still waiting (`pending`, `none`) or building right now
+ * (`in_progress`). Readiness must treat all of these as not ready.
+ */
+export function isTiltResourcePending(updateStatus, runtimeStatus) {
+    return (updateStatus === "pending" ||
+        updateStatus === "in_progress" ||
+        updateStatus === "none" ||
+        runtimeStatus === "pending" ||
+        runtimeStatus === "none");
+}
+//# sourceMappingURL=tilt-resource-state.js.map

package/cli/dist/utils/tilt-startup.js

@@ -11,6 +11,13 @@ export function parseTiltPort(value) {
     }
     return { ok: true, port };
 }
+export function secondUpAction(input) {
+    if (input.runningPorts.length === 0 || input.force)
+        return { action: "start" };
+    if (input.only)
+        return { action: "only-blocked", ports: input.runningPorts };
+    return { action: "already-running", ports: input.runningPorts };
+}
 export async function resolveTiltPort(options) {
     if (options.configuredPort !== undefined) {
         return { port: options.configuredPort, autoSwitched: false };

package/cli/dist/utils/tilt-unreachable-message.js

@@ -0,0 +1,8 @@
+/**
+ * What `tdk logs` says when no Tilt answers on the port. The usual cause is that the stack is not up, so the message
+ * names the command that starts it; Tilt's own connection error is not repeated, because it only restates that.
+ */
+export function tiltUnreachableMessage(port) {
+    return `Could not reach Tilt on port ${port}. The stack is not running, or Tilt is on another port. Start it with: tdk up`;
+}
+//# sourceMappingURL=tilt-unreachable-message.js.map

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

@@ -0,0 +1,35 @@
+import { getDeferredResourceNames } from "./doctor-runtime.js";
+import { deriveServiceStates } from "./service-runtime-state.js";
+import { deriveStackStatus } from "./stack-status.js";
+import { tiltGetUiResources } from "./up-readiness.js";
+/** One look at the running Tilt. Empty when no Tilt answers, so every service stays unknown. */
+export async function fetchServiceStates(services, tiltPort) {
+    try {
+        const text = await tiltGetUiResources(tiltPort);
+        if (!text)
+            return {};
+        return deriveServiceStates(text, Object.fromEntries(services.map((r) => [r.name, r.config?.dependsOn ?? []])), getDeferredResourceNames());
+    }
+    catch {
+        return {};
+    }
+}
+/** The same states `tdk status` shows, put onto the stack the UI is about to draw. */
+export function applyServiceStates(metadata, states) {
+    const resources = metadata.resources.map((resource) => {
+        const state = states[resource.name];
+        if (!state)
+            return resource;
+        return {
+            ...resource,
+            status: state.status,
+            ...(state.reason ? { statusReason: state.reason } : {}),
+        };
+    });
+    return {
+        ...metadata,
+        resources,
+        overallStatus: deriveStackStatus(resources.map((r) => r.status)),
+    };
+}
+//# sourceMappingURL=ui-service-state.js.map

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

@@ -102,6 +102,8 @@ export async function waitForTiltResourcesReady(port, options = {}) {
                 last = evaluation.result;
                 if (evaluation.settled)
                     return last;
+                if (last.failures.length > 0 && options.isStalled?.(text))
+                    return last;
             }
             catch {
                 /* Tilt may emit partial output while starting; retry. */

package/cli/package.json

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

package/cli/templates/.tiltignore.hbs

@@ -3,8 +3,7 @@
 # =============================================================================
 # SYSTEM-GENERATED BY TDK CLI - DO NOT EDIT
 # Source: .tdk/project.json
-# Generated: {{timestamp}}
-# Run 'tdk project' to regenerate
+# Regenerate with: tdk config regenerate
 # =============================================================================
 #
 # This file tells Tilt which directories to ignore during file watching.

package/cli/templates/TILT_RESOURCE_DEFAULTS.star.hbs

@@ -6,7 +6,7 @@
 # SYSTEM-GENERATED BY TDK CLI - DO NOT EDIT
 # Source: TDK Platform Standards v{{version}}
 # Output: .tdk/.tdk-out/
-# Run 'tdk project' to update
+# Regenerate with: tdk config regenerate
 # =============================================================================
 
 # Port Configuration

package/cli/templates/TILT_TECH_STACK.star.hbs

@@ -6,7 +6,7 @@
 # SYSTEM-GENERATED BY TDK CLI - DO NOT EDIT
 # Source: TDK Platform Standards v{{version}}
 # Output: .tdk/.tdk-out/
-# Run 'tdk project' to update
+# Regenerate with: tdk config regenerate
 # =============================================================================
 
 def get_tech_stack():
@@ -69,15 +69,15 @@ def validate_tech_stack(config, strict=False):
                     ))
                 elif strict:
                     errors.append(
-                        "❌ Tech Stack Error: {}: '{}' is not supported. " +
-                        "Platform standard is '{}'. Use _override_reason to document exceptions.".format(
+                        ("❌ Tech Stack Error: {}: '{}' is not supported. " +
+                        "Platform standard is '{}'. Use _override_reason to document exceptions.").format(
                             key, value, standard
                         )
                     )
                 else:
                     warnings.append(
-                        "⚠️ Tech Stack Warning: {}: '{}' is not standard. " +
-                        "Platform standard is '{}'.".format(key, value, standard)
+                        ("⚠️ Tech Stack Warning: {}: '{}' is not standard. " +
+                        "Platform standard is '{}'.").format(key, value, standard)
                     )
     
     # Optional validations (warnings if missing or different)

package/cli/templates/Tiltfile.hbs

@@ -1,11 +1,11 @@
 #!/usr/bin/env starlark
-# -*- coding: utf-8 -*}
+# -*- coding: utf-8 -*-
 # =============================================================================
 # 🎯 {{project.name}} - TILT ENTRYPOINT
 # =============================================================================
 # SYSTEM-GENERATED BY TDK CLI - DO NOT EDIT
 # Source: .tdk/project.json
-# Run 'tdk project' to regenerate
+# Regenerate with: tdk config regenerate
 # =============================================================================
 
 print("🚀 Loading {{project.name}}...")
@@ -38,7 +38,7 @@ TDK extension not found.
 'tdk up' needs the TDK Tilt extension (engine/discovery/specs/ext).
 Fix it with one of:
   1) Regenerate the project so the extension is vendored in:
-       tdk project --yes
+       tdk config regenerate
      (set $TDK_EXTENSION_SOURCE to a tdk-cli checkout if it was not auto-detected)
   2) Point at any tdk-cli checkout:
        export TDK_EXTENSION_PATH=/path/to/tdk-cli

package/cli/templates/spec.master.hbs

@@ -6,7 +6,7 @@
 # SYSTEM-GENERATED BY TDK CLI - DO NOT EDIT
 # Source: .tdk/project.json + TDK Platform Standards v{{version}}
 # Output: .tdk/.tdk-out/
-# Run 'tdk project' to update
+# Regenerate with: tdk config regenerate
 #
 # 🏗️ ARCHITECTURE: Project → Stack → Service (PSR Model)
 # Services are organized into stacks by release phase.

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

@@ -450,79 +450,6 @@ def _generate_port_anchors(resource_entries):
     return "\n".join(anchors)
 
 
-def _detect_sdk_in_entries(resource_entries):
-    """Check if any entry is an SDK."""
-    for entry in resource_entries:
-        if "-sdk:" in entry or entry.strip().startswith("identity-sdk:"):
-            return True
-    return False
-
-def _detect_frontend_in_entries(resource_entries):
-    """Check if any entry is a frontend."""
-    for entry in resource_entries:
-        if "<<: *frontend-memory-limit" in entry:
-            return True
-    return False
-
-def _detect_backend_in_entries(resource_entries):
-    """Check if any entry is a backend."""
-    for entry in resource_entries:
-        if _is_backend_entry(entry):
-            return True
-    return False
-
-def _is_sdk_entry(entry):
-    """Check if a specific entry is an SDK."""
-    return "-sdk:" in entry or entry.strip().startswith("identity-sdk:")
-
-def _is_backend_entry(entry):
-    """Check if a specific entry is a backend (not frontend, not SDK)."""
-    if "-sdk:" in entry or entry.strip().startswith("identity-sdk:"):
-        return False
-    if "<<: *frontend-memory-limit" in entry:
-        return False
-    # Backend entries have healthcheck with backend port pattern
-    if "healthcheck:" in entry and "curl" in entry:
-        return True
-    return False
-
-def _replace_ports_with_anchors(entry, has_sdk=False, has_frontend=False, has_backend=False):
-    """Replace hardcoded ports with YAML anchors in an entry."""
-    is_sdk = _is_sdk_entry(entry)
-    is_backend = _is_backend_entry(entry)
-    lines = entry.split("\n")
-    result = []
-
-    for line in lines:
-        new_line = line
-        # NOTE: We do NOT replace PORT=3000 with an anchor because YAML anchors
-        # in environment variable values are treated as literal strings, not resolved.
-        # The actual port value is already correctly set by _generate_single_backend_entry
-        # using the internal_port variable. Keep PORT=3000 as-is.
-
-        # YAML anchors do not resolve inside quoted Docker labels. Traefik must
-        # see a numeric loadbalancer.port (e.g. 4000), not `*backend-port`.
-        # NOTE: We do NOT replace healthcheck URLs with YAML anchors because anchors
-        # don't work inside quoted strings. The wget healthcheck URLs must use actual
-        # port numbers (e.g., http://127.0.0.1:3000), not anchor references.
-        # The correct port is already set by generate_frontend_compose.
-        # NOTE: We do NOT replace healthcheck URLs with anchors because YAML anchors
-        # don't work inside quoted strings. The healthcheck URL must use the actual
-        # port number (e.g., http://localhost:3000/health), not an anchor reference.
-        # The _generate_single_backend_entry function already uses the correct port
-        # via the internal_port variable in the healthcheck URL.
-
-        result.append(new_line)
-
-    return "\n".join(result)
-
-def _process_entries_with_anchors(resource_entries, has_sdk, has_frontend, has_backend):
-    """Replace ports with anchors in all entries."""
-    result = []
-    for entry in resource_entries:
-        result.append(_replace_ports_with_anchors(entry, has_sdk, has_frontend, has_backend))
-    return result
-
 def generate_app_compose_from_entries(resource_path, resource_entries, write_fn=None):
     """Generate docker-compose.app.autogenerated.yml from service entries with port anchors.
 
@@ -535,14 +462,6 @@ def generate_app_compose_from_entries(resource_path, resource_entries, write_fn=
         str: Generated docker-compose YAML content
     """
 
-    # Detect service types
-    has_sdk = _detect_sdk_in_entries(resource_entries)
-    has_frontend = _detect_frontend_in_entries(resource_entries)
-    has_backend = _detect_backend_in_entries(resource_entries)
-
-    # Replace ports with anchors in entries
-    processed_entries = _process_entries_with_anchors(resource_entries, has_sdk, has_frontend, has_backend)
-
     # Generate port anchors
     port_anchors = _generate_port_anchors(resource_entries)
 
@@ -598,15 +517,11 @@ networks:
         network_infisical=PlatformDockerConstants.NETWORK_INFISICAL,
     )
 
-    content = header + "\n".join(processed_entries) + footer
+    content = header + "\n".join(resource_entries) + footer
 
     if write_fn:
         compose_path = resource_path + '/' + OUTPUT.AUTOGENERATED_FOLDER + '/docker-compose.app.autogenerated.yml'
-        print("DEBUG COMPOSE GEN: Writing {} bytes to {}".format(len(content), compose_path))
         write_fn(compose_path, content)
-        print("DEBUG COMPOSE GEN: Write completed")
-    else:
-        print("DEBUG COMPOSE GEN: No write_fn provided!")
 
     return content
 

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

@@ -10,7 +10,7 @@ load("../config/healthcheck.star", "compose_healthcheck_timing")
 load("../networking/traefik_static_routes.star", "normalize_abs_path")
 
 
-def generate_standalone_traefik_compose(sablier_enabled = False, http_host_port = "8080", https_host_port = "8443"):
+def generate_standalone_traefik_compose(sablier_enabled = False, http_host_port = "8080", https_host_port = "8443", bind_address = "127.0.0.1"):
     """Minimal Traefik that routes Docker labels on api.{project}.localhost.
 
     The Sablier plugin, the sablier container and the wake gateway are only
@@ -31,7 +31,6 @@ services:
     container_name: {name}_traefik
     restart: unless-stopped
 {traefik_depends_on}    command:
-      - "--api.insecure=true"
       - "--ping=true"
       - "--providers.docker=true"
       - "--providers.docker.exposedbydefault=false"
@@ -48,8 +47,8 @@ services:
       - "--entrypoints.websecure.address=:443"
       - "--log.level=INFO"
 {sablier_flags}    ports:
-      - "{http_host_port}:80"
-      - "{https_host_port}:443"
+      - "{bind_address}:{http_host_port}:80"
+      - "{bind_address}:{https_host_port}:443"
     volumes:
       - /var/run/docker.sock:/var/run/docker.sock:ro
       - ./{dynamic_dir_name}:/etc/traefik/dynamic:ro
@@ -67,6 +66,7 @@ services:
         network=network,
         http_host_port=http_host_port,
         https_host_port=https_host_port,
+        bind_address=bind_address,
         healthcheck_timing=compose_healthcheck_timing(10),
         traefik_depends_on=_SABLIER_DEPENDS_ON if sablier_enabled else "",
         sablier_flags=_SABLIER_FLAGS if sablier_enabled else "",