@tdk-landscape/tdk-cli-core 1.3.86 → 1.3.87

package/CHANGELOG.md

@@ -4,6 +4,12 @@ Notable changes to the `tdk` CLI. Versions match [npm](https://www.npmjs.com/pac
 
 ## Unreleased
 
+- 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.
+- `tdk doctor` no longer reports "resource without a package.json" for a Python backend, and a Python service missing `pyproject.toml` or `src/main.py` now fails early with the missing file named.
+- Live reload now works: Tilt `live_update` sync paths were relative to the project root while Tilt resolves them against `.tdk/.tdk-out`, so they never matched and every source edit rebuilt the image ("Found file(s) not matching any sync"). An edit under `src/` is now copied into the running container without a rebuild, for Bun and Python services. Dependency file changes (`package.json`, `pyproject.toml`) still rebuild the image.
+- The service schema (`https://tdk-landscape.github.io/schema.service.json`) gains the `language` field (`bun`, `python`).
+- Fix the routed health URL in the `one-backend` example README.
+
 ## 1.3.80 (2026-09-30)
 
 - Add `tdk doctor --json` with schema-versioned readiness, checks, and structured errors; diagnostics remain on stderr.

package/README.md

@@ -2,7 +2,9 @@
 
 TDK CLI starts your services on your laptop. It is not a deploy and not a Compose file: define each service in `service.json`, then run `tdk up`. No Kubernetes is needed on the machine.
 
-Docker runs the containers. Tilt runs the development loop. TDK CLI writes that configuration. Production deployment stays with Helm, Argo CD, or Kustomize.
+Stability: 1.x local dev. Generated files are a contract; verify with `tdk config verify`. Core CLI is MIT and needs no key. Premium is optional.
+
+Docker runs the containers. Tilt watches services and live-updates containers while you code. TDK CLI writes the configuration Tilt uses. Production deployment stays with Helm, Argo CD, or Kustomize.
 
 [Website](https://tdk-landscape.github.io/tdk-website/) · [Quickstart](https://tdk-landscape.github.io/tdk-website/docs/quickstart/) · [Examples](https://tdk-landscape.github.io/tdk-website/docs/examples/) · [Awesome TDK](https://github.com/tdk-landscape/awesome-tdk-framework) · [Demo](https://tdk-landscape.github.io/tdk-demo-animation/) · [Report a bug](https://github.com/tdk-landscape/tdk-cli-core/issues)
 
@@ -20,6 +22,8 @@ curl http://api.shop.localhost/api/orders-api/health
 
 *Scaffolding a backend and frontend, then listing the stack.*
 
+![Top 9 places to use TDK CLI: scaffold a service, start a stack, hot reload, port management, auto-discovery, boot order, proxy routing, include infra, and config verify](docs/tdk-cli-top-9-uses.jpg)
+
 If Helm, Compose, or your existing Tilt setup already gives you a working local environment, keep using it. TDK CLI is for engineers managing several services who want a clear local service contract and one command to start the stack.
 
 See [how TDK CLI works alongside Helm](https://tdk-landscape.github.io/tdk-website/docs/with-helm/), the [service schema](engine/schemas/service-schema.json), and the [project configuration schema](engine/schemas/project-schema.json).
@@ -57,9 +61,12 @@ curl -fsSL https://tdk-landscape.github.io/install.sh | sh
 - [Working alongside Helm](docs/with-helm.md)
 - [Configuration and editor schemas](docs/configuration.md)
 - [Runnable one-backend example](examples/one-backend/README.md)
+- [Runnable Python backend example](examples/one-backend-python/README.md)
 - [Full multi-service example](examples/tdk-example/README.md)
 - [Features and license limits](docs/FEATURES.md)
 - [Honest comparison and known limits](docs/compare-honest.md)
+- [Public claims registry](docs/claims.md)
+- [Show HN draft](docs/show-hn.md)
 - [Architecture and repository map](docs/project-overview.md)
 - [Scale fixture measurements and caveats](docs/scale-bench.md)
 
@@ -67,6 +74,18 @@ curl -fsSL https://tdk-landscape.github.io/install.sh | sh
 
 For the local runtime, install Docker (Desktop, OrbStack, or Colima; Engine 25+, Compose 2.20+) and [Tilt](https://docs.tilt.dev/install.html). Bun 1.2+ is used by the default generated services. TDK selects host ports from bounded fallback ranges for HTTP, HTTPS, and Postgres; set `TDK_HTTP_PORT`, `TDK_HTTPS_PORT`, or `TDK_POSTGRES_PORT` to override them. TDK supports macOS, Linux, and Windows through WSL2 Ubuntu; native Windows supports CLI inspection only. Run `tdk doctor` to check local readiness. See [WSL2 setup](docs/wsl2.md).
 
+On native Windows, `tdk --version`, `tdk doctor`, and `tdk up --dry-run` are inspect-only commands. `tdk up` exits 2 with “Landscape startup needs Ubuntu on WSL2. Native Windows is inspect-only.”
+
+## License matrix
+
+| Capability | Free | Premium |
+| --- | --- | --- |
+| `tdk up`, scaffold, Traefik, Postgres, Tilt live update, golden layers | yes | yes |
+| Verdaccio, DDD scaffold, Sablier idle stop | no | key |
+| Playwright, C4, AGENTS.md | free if generated in-repo | only if the implementation is downloaded with a key |
+
+Core stays free. Premium is a separate key for the extras above; no key required to run `tdk up`.
+
 **Ecosystem map:** examples, articles, related tools, and notes live in [awesome-tdk-framework](https://github.com/tdk-landscape/awesome-tdk-framework). Star this repo (`tdk-cli-core`) if the CLI is what you run; use the awesome list to browse the rest.
 
 ## Contributing and license

package/cli/dist/backend-languages/bun.js

@@ -0,0 +1,53 @@
+export function getBackendIndexTemplate(name) {
+    return `import { Hono } from 'hono';
+
+const app = new Hono();
+
+// Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
+app.get('/health', (c) => {
+  return c.json({ status: 'ok', service: '${name}' });
+});
+
+app.get('/health/live', (c) => {
+  return c.json({ status: 'alive', timestamp: Date.now() });
+});
+
+app.get('/health/ready', async (c) => {
+  const dependencies: Record<string, string> = {};
+  let allReady = true;
+
+  // Add dependency checks here (database, cache, etc.)
+  // Mark allReady = false if any dependency is unhealthy
+
+  const status = allReady ? 'ready' : 'not_ready';
+  return c.json({ status, dependencies }, allReady ? 200 : 503);
+});
+
+app.get('/', (c) => {
+  return c.json({
+    service: '${name}',
+    version: '1.0.0',
+    endpoints: ['/health', '/health/live', '/health/ready']
+  });
+});
+
+const port = process.env.PORT || 3000;
+console.log('\\n🚀 ${name} running on http://localhost:' + port);
+console.log('📊 Health check: http://localhost:' + port + '/health\\n');
+
+export default {
+  port,
+  fetch: app.fetch,
+};
+`;
+}
+/**
+ * The historical default. Package scripts, tsconfig, Dockerfile, and the vitest smoke test stay in
+ * the shared scaffold so omitted-language output is byte-identical to before providers existed.
+ */
+export const bunBackendProvider = {
+    id: "bun",
+    label: "Bun + Hono",
+    installHint: "bun install",
+};
+//# sourceMappingURL=bun.js.map

package/cli/dist/backend-languages/python.js

@@ -0,0 +1,89 @@
+export const PYTHON_DEV_COMMAND = "uvicorn main:app --app-dir src --host 0.0.0.0 --port ${PORT:-4000} --reload --reload-dir src";
+export const pythonBackendProvider = {
+    id: "python",
+    label: "Python 3.12 + FastAPI",
+    devCommand: PYTHON_DEV_COMMAND,
+    watch: ["src/**/*"],
+    installHint: 'pip install -e ".[dev]"   # optional: Docker builds the image for you',
+    createFiles(name) {
+        return [
+            {
+                filename: "pyproject.toml",
+                content: `[project]
+name = "${name}"
+version = "0.0.1"
+requires-python = ">=3.12"
+dependencies = [
+  "fastapi==0.115.6",
+  "uvicorn[standard]==0.34.0",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest==8.3.4",
+  "httpx==0.28.1",
+]
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+# Only the dependencies are installed into the image; the source is synced for live reload.
+[tool.setuptools]
+py-modules = []
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]
+`,
+                description: "Generating pyproject.toml",
+                emoji: "📦",
+            },
+            {
+                filename: "src/main.py",
+                content: `import os
+
+from fastapi import FastAPI
+
+app = FastAPI(title="${name}")
+
+
+@app.get("/health")
+def health() -> dict[str, str]:
+    return {"status": "ok", "service": "${name}"}
+
+
+@app.get("/")
+def root() -> dict[str, object]:
+    return {"service": "${name}", "version": "1.0.0", "endpoints": ["/health"]}
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=int(os.environ.get("PORT", "3000")))
+`,
+                description: "Generating backend source",
+                emoji: "💻",
+            },
+            {
+                filename: "tests/test_health.py",
+                content: `from fastapi.testclient import TestClient
+
+from main import app
+
+client = TestClient(app)
+
+
+def test_health() -> None:
+    response = client.get("/health")
+    assert response.status_code == 200
+    assert response.json() == {"status": "ok", "service": "${name}"}
+`,
+                description: "Generating test file",
+                emoji: "🧪",
+            },
+        ];
+    },
+};
+//# sourceMappingURL=python.js.map

package/cli/dist/backend-languages/registry.js

@@ -0,0 +1,30 @@
+import { TdkError } from "../utils/errors.js";
+import { bunBackendProvider } from "./bun.js";
+import { pythonBackendProvider } from "./python.js";
+export const DEFAULT_BACKEND_LANGUAGE = "bun";
+export const BACKEND_LANGUAGES = {
+    bun: bunBackendProvider,
+    python: pythonBackendProvider,
+};
+export function getBackendLanguage(languageId) {
+    const id = (languageId ?? DEFAULT_BACKEND_LANGUAGE).trim().toLowerCase();
+    const provider = Object.hasOwn(BACKEND_LANGUAGES, id) ? BACKEND_LANGUAGES[id] : undefined;
+    if (!provider) {
+        const supportedIds = Object.keys(BACKEND_LANGUAGES).join(", ");
+        throw new TdkError(`Unknown backend language "${languageId}". Supported languages: ${supportedIds}.`, [`Use one of: ${supportedIds}`, `Omit --language to use ${DEFAULT_BACKEND_LANGUAGE}`]);
+    }
+    return provider;
+}
+/** Returns the provider for a backend, or undefined for other types. Rejects --language elsewhere. */
+export function resolveBackendLanguage(resourceType, languageId) {
+    if (resourceType !== "backend") {
+        if (languageId !== undefined) {
+            throw new TdkError("--language can only be used with --type backend.", [
+                "Add --type backend, or drop --language for this resource type",
+            ]);
+        }
+        return undefined;
+    }
+    return getBackendLanguage(languageId);
+}
+//# sourceMappingURL=registry.js.map

package/cli/dist/backend-languages/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/cli/dist/commands/resource.js

@@ -2,6 +2,8 @@ import { existsSync, mkdirSync } from "node:fs";
 import { isAbsolute, relative, resolve } from "node:path";
 import chalk from "chalk";
 import { Command } from "commander";
+import { getBackendIndexTemplate } from "../backend-languages/bun.js";
+import { resolveBackendLanguage } from "../backend-languages/registry.js";
 import { resolveFrontendFramework } from "../frontend-frameworks/registry.js";
 import { hasDddLicense } from "../generator/extension-fetch.js";
 import { CREATABLE_RESOURCE_TYPES } from "../types/index.js";
@@ -63,8 +65,10 @@ export function resolveByoPort(value, assignedPort, resources) {
     }
     return port;
 }
-export function createServiceJson(name, type, stack, port, extraFeatures = [], frameworkId) {
+export function createServiceJson(name, type, stack, port, extraFeatures = [], frameworkId, languageId) {
     const framework = resolveFrontendFramework(type, frameworkId);
+    // Only an explicit selection is persisted: a missing `language` has always meant Bun.
+    const language = languageId === undefined ? undefined : resolveBackendLanguage(type, languageId);
     const typeSpecific = TYPE_SPECIFIC[type];
     const base = JSON.parse(JSON.stringify(BASE_TEMPLATE));
     for (const [key, value] of Object.entries(typeSpecific)) {
@@ -75,18 +79,33 @@ export function createServiceJson(name, type, stack, port, extraFeatures = [], f
             base[key] = value;
         }
     }
+    if (language?.devCommand) {
+        base.dev = { command: language.devCommand, watch: language.watch ?? base.dev.watch };
+        // Provider-owned runtimes declare the probe path the engine reads; Bun keeps its historical key.
+        base.healthCheckPath = base.healthCheck;
+        delete base.healthCheck;
+        // The engine generates the image (.autogenerated/Dockerfile.app.autogenerated); a build
+        // block would point at a Dockerfile that does not exist.
+        delete base.build;
+    }
     return {
         ...base,
         $schema: SERVICE_MANIFEST_SCHEMA_URL,
         schemaVersion: SERVICE_MANIFEST_SCHEMA_VERSION,
         appName: name,
         appType: type,
-        featuresEnabled: [...getDefaultFeaturesForResourceType(type), ...extraFeatures],
+        featuresEnabled: [
+            ...getDefaultFeaturesForResourceType(type).filter(
+            // Prisma wiring is Bun-only; the Python provider owns their data layer.
+            (feature) => !(language?.createFiles && feature === "prisma")),
+            ...extraFeatures,
+        ],
         name,
         type,
         stack,
         port,
         ...(framework ? { framework: framework.id } : {}),
+        ...(language ? { language: language.id } : {}),
     };
 }
 export function createPackageJson(name, type, frameworkId) {
@@ -178,49 +197,7 @@ EXPOSE 3000
 
 CMD ["bun", "run", "start"]
 `;
-export function getBackendIndexTemplate(name) {
-    return `import { Hono } from 'hono';
-
-const app = new Hono();
-
-// Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
-app.get('/health', (c) => {
-  return c.json({ status: 'ok', service: '${name}' });
-});
-
-app.get('/health/live', (c) => {
-  return c.json({ status: 'alive', timestamp: Date.now() });
-});
-
-app.get('/health/ready', async (c) => {
-  const dependencies: Record<string, string> = {};
-  let allReady = true;
-
-  // Add dependency checks here (database, cache, etc.)
-  // Mark allReady = false if any dependency is unhealthy
-
-  const status = allReady ? 'ready' : 'not_ready';
-  return c.json({ status, dependencies }, allReady ? 200 : 503);
-});
-
-app.get('/', (c) => {
-  return c.json({
-    service: '${name}',
-    version: '1.0.0',
-    endpoints: ['/health', '/health/live', '/health/ready']
-  });
-});
-
-const port = process.env.PORT || 3000;
-console.log('\\n🚀 ${name} running on http://localhost:' + port);
-console.log('📊 Health check: http://localhost:' + port + '/health\\n');
-
-export default {
-  port,
-  fetch: app.fetch,
-};
-`;
-}
+export { getBackendIndexTemplate };
 function getShutdownHandlerTemplate(signal) {
     return `process.on('${signal}', () => {
   console.log('[Worker] ${signal} received, shutting down gracefully...');
@@ -312,6 +289,7 @@ export const resourceCommand = new Command("resource")
     .argument("[name]", "Resource name (kebab-case)")
     .option("-t, --type <type>", "Resource type: backend, frontend, worker, bring-your-own, sdk", "backend")
     .option("--framework <id>", "Frontend framework: react (default), vue")
+    .option("--language <id>", "Backend language: bun (default), python")
     .option("-s, --stack <stack>", "Stack to assign resource to", "default")
     .option("-p, --path <path>", "Custom path for resource directory")
     .option("--resource-path <path>", "Alias for --path (for backward compatibility)")
@@ -371,6 +349,7 @@ export const resourceCommand = new Command("resource")
             resourceType = normalizedType;
         }
         const frontendFramework = resolveFrontendFramework(resourceType, options.framework);
+        const backendLanguage = resolveBackendLanguage(resourceType, options.language);
         let dddEnabled = false;
         if (options.ddd) {
             if (resourceType !== "backend" && resourceType !== "worker") {
@@ -594,7 +573,7 @@ This file contains the resource configuration for TDK.
             }
         }
         // Prepare file generation tasks
-        const serviceJson = createServiceJson(resourceName, resourceType, stackName, assignedPort, dddEnabled ? ["ddd"] : [], frontendFramework?.id);
+        const serviceJson = createServiceJson(resourceName, resourceType, stackName, assignedPort, dddEnabled ? ["ddd"] : [], frontendFramework?.id, options.language === undefined ? undefined : backendLanguage?.id);
         const packageJson = createPackageJson(resourceName, resourceType, frontendFramework?.id);
         const tasks = [
             {
@@ -669,6 +648,21 @@ This file contains the resource configuration for TDK.
             description: "Generating test file",
             emoji: "🧪",
         });
+        // A language provider that owns its runtime files replaces the shared Bun/TypeScript
+        // scaffold (package.json, tsconfig, source, test, and the Dockerfile, which the engine generates); service.json stays shared.
+        const languageFiles = backendLanguage?.createFiles?.(resourceName);
+        if (languageFiles) {
+            const owned = new Set(languageFiles.map((file) => file.filename));
+            const sharedTasks = tasks.filter((task) => task.filename === "service.json" ||
+                !(owned.has(task.filename) ||
+                    task.filename === "Dockerfile" ||
+                    task.filename === "src/index.ts" ||
+                    task.filename === "package.json" ||
+                    task.filename === "tsconfig.json" ||
+                    task.filename.endsWith(".test.ts")));
+            tasks.length = 0;
+            tasks.push(...sharedTasks, ...languageFiles.map((file) => ({ ...file, type: "text" })));
+        }
         // Execute all file writes with progress
         console.log(chalk.blue("💻 Generating source files..."));
         writeFilesWithProgress(fullPath, tasks);
@@ -688,7 +682,7 @@ This file contains the resource configuration for TDK.
         }
         console.log(chalk.gray(`\nNext steps:`));
         console.log(chalk.gray(`  cd ${finalResourcePath}`));
-        console.log(chalk.gray(`  bun install`));
+        console.log(chalk.gray(`  ${backendLanguage?.installHint ?? "bun install"}`));
         console.log(chalk.gray(`  tdk up ${stackName}`));
     });
 });

package/cli/dist/commands/up.js

@@ -28,7 +28,7 @@ export function formatUpSuccess(port, appUrls = []) {
 export function nativeWindowsUpRefusal(platform, allowNativeWindows) {
     if (platform !== "win32" || allowNativeWindows === "1")
         return null;
-    return "Native Windows is not supported for `tdk up`. Use WSL2 with Docker Desktop integration, then run `tdk doctor` inside your WSL project.";
+    return "Landscape startup needs Ubuntu on WSL2. Native Windows is inspect-only.";
 }
 function waitForTiltUi(port, timeoutMs = 30_000) {
     return new Promise((resolve) => {

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

@@ -1,6 +1,7 @@
 import { execFileSync, execSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join, relative } from "node:path";
+import { BACKEND_LANGUAGES } from "../backend-languages/registry.js";
 import { execAsync } from "./exec-async.js";
 import { formatCount } from "./formatting.js";
 import { findProjectRoot } from "./paths.js";
@@ -44,9 +45,16 @@ function backendPorts(resources) {
     }
     return ports;
 }
+/** A backend whose language provider scaffolds its own runtime files (Python) has no package.json. */
+function ownsRuntimeFiles(resource) {
+    const language = resource.config?.language;
+    return (typeof language === "string" &&
+        Object.hasOwn(BACKEND_LANGUAGES, language) &&
+        BACKEND_LANGUAGES[language].createFiles !== undefined);
+}
 export function checkResourcePackageJson(projectRoot = findProjectRoot() ?? process.cwd()) {
     const missing = discoverResourcesFromRoot(projectRoot)
-        .filter((resource) => !existsSync(join(resource.path, "package.json")))
+        .filter((resource) => !ownsRuntimeFiles(resource) && !existsSync(join(resource.path, "package.json")))
         .map((resource) => resource.name);
     if (missing.length === 0) {
         return {

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

@@ -20,6 +20,7 @@ const KNOWN_SERVICE_FIELDS = new Set([
     "framework",
     "healthCheckPath",
     "image",
+    "language",
     "name",
     "nats",
     "params",

package/cli/package.json

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

package/engine/schemas/service-schema.json

@@ -222,6 +222,14 @@
       ],
       "type": "string"
     },
+    "language": {
+      "description": "Backend language provider used to scaffold and run the service. Only meaningful for backend resources; omitted means bun (legacy manifests).",
+      "enum": [
+        "bun",
+        "python"
+      ],
+      "type": "string"
+    },
     "healthCheckPath": {
       "default": "/health",
       "description": "HTTP endpoint for health checks. Must return 200 OK.",

package/engine/topologies/platform/docker/dockerfile/language_dockerfile.star

@@ -0,0 +1,62 @@
+# Dockerfiles for backends whose `language` is not the Bun default.
+#
+# Bun backends use the golden-image generator. Python backends are a small
+# standalone image: language-specific base image and reload command, while the build
+# context (project root), `production` target, health check, and PORT contract stay the
+# same as every other backend.
+
+BASE_PORT_BACKEND = 4000
+
+# Languages whose runtime files are owned by the provider (no Vite/tsconfig/Bun config).
+PROVIDER_OWNED_LANGUAGES = ["python"]
+
+_CURL = """RUN apt-get update && apt-get install -y --no-install-recommends curl \\
+  && rm -rf /var/lib/apt/lists/*
+"""
+
+_HEALTHCHECK = """HEALTHCHECK --interval=10s --timeout=5s --retries=3 \\
+  CMD curl -f http://localhost:${{PORT:-{port}}}/health || exit 1
+"""
+
+_PYTHON = """# Generated by TDK for a Python backend. Do not edit; change service.json instead.
+FROM python:3.12-slim AS base
+
+WORKDIR /app/{res_path}
+
+{curl}
+COPY {res_path}/pyproject.toml ./
+RUN pip install --no-cache-dir .
+
+COPY {res_path}/src ./src
+
+FROM base AS test
+RUN pip install --no-cache-dir ".[dev]"
+COPY {res_path}/tests ./tests
+RUN pytest
+
+FROM base AS production
+
+{healthcheck}
+EXPOSE {port}
+
+CMD ["sh", "-c", "uvicorn main:app --app-dir src --host 0.0.0.0 --port ${{PORT:-{port}}} --reload --reload-dir src"]
+"""
+
+def generate_language_dockerfile(res_path, language, port = BASE_PORT_BACKEND):
+    """Dockerfile text for a provider-owned backend language, or fail for an unknown one."""
+    template = {"python": _PYTHON}.get(language)
+    if template == None:
+        fail("No Dockerfile generator for backend language '{}'".format(language))
+    return template.format(
+        res_path = res_path,
+        port = port,
+        curl = _CURL,
+        healthcheck = _HEALTHCHECK.format(port = port),
+    )
+
+
+def is_provider_owned_language(manifest):
+    """True when the manifest selects Python (a missing language means Bun)."""
+    if not manifest:
+        return False
+    return manifest.get("appType", "backend") == "backend" and manifest.get("language", "bun") in PROVIDER_OWNED_LANGUAGES

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

@@ -4,6 +4,11 @@ load(
     "generate_app_dockerfile",
     "generate_migrator_dockerfile",
 )
+load(
+    "./dockerfile/language_dockerfile.star",
+    "generate_language_dockerfile",
+    "is_provider_owned_language",
+)
 load("./config/dockerignore.star", "generate_dockerignore")
 load(
     "./compose/compose.star",
@@ -18,6 +23,8 @@ Docker = struct(
     frontend = generate_frontend_dockerfile,
     backend = generate_app_dockerfile,
     migrator = generate_migrator_dockerfile,
+    backend_language = generate_language_dockerfile,
+    is_provider_owned_language = is_provider_owned_language,
     generate_dockerignore = generate_dockerignore,
     frontend_compose = generate_frontend_compose,
     backend_compose = generate_backend_compose_entry,

package/engine/topologies/tilt/generators/validators.star

@@ -556,8 +556,11 @@ def generate_resource_health_check(resource_name, resource_path, manifest, check
     
     # Check 1: Required files exist
     frontend_entry = "src/main.ts" if manifest.get("framework", "react") == "vue" else "src/main.tsx"
+    backend_files = {
+        "python": ["pyproject.toml", "src/main.py"],
+    }.get(manifest.get("language", "bun"), ["package.json", "prisma/schema.prisma"])
     required_files = {
-        "backend": ["package.json", "prisma/schema.prisma"],
+        "backend": backend_files,
         "frontend": ["package.json", "index.html", frontend_entry],
         "library": ["package.json"],
     }.get(app_type, ["package.json"])
@@ -570,8 +573,9 @@ if [ ! -f "{}" ]; then
 fi
 '''.format(req_file, req_file))
     
-    # Check 2: Package.json is valid JSON
-    health_checks.append('''
+    # Check 2: Package.json is valid JSON (Python backends have no package.json)
+    if manifest.get("language", "bun") != "python":
+        health_checks.append('''
 if ! cat package.json | head -1 > /dev/null 2>&1; then
     echo "❌ package.json is not valid"
     exit 1

package/engine/topologies/tilt/resources/orchestrator/apply_compose_resource_registration.star

@@ -201,14 +201,39 @@ def _register_replicas(config, auto_init_apps):
         )
 
 
-def _build_live_update_rules(res_path, full_res_path, syncs):
-    """Build live update sync and run rules for a resource."""
+def _live_update_sync_source(project_root, full_res_path, sync_path):
+    """Local path Tilt watches for a live-update sync.
+
+    Tilt resolves sync() local paths against the Tiltfile directory (.tdk/.tdk-out), not
+    the docker_build context, so a project-relative path never matches the changed files
+    and every edit falls back to a full image rebuild ("Found file(s) not matching any
+    sync"). Anchor it at the project root, like the Dockerfile and build context.
+    """
+    relative_path = full_res_path + '/' + sync_path
+    if project_root:
+        return project_root.rstrip('/') + '/' + relative_path
+    return relative_path
+
+
+def _build_live_update_rules(res_path, full_res_path, syncs, project_root='', language='bun'):
+    """Build live update sync and run rules for a resource.
+
+    Python backends reload their own process after a sync (uvicorn --reload), so they have
+    no Bun install step. A changed pyproject.toml is not synced, so Tilt rebuilds the image instead.
+    """
     live_update_rules = []
     for sync_path in syncs:
-        full_sync_path = full_res_path + '/' + sync_path
+        # Python images never read the npm/Bun registry config, and the engine does not
+        # generate it for provider-owned languages, so there is nothing to sync.
+        if language == 'python' and (sync_path.endswith('.npmrc.docker.autogenerated') or sync_path.endswith('bunfig.docker.autogenerated.toml')):
+            continue
+        full_sync_path = _live_update_sync_source(project_root, full_res_path, sync_path)
         dest = '/app/' + full_res_path + '/' + sync_path
         live_update_rules.append(sync(full_sync_path, dest))
     
+    if language == 'python':
+        return live_update_rules
+    
     package_json_path = '/app/' + full_res_path + '/package.json'
     bun_lock_path = '/app/' + full_res_path + '/bun.lock'
     live_update_rules.append(run('cd /app/' + full_res_path + ' && bun install', 
@@ -373,7 +398,9 @@ def _register_single_resource(config, resource_path, compose_project_name, auto_
         live_update_rules = _build_live_update_rules(
             config['res_path'],
             config['res_path'],
-            config['syncs']
+            config['syncs'],
+            project_root=config.get('project_root', ''),
+            language=config.get('manifest', {}).get('language', 'bun'),
         )
         _register_docker_build(config, live_update_rules)
         if defers_start:

package/engine/topologies/tilt/resources/orchestrator/generators/manifest_resource.star

@@ -310,6 +310,18 @@ def _generate_all_configs_for_resource(
     
     app_type = manifest.get('appType', 'backend')
     is_frontend = resource_config.get('frontend', False) or app_type == 'frontend'
+    # Python backends own their runtime files (package/pyproject, Dockerfile,
+    # reload command). Bun-only configs below (Vite, tsconfig, Prisma, bunfig) are skipped.
+    provider_owned = Docker.is_provider_owned_language(manifest)
+    if provider_owned:
+        # Fail before generating anything, with the missing file named, instead of a Docker
+        # COPY error halfway through the image build.
+        root = ctx.get('project_root', '')
+        prefix = (root.rstrip('/') + '/' if root else '') + resource_path + '/'
+        for required in ['pyproject.toml', 'src/main.py']:
+            if not os.path.exists(prefix + required):
+                fail("{}: language '{}' requires {} but {}{} does not exist".format(
+                    resource_name, manifest.get('language'), required, resource_path + '/', required))
     
     # ==========================================================================
     # 1. VITE CONFIG
@@ -319,7 +331,7 @@ def _generate_all_configs_for_resource(
             Vite.for_manifest(manifest, backend_manifest, write_file)
         else:
             Vite.for_manifest(manifest, None, write_file)
-    elif app_type == 'backend':
+    elif app_type == 'backend' and not provider_owned:
         Vite.for_manifest(manifest, None, write_file)
     elif app_type == 'sdk':
         Vite.for_manifest(manifest, None, write_file)
@@ -365,6 +377,12 @@ def _generate_all_configs_for_resource(
             use_nginx=use_nginx,
             use_golden=should_enable('golden-image')
         )
+    elif provider_owned:
+        dockerfile_content = Docker.backend_language(
+            res_path=resource_path,
+            language=manifest.get('language'),
+            port=manifest.get('port', 4000),
+        )
     else:
         dockerfile_content = Docker.backend(
             res_path=resource_path,
@@ -419,7 +437,7 @@ def _generate_all_configs_for_resource(
             resource_path, write_file, internal_deps=internal_deps_map, is_docker=False,
             framework=manifest.get('framework', 'react'),
         )
-    else:
+    elif not provider_owned:
         prisma_path = resource_config.get('prisma_client_path', './node_modules/.prisma/client')
         resource_features = manifest.get('featuresEnabled', [])
         TSConfig.backend(resource_path, prisma_path, write_file, internal_deps=internal_deps_map, is_docker=True, features=resource_features)
@@ -434,10 +452,11 @@ def _generate_all_configs_for_resource(
     # 8. PACKAGE CONFIGS (npmrc, bunfig)
     # ==========================================================================
     verdaccio_enabled = global_config.get('verdaccio_enabled', True)
-    PackageConfig.npmrc(resource_path=resource_path, registry_url=global_config['verdaccio_url_docker'], is_docker=True, write_fn=write_file, verdaccio_enabled=verdaccio_enabled)
-    PackageConfig.bunfig(resource_path=resource_path, registry_url=global_config['verdaccio_url_docker'], is_docker=True, write_fn=write_file, verdaccio_enabled=verdaccio_enabled)
-    PackageConfig.npmrc(resource_path=resource_path, registry_url=global_config['verdaccio_url_local'], is_docker=False, write_fn=write_file, verdaccio_enabled=verdaccio_enabled)
-    PackageConfig.bunfig(resource_path=resource_path, registry_url=global_config['verdaccio_url_local'], is_docker=False, write_fn=write_file, verdaccio_enabled=verdaccio_enabled)
+    if not provider_owned:
+        PackageConfig.npmrc(resource_path=resource_path, registry_url=global_config['verdaccio_url_docker'], is_docker=True, write_fn=write_file, verdaccio_enabled=verdaccio_enabled)
+        PackageConfig.bunfig(resource_path=resource_path, registry_url=global_config['verdaccio_url_docker'], is_docker=True, write_fn=write_file, verdaccio_enabled=verdaccio_enabled)
+        PackageConfig.npmrc(resource_path=resource_path, registry_url=global_config['verdaccio_url_local'], is_docker=False, write_fn=write_file, verdaccio_enabled=verdaccio_enabled)
+        PackageConfig.bunfig(resource_path=resource_path, registry_url=global_config['verdaccio_url_local'], is_docker=False, write_fn=write_file, verdaccio_enabled=verdaccio_enabled)
     
     # ==========================================================================
     # 9. YAML MANIFEST (for verification)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tdk-landscape/tdk-cli-core",
-  "version": "1.3.86",
+  "version": "1.3.87",
   "description": "TDK CLI — start services on your laptop.",
   "homepage": "https://tdk-landscape.github.io/tdk-website",
   "repository": {