@flisk-sh/flisk 0.0.0-stage → 1.3.190

package/cli/dist/utils/tilt-port-owner.js

@@ -0,0 +1,63 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { execFileSync } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { resolve } from "node:path";
+import { parseTiltProcesses } from "./doctor-wiring.js";
+const run = (command, args) => execFileSync(command, args, {
+    encoding: "utf-8",
+    stdio: "pipe",
+    timeout: 5000,
+    windowsHide: true,
+});
+/**
+ * The project whose `tilt up` listens on `port`, or null when it cannot be told (no lsof, Windows, a Tilt started
+ * without `-f`, a listener that is not Tilt). Callers must treat null as "unknown", not as "not mine".
+ */
+export function findTiltPortOwner(port, platform = process.platform, commandRunner = run) {
+    if (platform === "win32")
+        return null;
+    try {
+        const pids = commandRunner("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"])
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean);
+        for (const pid of pids) {
+            const command = commandRunner("ps", ["-p", pid, "-o", "command="]).trim();
+            const [owner] = parseTiltProcesses(`${pid} ${command}`);
+            if (owner)
+                return owner;
+        }
+    }
+    catch {
+        // lsof exits 1 when nothing listens, and may be missing.
+    }
+    return null;
+}
+/** Symlinked checkouts (macOS /tmp -> /private/tmp) must not make a project look foreign to itself. */
+function canonical(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}
+/** Whether `owner` is another project's Tilt, as opposed to this project's or unknown. */
+export function isForeignTilt(owner, projectRoot) {
+    return owner !== null && canonical(owner.root) !== canonical(projectRoot);
+}
+/** Split the candidate Tilt UI ports that answer into this project's and other projects'. */
+export async function classifyTiltPorts(candidatePorts, projectRoot, isServing, ownerOf = findTiltPortOwner) {
+    const result = { running: [], foreign: [] };
+    for (const port of candidatePorts) {
+        if (!(await isServing(port)))
+            continue;
+        const owner = ownerOf(port);
+        if (owner && isForeignTilt(owner, projectRoot))
+            result.foreign.push({ port, root: owner.root });
+        else
+            result.running.push(port);
+    }
+    return result;
+}

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

@@ -0,0 +1,54 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { execFileSync } from "node:child_process";
+const run = (command, args) => execFileSync(command, args, { encoding: "utf-8", stdio: "pipe", windowsHide: true });
+/** Refuse to target arbitrary listeners: only stop a Tilt process on the requested UI port. */
+export function findTiltProcessIdsOnPort(port, platform = process.platform, commandRunner = run) {
+    if (!Number.isInteger(port) || port < 1 || port > 65535)
+        return [];
+    if (platform === "win32") {
+        const script = `$port=${port}; Get-NetTCPConnection -LocalPort $port -State Listen -ErrorAction SilentlyContinue | ForEach-Object { $p=Get-Process -Id $_.OwningProcess -ErrorAction SilentlyContinue; if ($p -and $p.ProcessName -eq 'tilt') { $_.OwningProcess } } | Sort-Object -Unique`;
+        try {
+            return commandRunner("powershell.exe", ["-NoProfile", "-Command", script])
+                .split(/\s+/)
+                .map(Number)
+                .filter((pid) => Number.isInteger(pid) && pid > 0);
+        }
+        catch {
+            throw new Error(`Unable to inspect Tilt listeners on port ${port} with PowerShell.`);
+        }
+    }
+    let pids;
+    try {
+        pids = commandRunner("lsof", ["-nP", "-t", `-iTCP:${port}`, "-sTCP:LISTEN"])
+            .split(/\s+/)
+            .map(Number)
+            .filter((pid) => Number.isInteger(pid) && pid > 0);
+    }
+    catch (err) {
+        const commandErr = err;
+        const stderr = commandErr.stderr?.toString().trim();
+        if (commandErr?.status === 1 && !stderr)
+            return [];
+        throw new Error(`Unable to inspect listeners on port ${port}. Install lsof or resolve the lsof error before using --force.`, { cause: commandErr });
+    }
+    return pids.filter((pid) => {
+        try {
+            const name = commandRunner("ps", ["-p", String(pid), "-o", "comm="]).trim();
+            return name.split(/[\\/]/).at(-1) === "tilt";
+        }
+        catch (err) {
+            throw new Error(`Unable to identify the process listening on port ${port}.`, { cause: err });
+        }
+    });
+}
+export function stopTiltOnPort(port, platform = process.platform, commandRunner = run) {
+    const pids = findTiltProcessIdsOnPort(port, platform, commandRunner);
+    for (const pid of pids) {
+        if (platform === "win32")
+            commandRunner("taskkill.exe", ["/PID", String(pid), "/F"]);
+        else
+            commandRunner("kill", ["-TERM", String(pid)]);
+    }
+    return pids;
+}

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

@@ -0,0 +1,32 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+/**
+ * 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");
+}
+/** What a Tilt failure says when the container runs but Docker reports its health check as failing. */
+export const UNHEALTHY_CONTAINER_MESSAGE = "container is running, but its health check is failing";
+/**
+ * Tilt's runtime status, corrected for Docker health. Tilt reports a running compose container as `ok` even while its
+ * health check is still `starting` or has turned `unhealthy` (Tilt 0.37), so a Postgres that never accepts connections
+ * would read as ready. Health `starting` is pending and `unhealthy` is an error; a container without a health check
+ * keeps Tilt's status.
+ */
+export function effectiveRuntimeStatus(status) {
+    const runtimeStatus = status?.runtimeStatus ?? "";
+    if (runtimeStatus !== "ok")
+        return runtimeStatus;
+    const health = status?.composeResourceInfo?.healthStatus;
+    if (health === "unhealthy")
+        return "error";
+    if (health === "starting")
+        return "pending";
+    return runtimeStatus;
+}

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

@@ -0,0 +1,49 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { STANDARD_PORTS } from "./constants.js";
+import { isValidPort } from "./validation.js";
+export function parseTiltPort(value) {
+    if (value === undefined || value === "")
+        return { ok: true, port: undefined };
+    const port = Number(value);
+    if (/[^0-9]/.test(value) || !isValidPort(port)) {
+        return {
+            ok: false,
+            message: `Invalid TILT_PORT "${value}": expected an integer from 1 to 65535.`,
+        };
+    }
+    return { ok: true, port };
+}
+/** Resolve the port for read-only polling, falling back when TILT_PORT is absent or invalid. */
+export function getTiltPollingPort(value) {
+    const result = parseTiltPort(value);
+    return result.ok ? (result.port ?? STANDARD_PORTS.tiltUi) : STANDARD_PORTS.tiltUi;
+}
+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 };
+    }
+    if (options.force)
+        return { port: options.basePort, autoSwitched: false };
+    const availablePort = await options.findAvailablePort(options.basePort, 10);
+    if (availablePort && availablePort !== options.basePort) {
+        return { port: availablePort, autoSwitched: true };
+    }
+    return { port: options.basePort, autoSwitched: false };
+}
+export async function stopTiltForUp(options, dependencies) {
+    if (!options.force)
+        return;
+    if (!options.quiet) {
+        dependencies.log(`Force flag set - stopping Tilt on port ${options.port} if running...`);
+    }
+    dependencies.stop(options.port);
+    await dependencies.wait(2000);
+}

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

@@ -0,0 +1,9 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+/**
+ * What `flisk 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: flisk up`;
+}

package/cli/dist/utils/tilt.js

@@ -0,0 +1,104 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+import { errorFactories } from "./errors.js";
+import { findProjectRoot } from "./paths.js";
+import { findOnPath } from "./which.js";
+export function runTilt(command, args = [], options = {}) {
+    return new Promise((resolve, reject) => {
+        const tiltArgs = [command, ...args];
+        if (options.verbose) {
+            console.log(`Executing: tilt ${tiltArgs.join(" ")}`);
+        }
+        const child = spawn(findOnPath("tilt") ?? "tilt", tiltArgs, {
+            stdio: options.inheritStdio ? "inherit" : "pipe",
+            shell: false,
+            windowsHide: process.platform === "win32",
+            timeout: options.timeoutMs,
+        });
+        let stdout = "";
+        let stderr = "";
+        if (!options.inheritStdio) {
+            child.stdout?.on("data", (data) => {
+                stdout += data.toString();
+            });
+            child.stderr?.on("data", (data) => {
+                stderr += data.toString();
+            });
+        }
+        child.on("close", (code) => {
+            resolve({
+                exitCode: code ?? 1,
+                stdout,
+                stderr,
+            });
+        });
+        child.on("error", (err) => {
+            reject(new Error(`Failed to spawn tilt: ${err.message}`));
+        });
+    });
+}
+export async function isTiltAvailable() {
+    try {
+        const result = await runTilt("version", [], { inheritStdio: false, timeoutMs: 10_000 });
+        return result.exitCode === 0;
+    }
+    catch {
+        // tilt binary not found (or not spawnable) - treat as unavailable
+        return false;
+    }
+}
+export function getTiltfilePath() {
+    const projectRoot = findProjectRoot();
+    if (!projectRoot) {
+        throw errorFactories.notInProject();
+    }
+    return join(projectRoot, ".tdk", ".tdk-out", "Tiltfile");
+}
+function addTiltfilePath(args) {
+    const tiltfilePath = getTiltfilePath();
+    args.push("-f", tiltfilePath);
+}
+export function buildTiltUpArgs(serviceNames, options = {}) {
+    const args = [];
+    addTiltfilePath(args);
+    // Bare positional resource names only scope what this `tilt up` invocation waits
+    // on - they do NOT limit which resources the generated Tiltfile enables. Its focus
+    // filter (Config.apply_focus / apply_focus_filter) only reads the `--focus` flag;
+    // the positional-args catch-all it also defines (`cfg['args']`) is never read. So
+    // without `--focus`, every `flisk up <stack>` silently fell back to Tilt's default
+    // "pre-alpha" phase and built every stack in that phase, not just the one asked
+    // for. Passing the stack name via `--focus` reuses the Tiltfile's own (already
+    // dependency-aware) domain expansion instead of re-deriving it here.
+    //
+    // `--focus=...` needs a `--` before it: Tilt's own `tilt up` only accepts its own
+    // fixed flag set directly (see `tilt up --help`) and rejects anything else with
+    // "unknown flag" - `--` is what routes a token through to the Tiltfile's own
+    // config.parse(). Bare words like a service name aren't flag-shaped, so they don't
+    // need `--` to reach the Tiltfile's positional `args` catch-all.
+    if (options.focusTargets && options.focusTargets.length > 0) {
+        args.push("--", `--focus=${options.focusTargets.join(",")}`);
+    }
+    args.push(...serviceNames);
+    if (options.verbose && !options.quiet) {
+        args.push("--verbose");
+    }
+    if (options.watch) {
+        args.push("--watch");
+    }
+    return args;
+}
+export function buildTiltDownArgs(options = {}) {
+    const args = [];
+    addTiltfilePath(args);
+    // Note: `tilt down` has no `--force` or `--yes` flags. `flisk down` accepts them for
+    // CLI flag convention and script compatibility, but they must not be passed to Tilt.
+    // `tilt down` re-evaluates the Tiltfile and removes only the resources that evaluation registers. Without `--focus`
+    // the Tiltfile falls back to its default phase and never registers a stack's own compose project, so `flisk up shop`
+    // containers survived `flisk down`. Pass the same selection `flisk up` used (every stack) after `--`.
+    if (options.focusTargets && options.focusTargets.length > 0) {
+        args.push("--", `--focus=${options.focusTargets.join(",")}`);
+    }
+    return args;
+}

package/cli/dist/utils/ui-keymap.js

@@ -0,0 +1,129 @@
+export const TABS = [
+    { id: "overview", label: "OVERVIEW", shortcut: "1" },
+    { id: "resources", label: "RESOURCES", shortcut: "2" },
+    { id: "events", label: "EVENTS", shortcut: "3" },
+    { id: "files", label: "FILES", shortcut: "4" },
+    { id: "config", label: "CONFIG", shortcut: "5" },
+];
+const tabRange = `${TABS.at(0)?.shortcut}-${TABS.at(-1)?.shortcut}`;
+const uiKeymap = [
+    {
+        id: "list-navigation",
+        keys: ["ArrowUp", "ArrowDown", "j", "k"],
+        label: "Navigate list items",
+        group: "Navigation",
+        display: { ascii: "UP/DOWN or k/j", unicode: "↑/↓ or k/j" },
+    },
+    {
+        id: "first-last",
+        keys: ["g", "G", "Home", "End"],
+        label: "First/last item",
+        group: "Navigation",
+        display: { ascii: "g/G or Home/End", unicode: "g/G or Home/End" },
+    },
+    {
+        id: "page-list",
+        keys: ["PageUp", "PageDown"],
+        label: "Move one page",
+        group: "Navigation",
+        display: { ascii: "PgUp/PgDn", unicode: "PgUp/PgDn" },
+    },
+    {
+        id: "select",
+        keys: ["Enter", "Space"],
+        label: "Select item / Open detail",
+        group: "Navigation",
+        display: { ascii: "Enter or Space", unicode: "Enter or Space" },
+    },
+    {
+        id: "cycle-tabs",
+        keys: ["Tab", "Shift+Tab"],
+        label: "Next / previous tab",
+        group: "Navigation",
+        display: { ascii: "Tab/Shift+Tab", unicode: "Tab/Shift+Tab" },
+    },
+    {
+        id: "direct-tabs",
+        keys: TABS.map((tab) => tab.shortcut),
+        label: "Direct tab access",
+        group: "Navigation",
+        display: { ascii: tabRange, unicode: tabRange },
+    },
+    {
+        id: "toggle-mouse",
+        keys: ["m"],
+        label: "Toggle mouse support",
+        group: "Actions",
+    },
+    {
+        id: "toggle-tooltips",
+        keys: ["t"],
+        label: "Toggle tooltips",
+        group: "Actions",
+    },
+    {
+        id: "toggle-enabled",
+        keys: ["e"],
+        label: "Toggle enabled/disabled services",
+        group: "Actions",
+    },
+    {
+        id: "refresh",
+        keys: ["r"],
+        label: "Refresh data",
+        group: "Actions",
+    },
+    {
+        id: "open-url",
+        keys: ["o"],
+        label: "Open resource URL in browser",
+        group: "Actions",
+    },
+    {
+        id: "copy-url",
+        keys: ["y"],
+        label: "Copy resource URL to clipboard",
+        group: "Actions",
+    },
+    {
+        id: "search",
+        keys: ["/"],
+        label: "Search/filter",
+        group: "Actions",
+    },
+    {
+        id: "help",
+        keys: ["?"],
+        label: "Show this help",
+        group: "Actions",
+    },
+    {
+        id: "quit",
+        keys: ["q"],
+        label: "Quit",
+        group: "Actions",
+    },
+    {
+        id: "back",
+        keys: ["Esc"],
+        label: "Back",
+        group: "Actions",
+    },
+];
+export const UI_KEYMAP = uiKeymap;
+function getUiKeymapEntry(id) {
+    const entry = UI_KEYMAP.find((shortcut) => shortcut.id === id);
+    if (!entry) {
+        throw new Error(`Unknown Flisk UI shortcut: ${id}`);
+    }
+    return entry;
+}
+export function formatUiKeyNames(id, ascii = false) {
+    const entry = getUiKeymapEntry(id);
+    const display = ascii ? entry.display?.ascii : entry.display?.unicode;
+    return display ?? entry.keys.join("/");
+}
+export function formatUiKeyHint(id, label, ascii = false) {
+    const entry = getUiKeymapEntry(id);
+    return `[${formatUiKeyNames(id, ascii)}] ${label ?? entry.label}`;
+}

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

@@ -0,0 +1,34 @@
+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 `flisk 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)),
+    };
+}

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

@@ -0,0 +1,28 @@
+/** Requested names that match no discovered service (the Tiltfile silently enables everything for an unknown focus name). */
+export function findUnknownServices(requested, candidates) {
+    const known = new Set(candidates.map((resource) => resource.name));
+    return requested.filter((name) => !known.has(name));
+}
+/**
+ * The requested services plus their `dependsOn` closure. This mirrors what the generated Tiltfile enables for
+ * `--focus=<service>` (see get_all_needed_services in engine/topologies/tilt/config/profiles.star) so the CLI can report
+ * the same set. Shared infrastructure (Postgres, Traefik, the golden images) is always enabled by the Tiltfile and is not listed here.
+ * A dependsOn entry that is not a discovered service is ignored.
+ */
+export function resolveOnlySelection(requested, all) {
+    const byName = new Map(all.map((resource) => [resource.name, resource]));
+    const wanted = new Set();
+    const visit = (name) => {
+        if (wanted.has(name) || !byName.has(name))
+            return;
+        wanted.add(name);
+        for (const dep of byName.get(name)?.config?.dependsOn ?? [])
+            visit(dep);
+    };
+    for (const name of requested)
+        visit(name);
+    return {
+        selected: all.filter((resource) => wanted.has(resource.name)),
+        dependencies: all.map((r) => r.name).filter((n) => wanted.has(n) && !requested.includes(n)),
+    };
+}

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

@@ -0,0 +1,118 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { execFile } from "node:child_process";
+import { getDeferredResourceNames, parseTiltResourceFailures } from "./doctor-runtime.js";
+import { findOnPath } from "./which.js";
+export 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));
+    });
+}
+/**
+ * Tilt lists resources outside the current focus (the other release phases, or everything but a `--only` selection) with
+ * `disableStatus.state: Disabled` and both statuses `none`, which would read as pending forever. A resource whose update
+ * status is `not_applicable` (a serve-only local resource) has nothing to build, so it counts as built.
+ */
+export function onlyEnabledResources(jsonText) {
+    const parsed = JSON.parse(jsonText);
+    const items = (parsed.items ?? [])
+        .filter((item) => item.status?.disableStatus?.state !== "Disabled")
+        .map((item) => item.status?.updateStatus === "not_applicable"
+        ? { ...item, status: { ...item.status, updateStatus: "ok" } }
+        : item);
+    return JSON.stringify({ items });
+}
+function enabledNames(jsonText) {
+    return (JSON.parse(jsonText).items ?? [])
+        .filter((item) => item.status?.disableStatus?.state !== "Disabled")
+        .flatMap((item) => (item.metadata?.name ? [item.metadata.name] : []));
+}
+/**
+ * Services the caller asked for must not vanish into the disabled filter: one that Tilt lists as disabled (it can be
+ * disabled while running) is a failure, and one Tilt does not list yet is still pending.
+ */
+export function checkExpectedResources(jsonText, expected) {
+    const items = JSON.parse(jsonText).items ?? [];
+    const byName = new Map(items.map((item) => [item.metadata?.name, item]));
+    return {
+        missing: expected.filter((name) => !byName.has(name)),
+        disabled: expected.filter((name) => byName.get(name)?.status?.disableStatus?.state === "Disabled"),
+    };
+}
+/**
+ * One look at `tilt get uiresources -o json`. `settled` means polling can stop: everything is ready, or the rest has
+ * finished with a failure (an errored resource, or an expected service Tilt has disabled).
+ */
+export function evaluateTiltReadiness(jsonText, deferred, expected) {
+    const parsed = parseTiltResourceFailures(onlyEnabledResources(jsonText), deferred);
+    let result = {
+        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,
+        enabled: enabledNames(jsonText),
+    };
+    if (expected && expected.length > 0) {
+        const { missing, disabled } = checkExpectedResources(jsonText, expected);
+        if (missing.length > 0) {
+            result = { ...result, ready: false, pending: result.pending + missing.length };
+        }
+        if (disabled.length > 0) {
+            return {
+                settled: true,
+                result: {
+                    ...result,
+                    ready: false,
+                    failures: [
+                        ...result.failures,
+                        ...disabled.map((name) => ({ name, message: "disabled in Tilt" })),
+                    ],
+                },
+            };
+        }
+    }
+    return {
+        result,
+        settled: result.ready || (result.failures.length > 0 && result.pending === 0),
+    };
+}
+/**
+ * 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,
+        enabled: [],
+    };
+    for (;;) {
+        const text = await fetchJson(port);
+        if (text) {
+            try {
+                const evaluation = evaluateTiltReadiness(text, deferred, options.expected);
+                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. */
+            }
+        }
+        if (Date.now() >= deadline)
+            return { ...last, ready: false, timedOut: true };
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+}