@tdk-landscape/tdk-cli-core 1.3.75 → 1.3.77

package/cli/dist/commands/project.js

@@ -1,7 +1,8 @@
 import { execFileSync } from "node:child_process";
-import { existsSync, readdirSync, readFileSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { cpSync, existsSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
 import { cwd } from "node:process";
+import { fileURLToPath } from "node:url";
 import chalk from "chalk";
 import { Command } from "commander";
 import { generateMasterConfigs, readProjectConfig } from "../generator/template-engine.js";
@@ -94,13 +95,33 @@ async function cloneProjectTemplate(templateName, targetDir) {
     }
     showCommandHeader(`Cloning template: ${templateName}`);
     showDetail(`${template.description}\n`, 0);
-    showDetail(`Source: ${template.repo}`, 0);
+    showDetail(`Source: ${template.bundledPath ? "bundled TDK example" : template.repo}`, 0);
     showDetail(`Destination: ${destination}\n`, 0);
     try {
-        execFileSync("git", ["clone", template.repo, destination], { stdio: "inherit" });
+        if (template.bundledPath) {
+            const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../../../");
+            cpSync(resolve(packageRoot, template.bundledPath), destination, { recursive: true });
+            const projectSlug = basename(destination).replace(/-/g, "_");
+            for (const file of [
+                "services/platform/messaging/docker-compose.yml",
+                "services/shop/orders-api/service.json",
+                "services/shop/orders-api/src/index.ts",
+                "services/shop/orders-worker/service.json",
+                "services/shop/orders-worker/src/index.ts",
+            ]) {
+                const copiedPath = join(destination, file);
+                const contents = readFileSync(copiedPath, "utf-8");
+                writeFileSync(copiedPath, contents.replaceAll("tdk_example", projectSlug));
+            }
+        }
+        else {
+            execFileSync("git", ["clone", template.repo, destination], { stdio: "inherit" });
+        }
     }
     catch {
-        showErrorAndExit("git clone failed. Check you have git installed and network access.");
+        showErrorAndExit(template.bundledPath
+            ? "Bundled example copy failed. Reinstall the TDK CLI package and try again."
+            : "git clone failed. Check you have git installed and network access.");
     }
     console.log(chalk.green(`\n✅ Cloned "${templateName}" into ${dirName}/`));
     showDetail("\nNext steps:", 0);
@@ -160,6 +181,8 @@ export const projectCommand = new Command("project")
     .option("--yes", "Non-interactive mode (use defaults)")
     .option("--config-file <path>", "Load project config from existing JSON file")
     .action(async (template, options) => {
+    const { assertMachineReadyOrExit } = await import("../utils/cold-preflight.js");
+    await assertMachineReadyOrExit();
     if (template) {
         await runCommand(async () => cloneProjectTemplate(template, options.path));
         return;

package/cli/dist/commands/resource.js

@@ -7,12 +7,13 @@ import { hasDddLicense } from "../generator/extension-fetch.js";
 import { CREATABLE_RESOURCE_TYPES } from "../types/index.js";
 import { assertValid, confirmOrCancel } from "../utils/command-helpers.js";
 import { chooseResourcePath, isPathDiscovered, readDiscoveryPaths, } from "../utils/discovery-paths.js";
-import { errorFactories, requireProjectRoot, runCommand } from "../utils/errors.js";
+import { errorFactories, requireProjectRoot, runCommand, TdkError } from "../utils/errors.js";
 import { writeFilesWithProgress } from "../utils/file-helpers.js";
 import { showCommandHeader } from "../utils/formatting.js";
 import { assignPort } from "../utils/port-assignment.js";
 import { promptSelect, promptText } from "../utils/prompt.js";
 import { getDefaultFeaturesForResourceType } from "../utils/resource-features.js";
+import { SERVICE_MANIFEST_SCHEMA_VERSION } from "../utils/service-manifest.js";
 import { discoverResources } from "../utils/services.js";
 import { createKebabCaseValidator, isPathSafe, validateResourceName } from "../utils/validation.js";
 export const BASE_TEMPLATE = {
@@ -43,7 +44,25 @@ export const TYPE_SPECIFIC = {
             watch: ["src/**/*"],
         },
     },
+    "bring-your-own": {
+        healthCheck: "/health",
+    },
 };
+export function resolveByoPort(value, assignedPort, resources) {
+    if (!value)
+        return assignedPort;
+    if (!/^\d+$/.test(value)) {
+        throw new TdkError("BYO --port must be an integer from 4000 through 5999.");
+    }
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 4000 || port > 5999) {
+        throw new TdkError("BYO --port must be an integer from 4000 through 5999.");
+    }
+    if (resources.some((resource) => resource.config?.port === port)) {
+        throw new TdkError(`BYO port ${port} is already assigned to another resource.`);
+    }
+    return port;
+}
 export function createServiceJson(name, type, stack, port, extraFeatures = [], frameworkId) {
     const framework = resolveFrontendFramework(type, frameworkId);
     const typeSpecific = TYPE_SPECIFIC[type];
@@ -58,6 +77,7 @@ export function createServiceJson(name, type, stack, port, extraFeatures = [], f
     }
     return {
         ...base,
+        schemaVersion: SERVICE_MANIFEST_SCHEMA_VERSION,
         appName: name,
         appType: type,
         featuresEnabled: [...getDefaultFeaturesForResourceType(type), ...extraFeatures],
@@ -289,13 +309,19 @@ 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, sdk", "backend")
+    .option("-t, --type <type>", "Resource type: backend, frontend, worker, bring-your-own, sdk", "backend")
     .option("--framework <id>", "Frontend framework: react (default), vue")
     .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)")
     .option("--register-existing", "Register an existing resource without creating templates")
+    .option("-y, --yes", "Skip confirmation prompt", false)
     .option("--ddd", "Scaffold DDD (domain-driven design) folders + path aliases (Premium - requires TDK_LICENSE_KEY)")
+    .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("--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) => {
     await runCommand(async () => {
         const projectRoot = requireProjectRoot();
@@ -320,20 +346,28 @@ export const resourceCommand = new Command("resource")
         // Support sdk type for registering existing SDKs
         let resourceType;
         const validTypes = [...CREATABLE_RESOURCE_TYPES, "sdk"];
-        if (!validTypes.includes(options.type)) {
+        // Normalize bring-your-own aliases
+        const normalizedType = options.type === "byo" || options.type === "bring-your-own"
+            ? "bring-your-own"
+            : options.type;
+        if (!validTypes.includes(normalizedType)) {
             const selectedType = await promptSelect({
                 message: "Resource type:",
                 choices: [
                     { title: "backend - API service with HTTP endpoints", value: "backend" },
                     { title: "frontend - Web application/UI", value: "frontend" },
                     { title: "worker - Background job processor", value: "worker" },
+                    {
+                        title: "bring-your-own - Wrap an existing service. No app scaffold. Needs Dockerfile or --image.",
+                        value: "bring-your-own",
+                    },
                     { title: "sdk - Library/SDK (register existing)", value: "sdk" },
                 ],
             });
             resourceType = selectedType;
         }
         else {
-            resourceType = options.type;
+            resourceType = normalizedType;
         }
         const frontendFramework = resolveFrontendFramework(resourceType, options.framework);
         let dddEnabled = false;
@@ -400,6 +434,7 @@ export const resourceCommand = new Command("resource")
                 backend: `services/${stackName}/${resourceName}`,
                 frontend: `apps/${resourceName}`,
                 worker: `workers/${resourceName}`,
+                "bring-your-own": `services/${stackName}/${resourceName}`,
                 sdk: `packages/${resourceName}`,
             };
             finalResourcePath = defaultPaths[resourceType];
@@ -425,24 +460,28 @@ export const resourceCommand = new Command("resource")
         const shouldRegisterExisting = options.registerExisting ||
             resourceType === "sdk" ||
             (isExistingResource && hasServiceJson);
-        if (isExistingResource && !shouldRegisterExisting) {
+        if (isExistingResource && !shouldRegisterExisting && resourceType !== "bring-your-own") {
             errorFactories.directoryExists(fullPath).exit();
         }
-        const assignedPort = resourceType === "sdk"
+        const nextPort = resourceType === "sdk"
             ? 0
             : assignPort(resourceType, allResources);
+        const assignedPort = resourceType === "bring-your-own"
+            ? resolveByoPort(options.port, nextPort, allResources)
+            : nextPort;
         console.log(chalk.gray("\nResource details:"));
         console.log(chalk.gray(`  Name:  ${resourceName}`));
         console.log(chalk.gray(`  Type:  ${resourceType}`));
         console.log(chalk.gray(`  Stack: ${stackName}`));
-        console.log(chalk.gray(`  Port:  ${assignedPort || "N/A (SDK)"}`));
+        console.log(chalk.gray(`  Port: ${assignedPort || "N/A (SDK)"}`));
         console.log(chalk.gray(`  Path:  ${finalResourcePath}`));
         if (shouldRegisterExisting && hasServiceJson) {
             console.log(chalk.yellow("\n⚠️  Existing resource detected - will update service.json only"));
         }
-        const confirmed = await confirmOrCancel(shouldRegisterExisting && hasServiceJson
-            ? "\nRegister existing resource?"
-            : "\nCreate resource?");
+        const confirmed = options.yes ||
+            (await confirmOrCancel(shouldRegisterExisting && hasServiceJson
+                ? "\nRegister existing resource?"
+                : "\nCreate resource?"));
         if (!confirmed)
             return;
         // Handle existing resource registration
@@ -455,6 +494,7 @@ export const resourceCommand = new Command("resource")
             // Update with new values while preserving existing fields
             const updatedServiceJson = {
                 ...existingServiceJson,
+                schemaVersion: existingServiceJson.schemaVersion ?? SERVICE_MANIFEST_SCHEMA_VERSION,
                 appName: resourceName,
                 appType: resourceType === "sdk" ? "sdk" : existingServiceJson.appType || resourceType,
                 stack: stackName,
@@ -469,6 +509,74 @@ export const resourceCommand = new Command("resource")
             console.log(chalk.gray(`  tdk up ${stackName}`));
             return;
         }
+        // Handle bring-your-own type
+        if (resourceType === "bring-your-own") {
+            console.log(chalk.blue("\n📁 Creating bring-your-own resource..."));
+            // Parse port option
+            const port = assignedPort;
+            const dockerfile = options.dockerfile || "./Dockerfile";
+            const dockerfilePath = resolve(fullPath, dockerfile);
+            const dockerfileRelativePath = relative(fullPath, dockerfilePath);
+            if (isAbsolute(dockerfileRelativePath) ||
+                dockerfileRelativePath === ".." ||
+                dockerfileRelativePath.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`)) {
+                errorFactories.invalidPath(dockerfile).exit();
+            }
+            mkdirSync(fullPath, { recursive: true });
+            // Create service.json
+            const byoServiceJson = {
+                schemaVersion: SERVICE_MANIFEST_SCHEMA_VERSION,
+                appName: resourceName,
+                appType: "bring-your-own",
+                stack: stackName,
+                port,
+                healthCheckPath: options.healthPath || "/health",
+                ...(options.image ? { image: options.image } : { dockerfile }),
+                ...(options.proxy === false ? { exposeViaProxy: false } : {}),
+            };
+            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
+            if (!options.image && !existsSync(dockerfilePath)) {
+                mkdirSync(resolve(dockerfilePath, ".."), { recursive: true });
+                const healthConfigPath = resolve(dockerfilePath, "..", "health.conf");
+                const healthConfigRelativePath = relative(fullPath, healthConfigPath).replace(/\\/g, "/");
+                const dockerfileContent = `FROM nginx:1.27-alpine
+RUN apk add --no-cache curl
+COPY ${healthConfigRelativePath} /etc/nginx/conf.d/default.conf
+EXPOSE ${port}
+`;
+                writeFileSync(dockerfilePath, dockerfileContent);
+                const healthConfContent = `server {
+  listen ${port};
+  location /health {
+    default_type text/plain;
+    return 200 'ok';
+  }
+  location / {
+    default_type text/plain;
+    return 200 'byo';
+  }
+}
+`;
+                writeFileSync(healthConfigPath, healthConfContent);
+            }
+            // Create AGENTS.md
+            const agentsMdContent = `# AGENTS.md
+
+DO NOT DELETE service.json
+
+This file contains the resource configuration for TDK.
+`;
+            const agentsPath = resolve(fullPath, "AGENTS.md");
+            if (!existsSync(agentsPath))
+                writeFileSync(agentsPath, agentsMdContent);
+            console.log(chalk.green("\n✅ Bring-your-own resource created successfully!"));
+            console.log(chalk.gray(`\nLocation: ${fullPath}`));
+            console.log(chalk.gray(`\nNext steps:`));
+            console.log(chalk.gray(`  tdk up ${stackName}`));
+            return;
+        }
         // Create directory structure for new resources
         console.log(chalk.blue("\n📁 Creating directory structure..."));
         mkdirSync(fullPath, { recursive: true });

package/cli/dist/commands/up.js

@@ -1,17 +1,56 @@
-import { execSync } from "node:child_process";
+import { connect } from "node:net";
 import chalk from "chalk";
 import { Command } from "commander";
 import { ensureProjectRuntimeAssets } from "../generator/template-engine.js";
 import { handleDryRun } from "../utils/command-helpers.js";
 import { checkHostPorts } from "../utils/doctor-runtime.js";
-import { errorFactories, handleTiltFailure, withTiltCheck } from "../utils/errors.js";
+import { errorFactories, handleTiltFailure, requireProjectRoot, runCommand, showErrorAndExit, withTiltCheck, } from "../utils/errors.js";
 import { formatCount } from "../utils/formatting.js";
 import { findProjectRoot } from "../utils/paths.js";
 import { findAvailablePort } from "../utils/port-assignment.js";
 import { appendHealthPath, resolveSubdomainBases } from "../utils/service-urls.js";
 import { discoverResources, discoverStacks, getResourcesForStack, stackExists, } from "../utils/services.js";
 import { buildTiltUpArgs, runTilt } from "../utils/tilt.js";
+import { stopTiltOnPort } from "../utils/tilt-process.js";
 import { enableDiscoveredStacks } from "./project.js";
+export function formatUpSuccess(port, appUrls = []) {
+    return [
+        "TDK is up.",
+        `Tilt UI: http://localhost:${port}`,
+        "App URLs:",
+        ...(appUrls.length > 0
+            ? appUrls.slice(0, 5).map((url) => `  ${url}`)
+            : ["  run: tdk networks"]),
+        "Stop: tdk down",
+    ];
+}
+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.";
+}
+function waitForTiltUi(port, timeoutMs = 30_000) {
+    return new Promise((resolve) => {
+        const deadline = Date.now() + timeoutMs;
+        const attempt = () => {
+            const socket = connect({ host: "127.0.0.1", port });
+            let settled = false;
+            const finish = (ready) => {
+                if (settled)
+                    return;
+                settled = true;
+                socket.destroy();
+                if (ready || Date.now() >= deadline)
+                    resolve(ready);
+                else
+                    setTimeout(attempt, 250);
+            };
+            socket.once("connect", () => finish(true));
+            socket.once("error", () => finish(false));
+        };
+        attempt();
+    });
+}
 export const upCommand = new Command("up")
     .description("Start all services (optionally filtered by stack)")
     .alias("deploy")
@@ -21,15 +60,26 @@ export const upCommand = new Command("up")
     .option("--dry-run", "Show what would be started without starting", false)
     .option("-f, --force", "Kill existing Tilt process before starting", false)
     .action(async (stackName, options) => {
-    await withTiltCheck(async () => {
-        const projectRoot = findProjectRoot() ?? process.cwd();
-        const copiedAssets = ensureProjectRuntimeAssets(projectRoot);
-        if (copiedAssets.length > 0 && options.verbose && !options.quiet) {
-            console.log(chalk.gray(`Refreshed runtime assets: ${copiedAssets.join(", ")}`));
-        }
-        const newlyEnabledStacks = enableDiscoveredStacks(projectRoot);
-        if (newlyEnabledStacks.length > 0 && !options.quiet) {
-            console.log(chalk.gray(`Added ${newlyEnabledStacks.join(", ")} to the pre_alpha phase in .tdk/project.json`));
+    const platformRefusal = nativeWindowsUpRefusal(process.platform, process.env.TDK_ALLOW_NATIVE_WINDOWS);
+    if (platformRefusal)
+        showErrorAndExit(platformRefusal);
+    if (!options.dryRun) {
+        const { assertMachineReadyOrExit } = await import("../utils/cold-preflight.js");
+        await assertMachineReadyOrExit();
+    }
+    const action = async () => {
+        const projectRoot = options.dryRun
+            ? requireProjectRoot()
+            : (findProjectRoot() ?? process.cwd());
+        if (!options.dryRun) {
+            const copiedAssets = ensureProjectRuntimeAssets(projectRoot);
+            if (copiedAssets.length > 0 && options.verbose && !options.quiet) {
+                console.log(chalk.gray(`Refreshed runtime assets: ${copiedAssets.join(", ")}`));
+            }
+            const newlyEnabledStacks = enableDiscoveredStacks(projectRoot);
+            if (newlyEnabledStacks.length > 0 && !options.quiet) {
+                console.log(chalk.gray(`Added ${newlyEnabledStacks.join(", ")} to the pre_alpha phase in .tdk/project.json`));
+            }
         }
         let servicesToStart;
         let stackDescription;
@@ -52,7 +102,7 @@ export const upCommand = new Command("up")
         }
         const serviceNames = servicesToStart.map((s) => s.name);
         if (!options.quiet) {
-            console.log(chalk.blue(`Starting ${formatCount(serviceNames.length, "service")} from ${stackDescription}...`));
+            console.log(chalk.blue(`${options.dryRun ? "Would start" : "Starting"} ${formatCount(serviceNames.length, "service")} from ${stackDescription}...`));
             serviceNames.forEach((name) => {
                 console.log(chalk.gray(`  - ${name}`));
             });
@@ -93,17 +143,12 @@ export const upCommand = new Command("up")
             if (hostPorts.fix)
                 console.log(chalk.gray(`   ${hostPorts.fix}\n`));
         }
-        if (options.force && !options.quiet) {
-            console.log(chalk.yellow("Force flag set - killing any existing Tilt processes..."));
-            execSync("killall tilt 2>/dev/null || true", { shell: "/bin/sh", stdio: "pipe" });
-            await new Promise((resolve) => setTimeout(resolve, 2000));
-        }
         const basePort = 10350;
         let port = basePort;
         if (process.env.TILT_PORT) {
             port = parseInt(process.env.TILT_PORT, 10);
         }
-        else {
+        else if (!options.force) {
             const availablePort = await findAvailablePort(basePort, 10);
             if (availablePort && availablePort !== basePort) {
                 port = availablePort;
@@ -114,6 +159,13 @@ export const upCommand = new Command("up")
             }
         }
         process.env.TILT_PORT = port.toString();
+        if (options.force) {
+            if (!options.quiet) {
+                console.log(chalk.yellow(`Force flag set - stopping Tilt on port ${port} if running...`));
+            }
+            stopTiltOnPort(port);
+            await new Promise((resolve) => setTimeout(resolve, 2000));
+        }
         const tiltArgs = buildTiltUpArgs(focusServiceNames, {
             verbose: options.verbose,
             quiet: options.quiet,
@@ -123,16 +175,36 @@ export const upCommand = new Command("up")
         if (!options.quiet) {
             console.log(chalk.gray("\nRunning tilt up..."));
             console.log(chalk.gray(`Using Tiltfile: .tdk/.tdk-out/Tiltfile`));
-            console.log(chalk.blue(`📊 Tilt UI: http://localhost:${port}/\n`));
         }
-        const result = await runTilt("up", tiltArgs, {
+        const tiltRun = runTilt("up", tiltArgs, {
             verbose: options.verbose,
             quiet: options.quiet,
             inheritStdio: !options.quiet, // Suppress tilt output in quiet mode
         });
+        let printedSuccess = false;
+        const successOutput = (async () => {
+            const uiReady = await waitForTiltUi(port);
+            if (uiReady && !options.quiet) {
+                for (const line of formatUpSuccess(port))
+                    console.log(chalk.blue(line));
+                printedSuccess = true;
+            }
+        })();
+        const result = await tiltRun;
+        await successOutput;
         if (result.exitCode !== 0) {
             handleTiltFailure("up", result.exitCode);
         }
-    });
+        if (!options.quiet && result.exitCode === 0 && !printedSuccess) {
+            for (const line of formatUpSuccess(port))
+                console.log(chalk.blue(line));
+        }
+    };
+    if (options.dryRun) {
+        await runCommand(action);
+    }
+    else {
+        await withTiltCheck(action);
+    }
 });
 //# sourceMappingURL=up.js.map