@tdk-landscape/tdk-cli-core 1.3.104 → 1.3.106

package/CHANGELOG.md

@@ -4,6 +4,7 @@ Notable changes to the `tdk` CLI. Versions match [npm](https://www.npmjs.com/pac
 
 ## Unreleased
 
+- `tdk doctor` warns when a backend or worker applies database migrations from its own start-up (a `start`/`dev` script, a Dockerfile `CMD`/`ENTRYPOINT`, a shell entrypoint or its source: Prisma, Drizzle, Knex, TypeORM, MikroORM, Sequelize, dbmate, Atlas, Alembic). It is a warning, not a failure: such services work, but migrations belong in a `migrator` resource that runs once before the services that depend on it. `migrator` and bring-your-own resources are not checked.
 - Go services can opt in to a live development loop with `"dev": { "liveReload": true }` in `service.json`: edits are copied into the running container and recompiled without an image rebuild, while `go.mod`, `go.sum` and the generated Dockerfile still rebuild the image. The watcher compiles into a staging binary while the old build keeps serving and swaps only on success, so a compile error shows in the Tilt log and the last good build keeps answering (Air, tried first, stopped the app before compiling and left it down for the whole compile; in 2 of 6 edits a Traefik health check then returned 503 for 10 s). Measured on one loaded Mac: median edit-to-ready 1.63 s for the scaffold. The default Go image (`golang:1.23`) now sets `GOTOOLCHAIN=auto`, so a `go.mod` that needs a newer Go, such as Gin 1.12 (`go 1.25`), downloads that toolchain instead of stopping with `requires go >= 1.25`. Offline or air-gapped builds of a go.mod newer than 1.23 still fail, but now at the toolchain download rather than at the version check. `scripts/e2e/go-dev-loop.sh` checks all of this through a real `tdk up`. Refs #369.
 - `tdk up` keeps each smoke step's status and response body under `.tdk/smoke/<service>/<step>/` (`latest.json` and `body.txt`, body capped at 64 KiB), plus `last-success.json` and `last-success-body.txt` that a later failure never overwrites, so a regression can be diffed against the last good response. The failure line ends with the record path, and `tdk project` gitignores `.tdk/smoke/`. A new `smoke-e2e` workflow runs `scripts/verify-smoke.sh` and uploads the records. Before its first step a smoke check now waits for the service's health path (`healthCheckPath`, default `/health` for backends) with GETs until it answers something other than a connection error, 404 or 5xx, so a write is no longer the first request to hit a service that is still building; write retry rules are unchanged.
 - Add an opt-in Python backend: `tdk resource <name> --type backend --language python` scaffolds a FastAPI service (`pyproject.toml`, `src/main.py`, a pytest smoke test) and TDK generates its Docker image (`python:3.12-slim`, with `test` and `production` stages). The choice is saved as `language` in `service.json` only when you pass the flag; omitting it keeps the existing Bun + Hono output byte for byte. Unknown ids and `--language` on non-backend types fail before any file is written. A runnable example is in `examples/one-backend-python`, and the provider contract is in `docs/backend-language-providers.md`. Node.js is not included.

package/cli/dist/cli.js

@@ -9,7 +9,9 @@ import { downCommand } from "./commands/down.js";
 import { ejectCommand } from "./commands/eject.js";
 import { showHelp } from "./commands/help.js";
 import { importCommand } from "./commands/import.js";
+import { logsCommand } from "./commands/logs.js";
 import { maintainersCommand } from "./commands/maintainers.js";
+import { mcpCommand } from "./commands/mcp.js";
 import { networksCommand } from "./commands/networks.js";
 import { projectCommand } from "./commands/project.js";
 import { projectsCommand } from "./commands/projects.js";
@@ -46,6 +48,8 @@ program.addCommand(resourcesCommand);
 program.addCommand(projectsCommand);
 program.addCommand(upCommand);
 program.addCommand(downCommand);
+program.addCommand(mcpCommand);
+program.addCommand(logsCommand);
 program.addCommand(ejectCommand);
 program.addCommand(importCommand);
 program.addCommand(statusCommand);

package/cli/dist/commands/doctor.js

@@ -4,11 +4,12 @@ import { dirname, join, normalize, relative } from "node:path";
 import chalk from "chalk";
 import { Command } from "commander";
 import { hasVerdaccioLicense } from "../generator/extension-fetch.js";
+import { DEVCONTAINER_DOCKER_FIX, detectHost, isContainerHost, WEBCONTAINER_DOCS, WEBCONTAINER_UP_MESSAGE, } from "../utils/agent-host.js";
 import { MASTER_CONFIG_FILES, REQUIRED_PACKAGE_SCRIPTS } from "../utils/constants.js";
 import { isPathDiscovered, readDiscoveryPaths } from "../utils/discovery-paths.js";
 import { collectDoctorChecks, createDoctorReport, getDoctorExitCode, } from "../utils/doctor-report.js";
 import { checkHealthRoutes, checkIngressPorts, checkPrivateNpmRegistry, checkTiltResourceHealth, projectConfigEnablesVerdaccio, summarizeServiceProbes, } from "../utils/doctor-runtime.js";
-import { checkDockerNetworkCapacity, checkFrontendBackendUrls, checkNatsBroker, checkResourcePackageJson, checkServiceUrlPorts, checkTiltInstances, } from "../utils/doctor-wiring.js";
+import { checkDockerNetworkCapacity, checkFrontendBackendUrls, checkMigrationsInApi, checkNatsBroker, checkResourcePackageJson, checkServiceUrlPorts, checkTiltInstances, } from "../utils/doctor-wiring.js";
 import { validateEnvFile } from "../utils/env-validator.js";
 import { execAsync, isExecTimeout } from "../utils/exec-async.js";
 import { formatCount } from "../utils/formatting.js";
@@ -1005,6 +1006,7 @@ export const doctorCommand = new Command("doctor")
     if (!options.json) {
         console.log("TDK doctor checks your local Docker + Tilt development environment; it does not check cluster deployments.");
     }
+    const host = detectHost();
     if (process.platform === "win32") {
         if (options.json) {
             let windowsPortPlan = null;
@@ -1021,12 +1023,27 @@ export const doctorCommand = new Command("doctor")
                     message: NATIVE_WINDOWS_DOCTOR_MESSAGE,
                     fix: "Use WSL2 Ubuntu with Docker Desktop integration. Guide: docs/wsl2.md",
                 },
-            ], Boolean(findProjectRoot()), [], windowsPortPlan)));
+            ], Boolean(findProjectRoot()), [], windowsPortPlan, { ...host, canUp: false })));
         }
         console.error(NATIVE_WINDOWS_DOCTOR_MESSAGE);
         process.exit(1);
         return;
     }
+    if (host.kind === "webcontainer") {
+        const report = createDoctorReport([
+            {
+                name: "Host",
+                didPass: false,
+                message: WEBCONTAINER_UP_MESSAGE,
+                fix: `Use a machine with Docker. Guide: ${WEBCONTAINER_DOCS}`,
+            },
+        ], Boolean(findProjectRoot()), [], undefined, host);
+        if (options.json)
+            console.log(JSON.stringify(report));
+        console.error(WEBCONTAINER_UP_MESSAGE);
+        process.exit(1);
+        return;
+    }
     if (!options.json) {
         console.log(`\n${chalk.bold("🔍 TDK Doctor")}\n`);
         console.log("Checking environment...\n");
@@ -1089,6 +1106,7 @@ export const doctorCommand = new Command("doctor")
         () => checkServiceUrlPorts(),
         () => checkFrontendBackendUrls(),
         () => checkNatsBroker(),
+        () => checkMigrationsInApi(),
         () => checkTiltInstances(),
         checkEnvironmentVariables,
         // Preflight: Verdaccio down causes ImageBuild bun install ConnectionRefused.
@@ -1113,7 +1131,14 @@ export const doctorCommand = new Command("doctor")
     // would all fail with "run tdk project".
     const inProject = Boolean(projectRoot);
     const { checks: results, errors } = await collectDoctorChecks(machineChecks, inProject ? projectChecks : []);
-    const report = createDoctorReport(orderDoctorResults(results), inProject, errors, hostPortPlan);
+    if (isContainerHost(host.kind)) {
+        for (const result of results) {
+            if (result.name === "Container Runtime" && !result.didPass) {
+                result.fix = DEVCONTAINER_DOCKER_FIX;
+            }
+        }
+    }
+    const report = createDoctorReport(orderDoctorResults(results), inProject, errors, hostPortPlan, host);
     const exitCode = getDoctorExitCode(report);
     const allPassed = report.data.ready;
     if (options.json) {

package/cli/dist/commands/down.js

@@ -2,31 +2,40 @@ import chalk from "chalk";
 import { Command } from "commander";
 import { handleDryRun } from "../utils/command-helpers.js";
 import { handleTiltFailure, withTiltCheck } from "../utils/errors.js";
+import { createJsonEmitter } from "../utils/json-output.js";
 import { buildTiltDownArgs, runTilt } from "../utils/tilt.js";
 export const downCommand = new Command("down")
     .description("Stop all tilt resources")
     .option("-v, --verbose", "Enable verbose output", false)
     .option("-f, --force", "Skip confirmation", false)
     .option("--dry-run", "Show what would be stopped without stopping", false)
+    .option("--json", "Print one JSON object on stdout; implies quiet human output", false)
     .action(async (options) => {
+    const emit = options.json ? createJsonEmitter("DOWN_FAILED", "tdk down") : undefined;
     await withTiltCheck(async () => {
+        if (emit && options.dryRun) {
+            emit({ ok: true, dryRun: true });
+            return;
+        }
         if (handleDryRun(options, "not stopping resources", "tilt down")) {
             return;
         }
         const tiltArgs = buildTiltDownArgs({
             force: options.force,
         });
-        console.log(chalk.blue("Stopping all tilt resources..."));
-        if (options.verbose) {
+        if (!options.json)
+            console.log(chalk.blue("Stopping all tilt resources..."));
+        if (options.verbose && !options.json) {
             console.log(chalk.gray("Running: tilt down -f .tdk/.tdk-out/Tiltfile"));
         }
         const result = await runTilt("down", tiltArgs, {
-            verbose: options.verbose,
-            inheritStdio: true,
+            verbose: options.verbose && !options.json,
+            inheritStdio: !options.json,
         });
         if (result.exitCode !== 0) {
             handleTiltFailure("down", result.exitCode);
         }
+        emit?.({ ok: true });
     });
 });
 //# sourceMappingURL=down.js.map

package/cli/dist/commands/logs.js

@@ -0,0 +1,85 @@
+import { Command } from "commander";
+import { STANDARD_PORTS } from "../utils/constants.js";
+import { runCommand, showErrorAndExit } from "../utils/errors.js";
+import { createMachineEnvelope } from "../utils/machine-output.js";
+import { isTiltAvailable, runTilt } from "../utils/tilt.js";
+import { DEFAULT_LOG_TAIL, isTiltConnectionFailure, isValidPort, isValidSince, isValidTail, MAX_LOG_TAIL, parseTiltLogLines, } from "../utils/tilt-logs.js";
+/** Resource names Tilt knows about, or null when they cannot be listed (the logs call then reports the real error). */
+async function tiltResourceNames(port) {
+    try {
+        const result = await runTilt("get", ["uiresources", "-o", "json", "--port", port], {
+            inheritStdio: false,
+        });
+        if (result.exitCode !== 0)
+            return null;
+        const items = JSON.parse(result.stdout)
+            .items;
+        return (items ?? []).flatMap((item) => (item.metadata?.name ? [item.metadata.name] : []));
+    }
+    catch {
+        return null;
+    }
+}
+export const logsCommand = new Command("logs")
+    .description("Print a bounded snapshot of recent logs from the running stack")
+    .option("-s, --service <names...>", "Only these services (Tilt resource names)")
+    .option("--tail <n>", "Number of most recent lines to return", String(DEFAULT_LOG_TAIL))
+    .option("--since <duration>", "Only logs newer than this duration, for example 30s, 5m, 1h")
+    .option("--port <n>", "Tilt UI port (default: TILT_PORT or 10350)")
+    .option("--json", "Output one JSON object and exit", false)
+    .action(async (options) => {
+    const fail = (code, message, exitCode = 1) => {
+        if (options.json) {
+            console.log(JSON.stringify(createMachineEnvelope(null, [{ code, message }])));
+            console.error(message);
+            process.exit(exitCode);
+        }
+        return showErrorAndExit(message, exitCode);
+    };
+    if (!isValidTail(options.tail))
+        fail("USAGE", `--tail must be an integer from 1 to ${MAX_LOG_TAIL}`, 2);
+    if (options.since !== undefined && !isValidSince(options.since)) {
+        fail("USAGE", "--since must be a duration such as 30s, 5m or 1h", 2);
+    }
+    const portText = options.port ?? process.env.TILT_PORT ?? String(STANDARD_PORTS.tiltUi);
+    if (!isValidPort(portText))
+        fail("USAGE", "--port must be a valid port number", 2);
+    const tail = Number(options.tail);
+    const services = options.service ?? [];
+    const action = async () => {
+        if (!(await isTiltAvailable())) {
+            fail("TILT_MISSING", "Tilt is not installed. Run: tdk doctor");
+        }
+        if (services.length > 0) {
+            const known = await tiltResourceNames(portText);
+            const unknown = services.filter((name) => known && !known.includes(name));
+            if (unknown.length > 0) {
+                fail("UNKNOWN_SERVICE", `Unknown service ${unknown.join(", ")}. Valid names: ${(known ?? []).join(", ")}`, 2);
+            }
+        }
+        const args = ["--port", portText, "--tail", String(tail)];
+        if (options.since !== undefined)
+            args.push("--since", options.since);
+        if (options.json)
+            args.push("--json");
+        // `--` so a service name that starts with "-" is never read as a Tilt flag.
+        if (services.length > 0)
+            args.push("--", ...services);
+        const result = await runTilt("logs", args, { inheritStdio: false });
+        if (result.exitCode !== 0) {
+            const detail = result.stderr.trim();
+            if (!detail || isTiltConnectionFailure(detail)) {
+                fail("TILT_NOT_RUNNING", `Could not reach Tilt on port ${portText}: ${detail || "is the stack running? Start it with: tdk up"}`);
+            }
+            fail("TILT_LOGS_FAILED", `tilt logs failed: ${detail}`);
+        }
+        if (!options.json) {
+            process.stdout.write(result.stdout);
+            return;
+        }
+        const lines = parseTiltLogLines(result.stdout, tail);
+        console.log(JSON.stringify(createMachineEnvelope({ services, tail, since: options.since ?? null, lines })));
+    };
+    await runCommand(action);
+});
+//# sourceMappingURL=logs.js.map

package/cli/dist/commands/mcp.js

@@ -0,0 +1,24 @@
+import { createInterface } from "node:readline";
+import { Command } from "commander";
+import { createMcpServer } from "../mcp/server.js";
+import { createTdkTools } from "../mcp/tools.js";
+import { getPackageVersion } from "../utils/paths.js";
+export const mcpCommand = new Command("mcp")
+    .description("Run a Model Context Protocol server over stdio for coding agents")
+    .action(async () => {
+    const server = createMcpServer(createTdkTools(), { name: "tdk", version: getPackageVersion() });
+    // Stdout is the protocol channel. Nothing else may write to it; diagnostics go to stderr.
+    const lines = createInterface({ input: process.stdin });
+    const pending = new Set();
+    lines.on("line", (line) => {
+        const task = server.handleLine(line).then((response) => {
+            if (response)
+                process.stdout.write(`${response}\n`);
+        });
+        pending.add(task);
+        void task.finally(() => pending.delete(task));
+    });
+    await new Promise((resolve) => lines.once("close", resolve));
+    await Promise.allSettled(pending);
+});
+//# sourceMappingURL=mcp.js.map

package/cli/dist/commands/projects.js

@@ -4,21 +4,42 @@ import chalk from "chalk";
 import { Command } from "commander";
 import { MASTER_CONFIG_FILES } from "../utils/constants.js";
 import { createDiscoveryContext } from "../utils/discovery-context.js";
-import { requireProjectRoot, runCommand } from "../utils/errors.js";
+import { errorFactories, requireProjectRoot, runCommand } from "../utils/errors.js";
 import { formatCount } from "../utils/formatting.js";
+import { createMachineEnvelope, writeMachineError } from "../utils/machine-output.js";
+import { findProjectRoot } from "../utils/paths.js";
 export const projectsCommand = new Command("projects")
     .description("Show project information and configuration status")
     .alias("info")
     .option("--check", "Check if project is properly configured", false)
+    .option("--json", "Output a versioned JSON response")
     .action(async (options) => {
-    await runCommand(async () => {
-        const projectRoot = requireProjectRoot();
+    const action = async () => {
+        const projectRoot = options.json ? findProjectRoot() : requireProjectRoot();
+        if (!projectRoot) {
+            throw errorFactories.notInProject();
+        }
+        const outDir = join(projectRoot, ".tdk", ".tdk-out");
+        const missing = MASTER_CONFIG_FILES.filter((file) => !existsSync(join(outDir, file)));
+        if (options.json) {
+            const discovery = createDiscoveryContext();
+            console.log(JSON.stringify(createMachineEnvelope({
+                projectRoot,
+                configured: missing.length === 0,
+                missingFiles: missing,
+                resources: discovery.resources.length,
+                stacks: discovery.stackNames,
+                unassignedResources: discovery.unassignedResources.length,
+            }), null, 2));
+            if (options.check) {
+                process.exitCode = missing.length === 0 ? 0 : 1;
+            }
+            return;
+        }
         console.log(chalk.blue("Project Information\n"));
         console.log(chalk.bold("Project Root:"));
         console.log(chalk.gray(`  ${projectRoot}`));
         console.log();
-        const outDir = join(projectRoot, ".tdk", ".tdk-out");
-        const missing = MASTER_CONFIG_FILES.filter((file) => !existsSync(join(outDir, file)));
         console.log(chalk.bold("Master Configuration:"));
         if (missing.length === 0) {
             for (const file of MASTER_CONFIG_FILES) {
@@ -66,6 +87,16 @@ export const projectsCommand = new Command("projects")
         if (options.check) {
             process.exit(missing.length === 0 ? 0 : 1);
         }
-    });
+    };
+    if (options.json) {
+        try {
+            await action();
+        }
+        catch (error) {
+            writeMachineError(error);
+        }
+        return;
+    }
+    await runCommand(action);
 });
 //# sourceMappingURL=projects.js.map

package/cli/dist/commands/resources.js

@@ -23,6 +23,7 @@ export const resourcesCommand = new Command("resources")
             requireProjectRoot();
         }
         const discovery = createDiscoveryContext();
+        const withoutStackFilter = options.noStack || options.stack === false;
         let resources = discovery.resources;
         if (options.stack) {
             resources = discovery.resourcesByStack.get(options.stack) || [];
@@ -31,7 +32,7 @@ export const resourcesCommand = new Command("resources")
                 return;
             }
         }
-        if (options.noStack) {
+        if (withoutStackFilter) {
             resources = discovery.unassignedResources;
             if (resources.length === 0 && !options.json) {
                 showAllSatisfyCondition("resources", "assigned to a stack");
@@ -85,7 +86,7 @@ export const resourcesCommand = new Command("resources")
         const withoutStackCount = options.stack
             ? resources.filter((r) => !r.stack).length
             : discovery.unassignedResources.length;
-        if (withoutStackCount > 0 && !options.noStack && !options.stack) {
+        if (withoutStackCount > 0 && !withoutStackFilter && !options.stack) {
             console.log(chalk.yellow(`\n${formatCount(withoutStackCount, "resource")} not assigned to any stack.`));
             showDetail('Run "tdk resources --no-stack" to see them, or "tdk stack" to assign them.');
         }

package/cli/dist/commands/stacks.js

@@ -3,19 +3,36 @@ import { Command } from "commander";
 import { createDiscoveryContext } from "../utils/discovery-context.js";
 import { runCommand } from "../utils/errors.js";
 import { formatCount, showDetail, showEmptyState, showStep } from "../utils/formatting.js";
+import { createMachineEnvelope, writeMachineError } from "../utils/machine-output.js";
+import { findProjectRoot } from "../utils/paths.js";
 export const stacksCommand = new Command("stacks")
     .description("List all stacks and their resources")
     .alias("ls") // Keep 'tdk ls' as shorthand
     .option("-v, --verbose", "Show detailed information about each stack", false)
     .option("--services", "Include list of services in each stack", false)
+    .option("--json", "Output a versioned JSON stack report", false)
     .action(async (options) => {
-    await runCommand(async () => {
+    const action = async () => {
+        if (options.json && !findProjectRoot()) {
+            writeMachineError(new Error("Could not find project root (no .tdk/project.json found)"));
+        }
         const discovery = createDiscoveryContext();
+        const verbose = options.verbose || stacksCommand.parent?.opts().verbose === true;
+        if (options.json) {
+            const stacks = discovery.stacks.map((stack) => ({
+                name: stack.name,
+                resourceCount: stack.resourceCount,
+                ...(verbose ? { description: stack.description } : {}),
+                ...(options.services ? { services: stack.resources.map((service) => service.name) } : {}),
+            }));
+            console.log(JSON.stringify(createMachineEnvelope({ stacks })));
+            return;
+        }
         if (discovery.stackNames.length === 0) {
             showEmptyState("stacks");
             return;
         }
-        if (options.verbose || options.services) {
+        if (verbose || options.services) {
             showStep(`Found ${formatCount(discovery.stacks.length, "stack")}:\n`);
             for (const stack of discovery.stacks) {
                 console.log(chalk.bold(`${stack.name}`));
@@ -38,6 +55,16 @@ export const stacksCommand = new Command("stacks")
             }
             showDetail("\nRun with --verbose for more details, or --services to see all services in each stack.", 0);
         }
-    });
+    };
+    if (options.json) {
+        try {
+            await action();
+        }
+        catch (error) {
+            writeMachineError(error);
+        }
+        return;
+    }
+    await runCommand(action);
 });
 //# sourceMappingURL=stacks.js.map

package/cli/dist/commands/status.js

@@ -1,10 +1,15 @@
 import chalk from "chalk";
 import { Command } from "commander";
 import { createDiscoveryContext } from "../utils/discovery-context.js";
+import { getDeferredResourceNames } from "../utils/doctor-runtime.js";
 import { runCommand } from "../utils/errors.js";
 import { formatCount, showDetail, showStep } from "../utils/formatting.js";
+import { getHostPortPlan } from "../utils/host-port-config.js";
 import { createMachineEnvelope, writeMachineError } from "../utils/machine-output.js";
+import { findProjectRoot } from "../utils/paths.js";
+import { buildServicePorts, buildStackPorts } from "../utils/status-ports.js";
 import { getTiltfilePath, isTiltAvailable, runTilt } from "../utils/tilt.js";
+import { evaluateTiltReadiness, tiltGetUiResources } from "../utils/up-readiness.js";
 export const statusCommand = new Command("status")
     .description("Show status of resources and stacks")
     .option("--json", "Output a versioned JSON status report", false)
@@ -50,20 +55,46 @@ export const statusCommand = new Command("status")
                 queryError = result.stderr || "Could not retrieve Tilt resource status";
             }
         }
+        // A single look at the running Tilt, so a caller that started `tdk up` detached can poll for readiness. Null when no
+        // Tilt answers or its output cannot be read.
+        let readiness = null;
+        if (options.json && tiltAvailable) {
+            const port = Number.parseInt(process.env.TILT_PORT ?? "", 10);
+            const text = await tiltGetUiResources(Number.isInteger(port) ? port : 10350);
+            if (text) {
+                try {
+                    readiness = evaluateTiltReadiness(text, getDeferredResourceNames()).result;
+                }
+                catch {
+                    readiness = null;
+                }
+            }
+        }
         if (options.json) {
+            let portPlan = null;
+            try {
+                const root = findProjectRoot();
+                portPlan = root ? await getHostPortPlan(root, { inspectDocker: false }) : null;
+            }
+            catch {
+                // Port planning is best effort; stack ports then list only the Tilt UI.
+            }
             const errors = queryError ? [{ code: "TILT_STATUS_UNAVAILABLE", message: queryError }] : [];
             const data = {
                 tilt: {
                     available: tiltAvailable,
                     resourcesQueried: options.tilt && tiltAvailable,
                     resources: tiltResources,
+                    readiness,
                 },
                 resources: discovery.resources.map((resource) => ({
                     name: resource.name,
                     stack: resource.stack ?? null,
                     type: resource.type ?? "unknown",
                     port: resource.port ?? null,
+                    ...buildServicePorts(resource, portPlan?.ingressHttp),
                 })),
+                ports: buildStackPorts(portPlan, process.env.TILT_PORT ? Number.parseInt(process.env.TILT_PORT, 10) : undefined),
                 stacks: discovery.stacks.map((stack) => ({
                     name: stack.name,
                     resourceCount: stack.resourceCount,

package/cli/dist/commands/ui.js

@@ -12,7 +12,7 @@ const HelpPanel = ({ onClose }) => (_jsxs(Box, { borderStyle: "single", borderCo
 const LoadingScreen = ({ progress, message }) => (_jsxs(Box, { flexDirection: "column", padding: 2, children: [_jsx(Text, { bold: true, color: "cyan", children: "\u2593\u2592\u2591 TDK NEON EDITION \u2591\u2592\u2593" }), _jsx(Box, { marginY: 1 }), _jsxs(Text, { children: ["Loading: ", message] }), _jsxs(Box, { marginY: 1, borderStyle: "single", borderColor: "gray", width: 50, children: [_jsx(Box, { width: progress / 2, backgroundColor: "cyan", children: _jsx(Text, { children: " ".repeat(progress / 2) }) }), _jsxs(Text, { children: [" ", progress, "%"] })] })] }));
 // biome-ignore lint/correctness/noUnusedFunctionParameters: reserved callback prop kept in the component API
 const ErrorScreen = ({ error, onRetry }) => (_jsxs(Box, { flexDirection: "column", padding: 2, alignItems: "center", children: [_jsx(Text, { bold: true, color: "red", children: "Could Not Load Services" }), _jsx(Box, { marginY: 1 }), _jsxs(Text, { color: "red", children: ["\u2717 ", error] }), _jsx(Box, { marginY: 1 }), _jsx(Text, { color: "gray", children: "Troubleshooting:" }), _jsx(Text, { color: "gray", children: " 1. Check that every service.json is valid JSON" }), _jsx(Text, { color: "gray", children: " 2. Run tdk from your project (the folder with the Tiltfile)" }), _jsx(Text, { color: "gray", children: " 3. Try: tdk status --verbose" }), _jsx(Box, { marginY: 1 }), _jsx(Text, { color: "cyan", children: "Press [r] to retry or [q] to quit" })] }));
-const EmptyState = ({ message }) => (_jsxs(Box, { flexDirection: "column", padding: 2, alignItems: "center", children: [_jsx(Text, { bold: true, color: "yellow", children: "No Services Found" }), _jsx(Box, { marginY: 1 }), _jsx(Text, { color: "gray", children: "\u25C9 No service.json files found" }), _jsx(Box, { marginY: 1 }), _jsx(Text, { children: "To get started:" }), _jsx(Text, { children: " 1. Run: tdk init" }), _jsx(Text, { children: " 2. Or create services manually" }), _jsx(Box, { marginY: 1 }), _jsx(Text, { color: "cyan", children: "Press [r] to refresh or [q] to quit" }), message && (_jsx(Box, { paddingX: 1, height: 1, children: _jsxs(Text, { color: "cyan", children: ["\u2593\u2592\u2591 ", message, " \u2591\u2592\u2593"] }) }))] }));
+const EmptyState = ({ message }) => (_jsxs(Box, { flexDirection: "column", padding: 2, alignItems: "center", children: [_jsx(Text, { bold: true, color: "yellow", children: "No Services Found" }), _jsx(Box, { marginY: 1 }), _jsx(Text, { color: "gray", children: "\u25C9 No service.json files found" }), _jsx(Box, { marginY: 1 }), _jsx(Text, { children: "To get started:" }), _jsx(Text, { children: " 1. Run: tdk project" }), _jsx(Text, { children: " 2. Run: tdk resource api --type backend" }), _jsx(Box, { marginY: 1 }), _jsx(Text, { color: "cyan", children: "Press [r] to refresh or [q] to quit" }), message && (_jsx(Box, { paddingX: 1, height: 1, children: _jsxs(Text, { color: "cyan", children: ["\u2593\u2592\u2591 ", message, " \u2591\u2592\u2593"] }) }))] }));
 const TUIApp = () => {
     const { exit } = useApp();
     const { stdout } = useStdout();