@tdk-landscape/tdk-cli-core 1.3.91 → 1.3.93

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

@@ -0,0 +1,87 @@
+export function getMcpIndexTemplate(name) {
+    return `import { createServer } from 'node:http';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { z } from 'zod';
+
+// A new McpServer per request keeps the endpoint stateless, so there is no session to lose when the container restarts.
+function buildServer() {
+  const server = new McpServer({ name: '${name}', version: '1.0.0' });
+
+  // Add your tools, resources and prompts here. This one is a placeholder you can delete.
+  server.registerTool(
+    'echo',
+    { description: 'Echo a message back', inputSchema: { message: z.string() } },
+    async ({ message }) => ({ content: [{ type: 'text', text: message }] })
+  );
+
+  return server;
+}
+
+async function readBody(req: import('node:http').IncomingMessage) {
+  const chunks: Buffer[] = [];
+  for await (const chunk of req) chunks.push(chunk as Buffer);
+  const raw = Buffer.concat(chunks).toString('utf8');
+  return raw ? JSON.parse(raw) : undefined;
+}
+
+const httpServer = createServer(async (req, res) => {
+  const path = (req.url ?? '/').split('?')[0];
+
+  // Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
+  if (path === '/health') {
+    res.setHeader('content-type', 'application/json');
+    res.end(JSON.stringify({ status: 'ok', service: '${name}' }));
+    return;
+  }
+
+  // MCP over Streamable HTTP. Clients POST JSON-RPC here.
+  if (path === '/mcp') {
+    if (req.method !== 'POST') {
+      res.statusCode = 405;
+      res.setHeader('allow', 'POST');
+      res.setHeader('content-type', 'application/json');
+      res.end(JSON.stringify({ jsonrpc: '2.0', error: { code: -32000, message: 'Method not allowed' }, id: null }));
+      return;
+    }
+
+    const server = buildServer();
+    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+    res.on('close', () => {
+      transport.close();
+      server.close();
+    });
+    await server.connect(transport);
+    await transport.handleRequest(req, res, await readBody(req));
+    return;
+  }
+
+  res.statusCode = 404;
+  res.setHeader('content-type', 'application/json');
+  res.end(JSON.stringify({ error: 'not_found' }));
+});
+
+const port = Number(process.env.PORT || 3000);
+
+// Bind beyond loopback: Traefik reaches the container over the Docker network.
+httpServer.listen(port, '0.0.0.0', () => {
+  console.log('\\n🚀 ${name} MCP server on http://localhost:' + port + '/mcp');
+  console.log('📊 Health check: http://localhost:' + port + '/health\\n');
+});
+`;
+}
+/**
+ * The scaffold for \`--type mcp\`. It is not in BACKEND_FRAMEWORKS: \`mcp\` is a resource type of its own, not a \`--framework\`
+ * choice for a backend.
+ */
+export const mcpBackendProvider = {
+    id: "mcp",
+    label: "Bun + Model Context Protocol server",
+    dependencies: {
+        "@modelcontextprotocol/sdk": "^1.32.0",
+        zod: "^4.0.0",
+    },
+    devDependencies: {},
+    createIndex: getMcpIndexTemplate,
+};
+//# sourceMappingURL=mcp.js.map

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

@@ -5,6 +5,7 @@ import { expressBackendProvider } from "./express.js";
 import { fastifyBackendProvider } from "./fastify.js";
 import { h3BackendProvider } from "./h3.js";
 import { koaBackendProvider } from "./koa.js";
+import { mcpBackendProvider } from "./mcp.js";
 import { nestBackendProvider } from "./nestjs.js";
 /** Hono is the historical default; omitting --framework keeps the exact historical output. */
 export const DEFAULT_BACKEND_FRAMEWORK = "hono";
@@ -38,6 +39,21 @@ export function getBackendFramework(frameworkId) {
  * (the historical Hono scaffold). Python owns its runtime, so a framework cannot be combined with it.
  */
 export function resolveBackendFramework(resourceType, frameworkId, language) {
+    // `mcp` is a resource type with one fixed scaffold, so a framework choice does not apply to it.
+    if (resourceType === "mcp") {
+        if (frameworkId !== undefined) {
+            throw new TdkError("--framework cannot be combined with --type mcp.", [
+                "An mcp resource always scaffolds a Model Context Protocol server",
+                "Drop --framework, or use --type backend --framework <id>",
+            ]);
+        }
+        if (language?.createFiles) {
+            throw new TdkError(`--language ${language.id} cannot be combined with --type mcp.`, [
+                "An mcp resource is a Bun service; drop --language",
+            ]);
+        }
+        return mcpBackendProvider;
+    }
     if (resourceType !== "backend" || frameworkId === undefined)
         return undefined;
     if (language?.createFiles) {

package/cli/dist/commands/completion.js

@@ -42,7 +42,7 @@ _tdk_completions() {
             return 0
             ;;
         --type)
-            COMPREPLY=( $(compgen -W "backend frontend worker" -- \${cur}) )
+            COMPREPLY=( $(compgen -W "backend frontend worker mcp" -- \${cur}) )
             return 0
             ;;
         --stack)
@@ -94,7 +94,7 @@ _tdk() {
             ;;
         resource)
             _arguments 
-                '--type[Resource type]:type:(backend frontend worker)' 
+                '--type[Resource type]:type:(backend frontend worker mcp)' 
                 '--stack[Assign to stack]:stack:_tdk_stacks' 
                 '1:resource name:'
             ;;
@@ -196,7 +196,7 @@ complete -c tdk -l verbose -d 'Enable verbose output'
 
 # Command-specific completions
 # resource command options
-complete -c tdk -n '__fish_seen_subcommand_from resource' -l type -d 'Resource type' -a 'backend frontend worker'
+complete -c tdk -n '__fish_seen_subcommand_from resource' -l type -d 'Resource type' -a 'backend frontend worker mcp'
 complete -c tdk -n '__fish_seen_subcommand_from resource' -l stack -d 'Assign to stack' -a '(tdk stacks 2>/dev/null | string match -r "^  - " | string replace "  - " "")'
 
 # resources command options

package/cli/dist/commands/doctor.js

@@ -15,6 +15,7 @@ import { formatCount } from "../utils/formatting.js";
 import { getHostPortPlan } from "../utils/host-port-config.js";
 import { createHostPortPlan } from "../utils/host-port-plan.js";
 import { findProjectRoot } from "../utils/paths.js";
+import { isApiServiceType } from "../utils/resource-kind.js";
 import { buildHealthTargets, pingHealthTargets } from "../utils/service-urls.js";
 import { discoverResourcesFromRoot } from "../utils/services.js";
 import { findOnPath } from "../utils/which.js";
@@ -325,7 +326,7 @@ export async function checkBun(exec = execAsync) {
         };
     }
     const resources = discoverResourcesFromRoot(projectRoot);
-    const hasGeneratedJsServices = resources.some((resource) => resource.config?.appType === "backend" ||
+    const hasGeneratedJsServices = resources.some((resource) => isApiServiceType(resource.config?.appType) ||
         resource.config?.appType === "frontend" ||
         resource.config?.appType === "worker");
     if (!hasGeneratedJsServices) {
@@ -382,10 +383,15 @@ function checkEnvironmentVariables() {
             fix: "Edit .env and provide values for empty variables",
         };
     }
+    // `validateEnvFile` also reports non-fatal problems (for example a DATABASE_URL password that differs from DB_PASSWORD). The
+    // "no .env yet" notice is not one of them: that case is reported as missing keys above.
+    const warnings = validation.warnings.filter((warning) => !warning.startsWith(".env file not found"));
     return {
         name: "Environment Variables",
         didPass: true,
-        message: "All required environment variables are set",
+        message: warnings.length > 0
+            ? `All required environment variables are set (warning: ${warnings.join("; ")})`
+            : "All required environment variables are set",
     };
 }
 function checkMasterConfigs() {

package/cli/dist/commands/networks.js

@@ -11,6 +11,7 @@ import { createHostPortPlan } from "../utils/host-port-plan.js";
 import { createMachineEnvelope, writeMachineError } from "../utils/machine-output.js";
 import { findProjectRoot } from "../utils/paths.js";
 import { checkPortStatus } from "../utils/port-assignment.js";
+import { isApiServiceType } from "../utils/resource-kind.js";
 import { isValidPort, sanitizeForShell } from "../utils/validation.js";
 import { findOnPath } from "../utils/which.js";
 function execSafe(command, args, options = {}) {
@@ -181,7 +182,7 @@ export const networksCommand = new Command("networks")
             .filter((s) => typeof s.config?.basePath === "string")
             .map(async (s) => {
             const basePath = s.config.basePath.replace(/^\//, "");
-            const isBackend = s.config?.appType === "backend";
+            const isBackend = isApiServiceType(s.config?.appType);
             const host = isBackend ? apiDomain : appDomain;
             const url = `http://${host}:${httpPort}/${basePath}`;
             const port = s.config.port;

package/cli/dist/commands/project.js

@@ -7,7 +7,7 @@ import chalk from "chalk";
 import { Command } from "commander";
 import { generateMasterConfigs, readProjectConfig } from "../generator/template-engine.js";
 import { MASTER_CONFIG_FILES } from "../utils/constants.js";
-import { ensureEnvFile, validateEnvFile } from "../utils/env-validator.js";
+import { completeEnvFile, ensureEnvFile, validateEnvFile } from "../utils/env-validator.js";
 import { errorFactories, runCommand, showErrorAndExit } from "../utils/errors.js";
 import { ensureDirectory, ensureGitignore, writeJsonFile } from "../utils/file-helpers.js";
 import { showCancelled, showCommandHeader, showDetail, showStep, showSuccess, } from "../utils/formatting.js";
@@ -244,6 +244,12 @@ export const projectCommand = new Command("project")
             if (ensureEnvFile(projectRoot)) {
                 showSuccess("Created: .env (the defaults work as-is)");
             }
+            else {
+                const added = completeEnvFile(projectRoot);
+                if (added.length > 0) {
+                    showSuccess(`Updated: .env (added ${added.join(", ")}; existing values unchanged)`);
+                }
+            }
             const ignored = ensureGitignore(projectRoot);
             if (ignored.length > 0) {
                 showSuccess(`Added to .gitignore: ${ignored.join(", ")}`);
@@ -387,7 +393,14 @@ export const projectCommand = new Command("project")
             showSuccess("Created: .env (the defaults work as-is)");
         }
         else {
-            showSuccess("Found: .env (environment already configured)");
+            // An .env from an older CLI lacks keys a newer one expects; add them without changing anything already there.
+            const added = completeEnvFile(projectRoot);
+            if (added.length > 0) {
+                showSuccess(`Updated: .env (added ${added.join(", ")}; existing values unchanged)`);
+            }
+            else {
+                showSuccess("Found: .env (environment already configured)");
+            }
         }
         const envValidation = validateEnvFile(projectRoot);
         if (envValidation.missing.length > 0) {

package/cli/dist/commands/resource.js

@@ -21,7 +21,8 @@ import { discoverResources } from "../utils/services.js";
 import { createKebabCaseValidator, isPathSafe, validateResourceName } from "../utils/validation.js";
 export const BASE_TEMPLATE = {
     port: 0, // Will be assigned
-    dependencies: [],
+    // `dependsOn` is the current name; `dependencies` is deprecated and `tdk doctor` warns about it, so a fresh scaffold must not write it.
+    dependsOn: [],
     build: {
         dockerfile: "Dockerfile",
         context: ".",
@@ -33,7 +34,7 @@ export const BASE_TEMPLATE = {
 };
 export const TYPE_SPECIFIC = {
     backend: {
-        healthCheck: "/health",
+        healthCheckPath: "/health",
     },
     frontend: {
         dev: {
@@ -47,8 +48,11 @@ export const TYPE_SPECIFIC = {
             watch: ["src/**/*"],
         },
     },
+    mcp: {
+        healthCheckPath: "/health",
+    },
     "bring-your-own": {
-        healthCheck: "/health",
+        healthCheckPath: "/health",
     },
 };
 const BYO_RESTART_POLICIES = ["no", "on-failure", "unless-stopped", "always"];
@@ -85,9 +89,6 @@ export function createServiceJson(name, type, stack, port, extraFeatures = [], f
     }
     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;
@@ -109,10 +110,24 @@ export function createServiceJson(name, type, stack, port, extraFeatures = [], f
         stack,
         port,
         ...(framework ? { framework: framework.id } : {}),
-        ...(backendFramework ? { framework: backendFramework.id } : {}),
+        ...(backendFramework && type !== "mcp" ? { framework: backendFramework.id } : {}),
         ...(language ? { language: language.id } : {}),
     };
 }
+export function createByoServiceJson(name, stack, port, options) {
+    return {
+        $schema: SERVICE_MANIFEST_SCHEMA_URL,
+        schemaVersion: SERVICE_MANIFEST_SCHEMA_VERSION,
+        appName: name,
+        appType: "bring-your-own",
+        stack,
+        port,
+        healthCheckPath: options.healthCheckPath,
+        ...(options.image ? { image: options.image } : { dockerfile: options.dockerfile }),
+        ...(options.exposeViaProxy === false ? { exposeViaProxy: false } : {}),
+        ...(options.restart ? { restart: options.restart } : {}),
+    };
+}
 export function createPackageJson(name, type, frameworkId) {
     const isFrontend = type === "frontend";
     const framework = resolveFrontendFramework(type, frameworkId);
@@ -296,7 +311,7 @@ describe('${name}', () => {
 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("-t, --type <type>", "Resource type: backend, frontend, worker, mcp, bring-your-own, sdk", "backend")
     .option("--framework <id>", "Framework: frontend react (default), vue, svelte, preact, lit, solid, qwik, vanilla; backend hono (default), express, elysia, fastify, nestjs, koa, h3")
     .option("--language <id>", "Backend language: bun (default), python, go, rust")
     .option("-s, --stack <stack>", "Stack to assign resource to", "default")
@@ -346,6 +361,7 @@ export const resourceCommand = new Command("resource")
                     { title: "backend - API service with HTTP endpoints", value: "backend" },
                     { title: "frontend - Web application/UI", value: "frontend" },
                     { title: "worker - Background job processor", value: "worker" },
+                    { title: "mcp - Model Context Protocol server (HTTP)", value: "mcp" },
                     {
                         title: "bring-your-own - Wrap an existing service. No app scaffold. Needs Dockerfile or --image.",
                         value: "bring-your-own",
@@ -361,6 +377,9 @@ export const resourceCommand = new Command("resource")
         const frontendFramework = resolveFrontendFramework(resourceType, options.framework);
         const backendLanguage = resolveBackendLanguage(resourceType, options.language);
         const backendFramework = resolveBackendFramework(resourceType, options.framework, backendLanguage);
+        // The id passed on to the file generators. An mcp resource has one fixed scaffold and no `framework` setting, so it passes none
+        // (its provider is selected by the resource type itself).
+        const scaffoldFrameworkId = resourceType === "mcp" ? undefined : (frontendFramework?.id ?? backendFramework?.id);
         let dddEnabled = false;
         if (options.ddd) {
             if (resourceType !== "backend" && resourceType !== "worker") {
@@ -425,6 +444,7 @@ export const resourceCommand = new Command("resource")
                 backend: `services/${stackName}/${resourceName}`,
                 frontend: `apps/${resourceName}`,
                 worker: `workers/${resourceName}`,
+                mcp: `services/${stackName}/${resourceName}`,
                 "bring-your-own": `services/${stackName}/${resourceName}`,
                 sdk: `packages/${resourceName}`,
             };
@@ -528,18 +548,13 @@ export const resourceCommand = new Command("resource")
             }
             mkdirSync(fullPath, { recursive: true });
             // Create service.json
-            const byoServiceJson = {
-                $schema: SERVICE_MANIFEST_SCHEMA_URL,
-                schemaVersion: SERVICE_MANIFEST_SCHEMA_VERSION,
-                appName: resourceName,
-                appType: "bring-your-own",
-                stack: stackName,
-                port,
+            const byoServiceJson = createByoServiceJson(resourceName, stackName, port, {
                 healthCheckPath: options.healthPath || "/health",
-                ...(options.image ? { image: options.image } : { dockerfile }),
+                dockerfile,
+                ...(options.image ? { image: options.image } : {}),
                 ...(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));
             // Create Dockerfile stub if no image provided and dockerfile doesn't exist
@@ -602,8 +617,8 @@ This file contains the resource configuration for TDK.
             }
         }
         // Prepare file generation tasks
-        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 serviceJson = createServiceJson(resourceName, resourceType, stackName, assignedPort, dddEnabled ? ["ddd"] : [], scaffoldFrameworkId, options.language === undefined ? undefined : backendLanguage?.id);
+        const packageJson = createPackageJson(resourceName, resourceType, scaffoldFrameworkId);
         const tasks = [
             {
                 type: "json",
@@ -622,7 +637,7 @@ This file contains the resource configuration for TDK.
             {
                 type: "json",
                 filename: "tsconfig.json",
-                content: createResourceTsconfig(resourceType, frontendFramework?.id ?? backendFramework?.id),
+                content: createResourceTsconfig(resourceType, scaffoldFrameworkId),
                 description: "Generating tsconfig.json",
                 emoji: "⚙️",
             },
@@ -635,12 +650,12 @@ This file contains the resource configuration for TDK.
             },
         ];
         // Add source files based on resource type
-        if (resourceType === "backend") {
+        if (resourceType === "backend" || resourceType === "mcp") {
             tasks.push({
                 type: "text",
                 filename: "src/index.ts",
                 content: (backendFramework?.createIndex ?? getBackendIndexTemplate)(resourceName),
-                description: "Generating backend source",
+                description: resourceType === "mcp" ? "Generating MCP server source" : "Generating backend source",
                 emoji: "💻",
             });
         }

package/cli/dist/commands/up.js

@@ -3,14 +3,17 @@ import chalk from "chalk";
 import { Command } from "commander";
 import { ensureProjectRuntimeAssets } from "../generator/template-engine.js";
 import { handleDryRun } from "../utils/command-helpers.js";
+import { completeEnvFile } from "../utils/env-validator.js";
 import { errorFactories, handleTiltFailure, requireProjectRoot, runCommand, showErrorAndExit, withTiltCheck, } from "../utils/errors.js";
 import { formatCount } from "../utils/formatting.js";
 import { exportHostPortPlan, getHostPortPlan, writeSavedHostPortPlan, } from "../utils/host-port-config.js";
 import { formatHostPortPlan } from "../utils/host-port-plan.js";
 import { findProjectRoot } from "../utils/paths.js";
 import { findAvailablePort } from "../utils/port-assignment.js";
+import { isApiServiceType } from "../utils/resource-kind.js";
 import { appendHealthPath, resolveSubdomainBases } from "../utils/service-urls.js";
 import { discoverResources, discoverStacks, getResourcesForStack, stackExists, } from "../utils/services.js";
+import { buildSmokePlans, formatSmokeFailure, runSmokePlans } from "../utils/smoke.js";
 import { buildTiltUpArgs, runTilt } from "../utils/tilt.js";
 import { stopTiltOnPort } from "../utils/tilt-process.js";
 import { enableDiscoveredStacks } from "./project.js";
@@ -76,6 +79,14 @@ export const upCommand = new Command("up")
             inspectDocker: !options.dryRun,
         });
         if (!options.dryRun) {
+            // An older project's .env predates keys such as JWT_SECRET, which Compose now requires. Add what is missing (never
+            // changing an existing value) before anything starts. Only inside a real project, so a stray run never writes a .env.
+            if (findProjectRoot()) {
+                const addedEnvKeys = completeEnvFile(projectRoot);
+                if (addedEnvKeys.length > 0 && !options.quiet) {
+                    console.log(chalk.gray(`Added ${addedEnvKeys.join(", ")} to .env (generated; existing values unchanged)`));
+                }
+            }
             const copiedAssets = ensureProjectRuntimeAssets(projectRoot);
             if (copiedAssets.length > 0 && options.verbose && !options.quiet) {
                 console.log(chalk.gray(`Refreshed runtime assets: ${copiedAssets.join(", ")}`));
@@ -112,7 +123,7 @@ export const upCommand = new Command("up")
             });
             const { appBase, apiBase } = resolveSubdomainBases(hostPortPlan.ingressHttp);
             const frontends = servicesToStart.filter((s) => s.config?.appType === "frontend");
-            const backends = servicesToStart.filter((s) => s.config?.appType === "backend");
+            const backends = servicesToStart.filter((s) => isApiServiceType(s.config?.appType));
             if (frontends.length > 0) {
                 console.log(chalk.blue("\n🌍 Frontend URLs:"));
                 frontends.forEach((svc) => {
@@ -183,6 +194,10 @@ export const upCommand = new Command("up")
             quiet: options.quiet,
             inheritStdio: !options.quiet, // Suppress tilt output in quiet mode
         });
+        // Services that declare `smoke` are checked through the public URL once Tilt is up. A miss stops Tilt (containers stay for
+        // inspection; `tdk down` removes them) and fails the command.
+        const smokePlans = buildSmokePlans(servicesToStart, hostPortPlan.ingressHttp);
+        let smokeFailed = false;
         let printedSuccess = false;
         const successOutput = (async () => {
             const uiReady = await waitForTiltUi(port);
@@ -191,9 +206,30 @@ export const upCommand = new Command("up")
                     console.log(chalk.blue(line));
                 printedSuccess = true;
             }
+            if (uiReady && smokePlans.length > 0) {
+                if (!options.quiet) {
+                    console.log(chalk.gray(`Smoke check: ${smokePlans.map((p) => p.name).join(", ")}`));
+                }
+                const results = await runSmokePlans(smokePlans);
+                for (const smokeResult of results) {
+                    if (smokeResult.ok) {
+                        if (!options.quiet)
+                            console.log(chalk.green(`Smoke check passed: ${smokeResult.name}`));
+                    }
+                    else {
+                        smokeFailed = true;
+                        console.error(chalk.red(formatSmokeFailure(smokeResult)));
+                    }
+                }
+                if (smokeFailed)
+                    stopTiltOnPort(port);
+            }
         })();
         const result = await tiltRun;
         await successOutput;
+        if (smokeFailed) {
+            process.exit(1);
+        }
         if (result.exitCode !== 0) {
             handleTiltFailure("up", result.exitCode);
         }

package/cli/dist/types/index.js

@@ -1,7 +1,18 @@
+export const RESOURCE_CONFIG_APP_TYPES = [
+    "backend",
+    "frontend",
+    "library",
+    "sdk",
+    "worker",
+    "migrator",
+    "mcp",
+    "bring-your-own",
+];
 export const CREATABLE_RESOURCE_TYPES = [
     "backend",
     "frontend",
     "worker",
+    "mcp",
     "bring-your-own",
 ];
 export function isCreatableResourceType(value) {

package/cli/dist/utils/constants.js

@@ -10,6 +10,7 @@ export const VALID_RESOURCE_TYPES = [
     "sdk",
     "worker",
     "migrator",
+    "mcp",
     "bring-your-own",
 ];
 // Frontend/library/sdk services are served statically or consumed as
@@ -20,6 +21,7 @@ export const REQUIRED_PACKAGE_SCRIPTS = {
     backend: ["dev", "build", "start"],
     worker: ["dev", "build", "start"],
     migrator: ["dev", "build", "start"],
+    mcp: ["dev", "build", "start"],
     frontend: ["dev", "build"],
     library: ["dev", "build"],
     sdk: ["dev", "build"],
@@ -38,6 +40,8 @@ export const OPTIONAL_INFRA_SERVICES = [
 export const PORT_RANGES = {
     frontend: { base: 3000, min: 3000, max: 3999, range: "3000-3999" },
     backend: { base: 4000, min: 4000, max: 4999, range: "4000-4999" },
+    // An MCP server is an HTTP service, so it shares the backend-compatible range with bring-your-own.
+    mcp: { base: 4000, min: 4000, max: 5999, range: "4000-5999" },
     "bring-your-own": { base: 4000, min: 4000, max: 5999, range: "4000-5999" },
     worker: { base: 6000, min: 6000, max: 6999, range: "6000-6999" },
     health: { base: 5000, min: 5000, max: 5999, range: "5000-5999" },

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

@@ -4,6 +4,7 @@ import { createServer } from "node:net";
 import { join } from "node:path";
 import { formatCount } from "./formatting.js";
 import { findProjectRoot } from "./paths.js";
+import { isApiServiceType } from "./resource-kind.js";
 import { getProjectName } from "./service-urls.js";
 import { discoverResources, discoverResourcesFromRoot } from "./services.js";
 import { findOnPath } from "./which.js";
@@ -725,7 +726,7 @@ export function resolveHealthPaths(config) {
 export function findMissingHealthRoutes(resources) {
     const missing = [];
     for (const resource of resources) {
-        if (resource.config?.appType !== "backend")
+        if (!isApiServiceType(resource.config?.appType))
             continue;
         const srcDir = join(resource.path, "src");
         if (!existsSync(srcDir))
@@ -768,7 +769,7 @@ export function checkHealthRoutes(projectRoot = findProjectRoot() ?? process.cwd
             message: "Could not read services - skipped health route check",
         };
     }
-    const backends = resources.filter((r) => r.config?.appType === "backend");
+    const backends = resources.filter((r) => isApiServiceType(r.config?.appType));
     if (backends.length === 0) {
         return {
             name: "Health Routes",

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

@@ -5,6 +5,7 @@ import { BACKEND_LANGUAGES } from "../backend-languages/registry.js";
 import { execAsync } from "./exec-async.js";
 import { formatCount } from "./formatting.js";
 import { findProjectRoot } from "./paths.js";
+import { isApiServiceType } from "./resource-kind.js";
 import { discoverResourcesFromRoot } from "./services.js";
 /**
  * Checks for wiring mistakes that only show up minutes into `tdk up`: an image
@@ -39,7 +40,7 @@ function backendPorts(resources) {
     const ports = new Map();
     for (const resource of resources) {
         const port = resource.config?.port;
-        if (resource.config?.appType === "backend" && typeof port === "number") {
+        if (isApiServiceType(resource.config?.appType) && typeof port === "number") {
             ports.set(resource.name, port);
         }
     }