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

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)
 
@@ -16,10 +18,12 @@ tdk up shop
 curl http://api.shop.localhost/api/orders-api/health
 ```
 
-![TDK scaffolding a backend and a frontend, then listing the stack](docs/demo.svg)
+![TDK scaffolding a backend and a frontend, then listing the stack](docs/assets/demo.svg)
 
 *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/assets/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,16 +61,31 @@ 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/drafts/show-hn.md)
 - [Architecture and repository map](docs/project-overview.md)
-- [Scale fixture measurements and caveats](docs/scale-bench.md)
+- [Scale fixture measurements and caveats](docs/benchmarks/scale-bench.md)
 
 ## Requirements and support
 
 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-frameworks/express.js

@@ -0,0 +1,50 @@
+export function getExpressIndexTemplate(name) {
+    return `import express from 'express';
+
+const app = express();
+
+// Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
+app.get('/health', (_req, res) => {
+  res.json({ status: 'ok', service: '${name}' });
+});
+
+app.get('/health/live', (_req, res) => {
+  res.json({ status: 'alive', timestamp: Date.now() });
+});
+
+app.get('/health/ready', async (_req, res) => {
+  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';
+  res.status(allReady ? 200 : 503).json({ status, dependencies });
+});
+
+app.get('/', (_req, res) => {
+  res.json({
+    service: '${name}',
+    version: '1.0.0',
+    endpoints: ['/health', '/health/live', '/health/ready']
+  });
+});
+
+const port = Number(process.env.PORT || 3000);
+
+// Bind beyond loopback: Traefik reaches the container over the Docker network.
+app.listen(port, '0.0.0.0', () => {
+  console.log('\\n🚀 ${name} running on http://localhost:' + port);
+  console.log('📊 Health check: http://localhost:' + port + '/health\\n');
+});
+`;
+}
+export const expressBackendProvider = {
+    id: "express",
+    label: "Bun + Express",
+    dependencies: { express: "^5.1.0" },
+    devDependencies: { "@types/express": "^5.0.0" },
+    createIndex: getExpressIndexTemplate,
+};
+//# sourceMappingURL=express.js.map

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

@@ -0,0 +1,41 @@
+import { getBackendIndexTemplate } from "../backend-languages/bun.js";
+import { TdkError } from "../utils/errors.js";
+import { expressBackendProvider } from "./express.js";
+/** Hono is the historical default; omitting --framework keeps the exact historical output. */
+export const DEFAULT_BACKEND_FRAMEWORK = "hono";
+export const honoBackendProvider = {
+    id: "hono",
+    label: "Bun + Hono",
+    dependencies: { hono: "^4.0.0" },
+    devDependencies: {},
+    createIndex: getBackendIndexTemplate,
+};
+export const BACKEND_FRAMEWORKS = {
+    hono: honoBackendProvider,
+    express: expressBackendProvider,
+};
+export function getBackendFramework(frameworkId) {
+    const id = (frameworkId ?? DEFAULT_BACKEND_FRAMEWORK).trim().toLowerCase();
+    const provider = Object.hasOwn(BACKEND_FRAMEWORKS, id) ? BACKEND_FRAMEWORKS[id] : undefined;
+    if (!provider) {
+        const supportedIds = Object.keys(BACKEND_FRAMEWORKS).join(", ");
+        throw new TdkError(`Unknown backend framework "${frameworkId}". Supported frameworks: ${supportedIds}.`, [`Use one of: ${supportedIds}`, `Omit --framework to use ${DEFAULT_BACKEND_FRAMEWORK}`]);
+    }
+    return provider;
+}
+/**
+ * Returns the provider for an explicit `--framework` on a backend, or undefined when none was given
+ * (the historical Hono scaffold). Python owns its runtime, so a framework cannot be combined with it.
+ */
+export function resolveBackendFramework(resourceType, frameworkId, language) {
+    if (resourceType !== "backend" || frameworkId === undefined)
+        return undefined;
+    if (language?.createFiles) {
+        throw new TdkError(`--framework cannot be combined with --language ${language.id}.`, [
+            `The ${language.id} provider owns its runtime and framework`,
+            "Drop --framework, or use --language bun",
+        ]);
+    }
+    return getBackendFramework(frameworkId);
+}
+//# sourceMappingURL=registry.js.map

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

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

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,9 @@ import { existsSync, mkdirSync } from "node:fs";
 import { isAbsolute, relative, resolve } from "node:path";
 import chalk from "chalk";
 import { Command } from "commander";
+import { resolveBackendFramework } from "../backend-frameworks/registry.js";
+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";
@@ -48,6 +51,7 @@ export const TYPE_SPECIFIC = {
         healthCheck: "/health",
     },
 };
+const BYO_RESTART_POLICIES = ["no", "on-failure", "unless-stopped", "always"];
 export function resolveByoPort(value, assignedPort, resources) {
     if (!value)
         return assignedPort;
@@ -63,8 +67,12 @@ 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);
+    // Likewise a missing backend `framework` has always meant Hono.
+    const backendFramework = resolveBackendFramework(type, frameworkId, language);
     const typeSpecific = TYPE_SPECIFIC[type];
     const base = JSON.parse(JSON.stringify(BASE_TEMPLATE));
     for (const [key, value] of Object.entries(typeSpecific)) {
@@ -75,23 +83,40 @@ 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 } : {}),
+        ...(backendFramework ? { framework: backendFramework.id } : {}),
+        ...(language ? { language: language.id } : {}),
     };
 }
 export function createPackageJson(name, type, frameworkId) {
     const isFrontend = type === "frontend";
     const framework = resolveFrontendFramework(type, frameworkId);
+    const backendFramework = resolveBackendFramework(type, frameworkId);
     return {
         name: `@project/${name}`,
         version: "0.0.1",
@@ -110,7 +135,7 @@ export function createPackageJson(name, type, frameworkId) {
             "lint:fix": "biome check . --write",
         },
         dependencies: {
-            ...(isFrontend ? {} : { hono: "^4.0.0" }),
+            ...(isFrontend ? {} : (backendFramework?.dependencies ?? { hono: "^4.0.0" })),
             ...(framework?.dependencies ?? {}),
         },
         devDependencies: {
@@ -123,6 +148,7 @@ export function createPackageJson(name, type, frameworkId) {
             "@biomejs/biome": "^2.5.13",
             ...(isFrontend ? { vite: "^5.0.0" } : {}),
             ...(framework?.devDependencies ?? {}),
+            ...(backendFramework?.devDependencies ?? {}),
         },
     };
 }
@@ -178,49 +204,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...');
@@ -311,7 +295,8 @@ export const resourceCommand = new Command("resource")
     .description("Create a new resource (service) from scratch, or register an existing one")
     .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("--framework <id>", "Framework: frontend react (default), vue, svelte, preact, lit, solid, qwik; backend hono (default), express")
+    .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)")
@@ -321,6 +306,7 @@ export const resourceCommand = new Command("resource")
     .option("--dockerfile <path>", "Path to Dockerfile relative to resource dir (for bring-your-own)")
     .option("--health-path <path>", "HTTP health check path (for bring-your-own)", "/health")
     .option("--no-proxy", "Disable the Traefik route (bring-your-own only)")
+    .option("--restart <policy>", "Compose restart policy: no, on-failure, unless-stopped, always (bring-your-own only; use no for one-shot jobs)")
     .option("--image <name>", "Docker image name instead of building from Dockerfile (for bring-your-own)")
     .option("--port <port>", "Port number (default: next free in 4000-5999)")
     .action(async (name, options) => {
@@ -371,6 +357,8 @@ export const resourceCommand = new Command("resource")
             resourceType = normalizedType;
         }
         const frontendFramework = resolveFrontendFramework(resourceType, options.framework);
+        const backendLanguage = resolveBackendLanguage(resourceType, options.language);
+        const backendFramework = resolveBackendFramework(resourceType, options.framework, backendLanguage);
         let dddEnabled = false;
         if (options.ddd) {
             if (resourceType !== "backend" && resourceType !== "worker") {
@@ -467,6 +455,18 @@ export const resourceCommand = new Command("resource")
         const nextPort = resourceType === "sdk"
             ? 0
             : assignPort(resourceType, allResources);
+        if (options.restart !== undefined) {
+            if (resourceType !== "bring-your-own") {
+                throw new TdkError("--restart can only be used with --type bring-your-own.", [
+                    "Add --type bring-your-own, or drop --restart",
+                ]);
+            }
+            if (!BYO_RESTART_POLICIES.includes(options.restart)) {
+                throw new TdkError(`Unknown --restart policy "${options.restart}".`, [
+                    `Use one of: ${BYO_RESTART_POLICIES.join(", ")}`,
+                ]);
+            }
+        }
         const assignedPort = resourceType === "bring-your-own"
             ? resolveByoPort(options.port, nextPort, allResources)
             : nextPort;
@@ -536,6 +536,7 @@ export const resourceCommand = new Command("resource")
                 healthCheckPath: options.healthPath || "/health",
                 ...(options.image ? { image: options.image } : { dockerfile }),
                 ...(options.proxy === false ? { exposeViaProxy: false } : {}),
+                ...(options.restart ? { restart: options.restart } : {}),
             };
             const { writeFileSync } = await import("node:fs");
             writeFileSync(resolve(fullPath, "service.json"), JSON.stringify(byoServiceJson, null, 2));
@@ -594,8 +595,8 @@ This file contains the resource configuration for TDK.
             }
         }
         // Prepare file generation tasks
-        const serviceJson = createServiceJson(resourceName, resourceType, stackName, assignedPort, dddEnabled ? ["ddd"] : [], frontendFramework?.id);
-        const packageJson = createPackageJson(resourceName, resourceType, frontendFramework?.id);
+        const serviceJson = createServiceJson(resourceName, resourceType, stackName, assignedPort, dddEnabled ? ["ddd"] : [], frontendFramework?.id ?? backendFramework?.id, options.language === undefined ? undefined : backendLanguage?.id);
+        const packageJson = createPackageJson(resourceName, resourceType, frontendFramework?.id ?? backendFramework?.id);
         const tasks = [
             {
                 type: "json",
@@ -631,7 +632,7 @@ This file contains the resource configuration for TDK.
             tasks.push({
                 type: "text",
                 filename: "src/index.ts",
-                content: getBackendIndexTemplate(resourceName),
+                content: (backendFramework?.createIndex ?? getBackendIndexTemplate)(resourceName),
                 description: "Generating backend source",
                 emoji: "💻",
             });
@@ -669,6 +670,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 +704,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/frontend-frameworks/lit.js

@@ -0,0 +1,65 @@
+export const litFrontendProvider = {
+    id: "lit",
+    label: "Lit + Vite",
+    dependencies: {
+        lit: "^3.2.0",
+    },
+    devDependencies: {},
+    compilerOptions: {},
+    createFiles(name) {
+        return [
+            {
+                filename: "index.html",
+                content: `<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${name}</title>
+  </head>
+  <body>
+    <app-root></app-root>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>
+`,
+                description: "Generating HTML template",
+                emoji: "💻",
+            },
+            {
+                filename: "src/main.ts",
+                content: `import './app-root';
+`,
+                description: "Generating Lit entry",
+                emoji: "💻",
+            },
+            {
+                filename: "src/app-root.ts",
+                content: `import { LitElement, css, html } from 'lit';
+
+export class AppRoot extends LitElement {
+  static styles = css\`
+    :host {
+      display: block;
+      padding: 2rem;
+      font-family: system-ui;
+    }
+  \`;
+
+  render() {
+    return html\`
+      <h1>${name}</h1>
+      <p>Frontend resource created with TDK</p>
+    \`;
+  }
+}
+
+customElements.define('app-root', AppRoot);
+`,
+                description: "Generating Lit app",
+                emoji: "💻",
+            },
+        ];
+    },
+};
+//# sourceMappingURL=lit.js.map