@tdk-landscape/tdk-cli-core 1.3.45 → 1.3.48

package/cli/src/commands/__tests__/doctor.test.ts

@@ -0,0 +1,557 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  checkFrontendDockerPreflight,
+  checkGeneratedProjectRuntimeAssets,
+  checkStarlarkLoadExports,
+} from "../doctor.js";
+import {
+  checkIngressPorts,
+  checkPrivateNpmRegistry,
+  checkTiltResourceHealth,
+  findForeignIngressHolders,
+  orderTiltFailures,
+  parsePublishedPortHolders,
+  parseTiltResourceFailures,
+  probeContainerRuntimeError,
+  summarizeTiltBuildError,
+} from "../../utils/doctor-runtime.js";
+
+describe("doctor frontend Docker preflight", () => {
+  let testDir: string;
+  let originalCwd: string;
+
+  beforeEach(() => {
+    originalCwd = process.cwd();
+    testDir = join(
+      tmpdir(),
+      `tdk-doctor-frontend-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+    );
+    mkdirSync(testDir, { recursive: true });
+    process.chdir(testDir);
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    if (testDir && existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  function writeFrontendProject(options: {
+    composePort: number;
+    dockerTsconfig: Record<string, unknown>;
+    mainTsx: string;
+  }) {
+    const appDir = join(testDir, "services", "app", "dashboard-app");
+    const generatedDir = join(appDir, ".autogenerated");
+    const stackGeneratedDir = join(testDir, "services", "app", ".autogenerated");
+
+    mkdirSync(generatedDir, { recursive: true });
+    mkdirSync(stackGeneratedDir, { recursive: true });
+    mkdirSync(join(appDir, "src"), { recursive: true });
+
+    writeFileSync(
+      join(appDir, "service.json"),
+      JSON.stringify(
+        {
+          appName: "dashboard-app",
+          appType: "frontend",
+          stack: "app",
+          port: 3200,
+          basePath: "/dashboard-app",
+        },
+        null,
+        2,
+      ),
+    );
+    writeFileSync(
+      join(generatedDir, "Dockerfile.app.autogenerated"),
+      "FROM nginx:alpine\nCOPY dist /usr/share/nginx/html\nEXPOSE 80\n",
+    );
+    writeFileSync(
+      join(stackGeneratedDir, "docker-compose.app.autogenerated.yml"),
+      [
+        "services:",
+        "  dashboard-app:",
+        "    labels:",
+        `      - "traefik.http.services.dashboard-app.loadbalancer.server.port=${options.composePort}"`,
+      ].join("\n"),
+    );
+    writeFileSync(
+      join(generatedDir, "tsconfig.docker.autogenerated.json"),
+      JSON.stringify(options.dockerTsconfig, null, 2),
+    );
+    writeFileSync(join(appDir, "src", "main.tsx"), options.mainTsx);
+  }
+
+  it("fails when generated Traefik routes an nginx frontend to the Vite dev port", () => {
+    writeFrontendProject({
+      composePort: 3200,
+      dockerTsconfig: { compilerOptions: { allowSyntheticDefaultImports: true } },
+      mainTsx: 'import { StrictMode } from "react";\n',
+    });
+
+    const result = checkFrontendDockerPreflight();
+
+    expect(result.didPass).toBe(false);
+    expect(result.message).toContain("nginx runtime exposes 80");
+    expect(result.message).toContain("routes to 3200");
+  });
+
+  it("fails when Docker tsconfig rejects default React imports used by the entrypoint", () => {
+    writeFrontendProject({
+      composePort: 80,
+      dockerTsconfig: { compilerOptions: { strict: true } },
+      mainTsx: ['import React from "react";', 'import ReactDOM from "react-dom/client";', ""].join(
+        "\n",
+      ),
+    });
+
+    const result = checkFrontendDockerPreflight();
+
+    expect(result.didPass).toBe(false);
+    expect(result.message).toContain("does not allow synthetic default imports");
+    expect(result.message).toContain("react-dom/client");
+  });
+
+  it("passes when generated frontend Docker metadata is internally consistent", () => {
+    writeFrontendProject({
+      composePort: 80,
+      dockerTsconfig: { compilerOptions: { strict: true } },
+      mainTsx: [
+        'import { StrictMode } from "react";',
+        'import { createRoot } from "react-dom/client";',
+        "",
+      ].join("\n"),
+    });
+
+    const result = checkFrontendDockerPreflight();
+
+    expect(result.didPass).toBe(true);
+  });
+
+  it("fails when generated Starlark loads a private exported symbol", () => {
+    const outDir = join(testDir, ".tdk", ".tdk-out");
+    const extDir = join(outDir, "tdk-cli-ext", "engine");
+    mkdirSync(extDir, { recursive: true });
+    writeFileSync(join(outDir, "Tiltfile"), 'load("./tdk-cli-ext/engine/bad.star", "Bad")\n');
+    writeFileSync(
+      join(extDir, "sablier_container_cycle.star"),
+      "_sablier_middleware_suffix = 'x'\n",
+    );
+    writeFileSync(join(extDir, "public.star"), "Docker = struct()\n");
+    writeFileSync(
+      join(extDir, "bad.star"),
+      [
+        "Bad = struct()",
+        'load("./sablier_container_cycle.star", "_sablier_middleware_suffix")',
+        'load("./public.star", _Docker = "Docker")',
+        "",
+      ].join("\n"),
+    );
+
+    const result = checkStarlarkLoadExports();
+
+    expect(result.didPass).toBe(false);
+    expect(result.message).toContain("_sablier_middleware_suffix");
+    expect(result.message).not.toContain("_Docker");
+  });
+
+  it("fails when generated Starlark loads a missing relative file", () => {
+    const outDir = join(testDir, ".tdk", ".tdk-out");
+    const extDir = join(outDir, "tdk-cli-ext", "discovery");
+    mkdirSync(extDir, { recursive: true });
+    writeFileSync(
+      join(outDir, "Tiltfile"),
+      'load("./tdk-cli-ext/discovery/daemon.star", "Daemon")\n',
+    );
+    writeFileSync(join(extDir, "daemon.star"), 'load("./resource_registry.star", "CacheOps")\n');
+
+    const result = checkStarlarkLoadExports();
+
+    expect(result.didPass).toBe(false);
+    expect(result.message).toContain("Missing relative load targets");
+    expect(result.message).toContain("resource_registry.star");
+  });
+
+  it("passes when generated Starlark only uses private local aliases", () => {
+    const extDir = join(testDir, ".tdk", ".tdk-out", "tdk-cli-ext", "engine");
+    mkdirSync(extDir, { recursive: true });
+    writeFileSync(join(extDir, "public.star"), "Docker = struct()\n");
+    writeFileSync(join(extDir, "good.star"), 'load("./public.star", _Docker = "Docker")\n');
+
+    const result = checkStarlarkLoadExports();
+
+    expect(result.didPass).toBe(true);
+  });
+});
+
+describe("doctor generated runtime asset preflight", () => {
+  let testDir: string;
+  let originalCwd: string;
+
+  beforeEach(() => {
+    originalCwd = process.cwd();
+    testDir = join(
+      tmpdir(),
+      `tdk-doctor-runtime-assets-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+    );
+    mkdirSync(join(testDir, ".tdk"), { recursive: true });
+    writeFileSync(
+      join(testDir, ".tdk", "project.json"),
+      JSON.stringify({
+        version: "1.0",
+        project: { name: "asset-check", version: "1.0.0" },
+        phases: {
+          pre_alpha: { name: "Pre-Alpha", description: "", enabledStacks: [] },
+          alpha: { name: "Alpha", description: "", enabledStacks: [] },
+          beta: { name: "Beta", description: "", enabledStacks: [] },
+          out_of_scope: { name: "Out of Scope", description: "", enabledStacks: [] },
+        },
+        optional_infra: {
+          monitoring: false,
+          elk: false,
+          debezium: false,
+          golden_image: true,
+          verdaccio: false,
+        },
+        discovery: { paths: ["services/*/*"] },
+        overrides: {},
+      }),
+    );
+    process.chdir(testDir);
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    if (testDir && existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  function writeRequiredRuntimeAssets() {
+    const templateDir = join(testDir, "shared-platform-engineering", "docker-templates");
+    mkdirSync(templateDir, { recursive: true });
+    for (const file of [
+      "install-deps.sh",
+      "bun-hoisted-symlink-fix.sh",
+      "prisma-bun-client-link-fix.sh",
+      "prisma-normalize-client.sh",
+    ]) {
+      writeFileSync(join(templateDir, file), "#!/bin/sh\n");
+    }
+  }
+
+  it("fails when the root workspace package.json and Docker template scripts are missing", () => {
+    const result = checkGeneratedProjectRuntimeAssets();
+
+    expect(result.didPass).toBe(false);
+    expect(result.message).toContain("package.json");
+    expect(result.message).toContain("install-deps.sh");
+    expect(result.fix).toContain("tdk project");
+  });
+
+  it("passes when generated Docker runtime assets are present", () => {
+    writeFileSync(
+      join(testDir, "package.json"),
+      JSON.stringify({ name: "asset-check", private: true, workspaces: ["services/*/*"] }),
+    );
+    writeRequiredRuntimeAssets();
+
+    const result = checkGeneratedProjectRuntimeAssets();
+
+    expect(result.didPass).toBe(true);
+    expect(result.message).toContain("runtime assets are present");
+  });
+});
+
+describe("doctor ingress + tilt runtime checks", () => {
+  it("detects a foreign Traefik holding host port 80", () => {
+    const dockerPs = [
+      "tdk_saas_starter_traefik\t0.0.0.0:80->80/tcp,:::80->80/tcp,0.0.0.0:8080->8080/tcp",
+      "beauty_crm_postgres\t0.0.0.0:5432->5432/tcp",
+    ].join("\n");
+
+    const holders = parsePublishedPortHolders(dockerPs, [80, 443]);
+    expect(holders).toHaveLength(1);
+    expect(holders[0]?.name).toBe("tdk_saas_starter_traefik");
+    expect(holders[0]?.publishedPorts).toContain(80);
+
+    const foreign = findForeignIngressHolders(holders, "beauty_crm");
+    expect(foreign).toHaveLength(1);
+
+    const result = checkIngressPorts((() => dockerPs) as never, "beauty-crm");
+    expect(result.didPass).toBe(false);
+    expect(result.message).toContain("tdk_saas_starter_traefik");
+    expect(result.fix).toContain("docker stop");
+  });
+
+  it("passes when this project's Traefik owns the ingress ports", () => {
+    const dockerPs =
+      "beauty_crm_traefik\t0.0.0.0:80->80/tcp,:::80->80/tcp,0.0.0.0:443->443/tcp";
+    const result = checkIngressPorts((() => dockerPs) as never, "beauty-crm");
+    expect(result.didPass).toBe(true);
+    expect(result.message).toContain("beauty_crm_traefik");
+  });
+
+  it("fails doctor when Tilt reports Traefik update errors that block apps", () => {
+    const payload = {
+      items: [
+        {
+          metadata: { name: "traefik" },
+          status: {
+            updateStatus: "error",
+            runtimeStatus: "unknown",
+            buildHistory: [
+              {
+                error:
+                  'Bind for 0.0.0.0:80 failed: port is already allocated\nerror: exit status 1',
+              },
+            ],
+          },
+        },
+        {
+          metadata: { name: "salon-management-frontend" },
+          status: { updateStatus: "pending", runtimeStatus: "pending" },
+        },
+        {
+          metadata: { name: "postgres" },
+          status: { updateStatus: "ok", runtimeStatus: "ok" },
+        },
+      ],
+    };
+
+    const parsed = parseTiltResourceFailures(JSON.stringify(payload));
+    expect(parsed.failures).toHaveLength(1);
+    expect(parsed.failures[0]?.name).toBe("traefik");
+    expect(parsed.pendingCount).toBe(1);
+
+    const result = checkTiltResourceHealth((() => JSON.stringify(payload)) as never);
+    expect(result.didPass).toBe(false);
+    expect(result.message).toContain("traefik");
+    expect(result.message).toContain("port 80");
+    expect(result.message).toContain("pending");
+    expect(result.fix).toMatch(/docker ps --filter publish=80|Free the conflicting/);
+  });
+
+  it("skips tilt resource check when tilt is not running", () => {
+    const result = checkTiltResourceHealth((() => {
+      throw new Error("tilt not running");
+    }) as never);
+    expect(result.isSkipped).toBe(true);
+    expect(result.didPass).toBe(true);
+  });
+
+  it("summarizes ConnectionRefused package manifest errors from build logs", () => {
+    const raw = [
+      "error: ConnectionRefused downloading package manifest @tdk-landscape/eventing",
+      "error: ConnectionRefused downloading package manifest @beauty-crm/identity-js-sdk",
+      "error: ConnectionRefused downloading package manifest @tdk-landscape/observability",
+      'ImageBuild: process "/bin/sh -c bun install --production --cache-dir=/cache/bun" did not complete successfully: exit code: 1',
+    ].join("\n");
+
+    const summary = summarizeTiltBuildError(raw);
+    expect(summary).toContain("ConnectionRefused");
+    expect(summary).toContain("@tdk-landscape/eventing");
+    expect(summary).toContain("Verdaccio");
+  });
+
+  it("summarizes truncated bun install ImageBuild exits as registry failures", () => {
+    const summary = summarizeTiltBuildError(
+      'ImageBuild: process "/bin/sh -c bun install --production --cache-dir=/cache/bun" did not complete successfully: exit code: 1',
+    );
+    expect(summary).toMatch(/dependency install failed|Verdaccio|ConnectionRefused/i);
+  });
+
+  it("summarizes missing compose images for run-only resources", () => {
+    const summary = summarizeTiltBuildError(
+      'Command "docker compose -p appointment-planner-autogenerated -f .../docker-compose.app.autogenerated.yml up -d --no-build appointment-planner-builder-backend" failed: exit status 1',
+    );
+    expect(summary).toContain("appointment-planner-builder-backend");
+    expect(summary).toMatch(/image is missing|ImageBuild|run-only/i);
+  });
+
+  it("lists every failed resource even when an infra resource also failed", () => {
+    const payload = {
+      items: [
+        {
+          metadata: { name: "nats-http-bridge" },
+          status: { updateStatus: "ok", runtimeStatus: "error" },
+        },
+        {
+          metadata: { name: "appointment-management-backend" },
+          status: {
+            updateStatus: "error",
+            runtimeStatus: "unknown",
+            buildHistory: [
+              {
+                error:
+                  'ImageBuild: process "/bin/sh -c bun run build" did not complete successfully: exit code: 1',
+              },
+            ],
+          },
+        },
+        {
+          metadata: { name: "appointment-management-backend-run-only" },
+          status: {
+            updateStatus: "error",
+            runtimeStatus: "not_applicable",
+            buildHistory: [
+              {
+                error:
+                  'Command "docker compose -p appointment-autogenerated -f x.yml up -d --no-build appointment-management-backend" failed: exit status 1',
+              },
+            ],
+          },
+        },
+      ],
+    };
+
+    const result = checkTiltResourceHealth(((command: string) => {
+      if (command.includes("tilt get uiresources")) {
+        return JSON.stringify(payload);
+      }
+      if (command.startsWith("docker ps")) {
+        return "platform-autogenerated-nats-http-bridge-1\n";
+      }
+      if (command.includes("docker logs")) {
+        return 'error: Failed to start NATS HTTP Bridge {"error":"Connection error: getaddrinfo ENOTFOUND"}\nInitializing Kafka consumer... {"brokers":["kafka:9092"]}';
+      }
+      throw new Error(`unexpected exec: ${command}`);
+    }) as typeof import("node:child_process").execSync);
+
+    expect(result.didPass).toBe(false);
+    expect(result.message).toContain("3 failed resources");
+    expect(result.message).toContain("nats-http-bridge");
+    expect(result.message).toContain("appointment-management-backend");
+    expect(result.message).toContain("appointment-management-backend-run-only");
+    expect(result.message).toMatch(/Kafka broker unreachable|kafka:9092/i);
+    expect(result.message).toMatch(/bun run build/i);
+    expect(result.fix).toMatch(/Kafka/i);
+    expect(
+      orderTiltFailures(parseTiltResourceFailures(JSON.stringify(payload)).failures)[0]?.name,
+    ).toBe("nats-http-bridge");
+  });
+
+  it("probes docker logs for Kafka ENOTFOUND runtime crashes", () => {
+    const exec = ((command: string) => {
+      if (command.startsWith("docker ps")) {
+        return "platform-autogenerated-nats-http-bridge-1\n";
+      }
+      if (command.includes("docker logs")) {
+        return "getaddrinfo ENOTFOUND\nbroker kafka:9092\nFailed to start NATS HTTP Bridge";
+      }
+      return "";
+    }) as typeof import("node:child_process").execSync;
+
+    const summary = probeContainerRuntimeError("nats-http-bridge", exec);
+    expect(summary).toMatch(/Kafka broker unreachable/);
+  });
+
+  it("summarizes bun run build ImageBuild failures", () => {
+    const summary = summarizeTiltBuildError(
+      'ImageBuild: process "/bin/sh -c bun run build" did not complete successfully: exit code: 1',
+    );
+    expect(summary).toMatch(/bun run build|TypeScript|Tilt/i);
+  });
+
+  it("surfaces registry-oriented fix when ImageBuild dependency installs fail", () => {
+    const payload = {
+      items: [
+        {
+          metadata: { name: "appointment-management-backend" },
+          status: {
+            updateStatus: "error",
+            runtimeStatus: "unknown",
+            buildHistory: [
+              {
+                error:
+                  'ImageBuild: process "/bin/sh -c bun install --production --cache-dir=/cache/bun" did not complete successfully: exit code: 1',
+              },
+            ],
+          },
+        },
+        {
+          metadata: { name: "salon-management-frontend" },
+          status: { updateStatus: "pending", runtimeStatus: "pending" },
+        },
+      ],
+    };
+
+    const result = checkTiltResourceHealth((() => JSON.stringify(payload)) as never);
+    expect(result.didPass).toBe(false);
+    expect(result.message).toContain("appointment-management-backend");
+    expect(result.message).toMatch(/dependency install failed|Verdaccio|ConnectionRefused/i);
+    expect(result.fix).toMatch(/verdaccio:start|publish/i);
+  });
+
+  it("fails private registry check when Verdaccio is enabled but unreachable", () => {
+    const projectRoot = join(
+      tmpdir(),
+      `tdk-doctor-registry-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+    );
+    mkdirSync(join(projectRoot, ".tdk"), { recursive: true });
+    writeFileSync(
+      join(projectRoot, ".tdk", "project.json"),
+      JSON.stringify({
+        project: { name: "demo" },
+        optional_infra: { verdaccio: true },
+        phases: {},
+      }),
+    );
+
+    const execDown = ((command: string) => {
+      if (command.startsWith("docker ps")) {
+        return "";
+      }
+      if (command.includes("curl")) {
+        throw new Error("Failed to connect to localhost port 4873");
+      }
+      return "";
+    }) as typeof import("node:child_process").execSync;
+
+    const result = checkPrivateNpmRegistry(execDown, projectRoot, "http://localhost:4873");
+
+    expect(result.didPass).toBe(false);
+    expect(result.message).toContain("ConnectionRefused");
+    expect(result.fix).toMatch(/verdaccio:start/);
+
+    rmSync(projectRoot, { recursive: true, force: true });
+  });
+
+  it("passes private registry check when Verdaccio responds", () => {
+    const projectRoot = join(
+      tmpdir(),
+      `tdk-doctor-registry-ok-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+    );
+    mkdirSync(join(projectRoot, ".tdk"), { recursive: true });
+    writeFileSync(
+      join(projectRoot, ".tdk", "project.json"),
+      JSON.stringify({
+        project: { name: "demo" },
+        optional_infra: { verdaccio: true },
+        phases: {},
+      }),
+    );
+
+    const execUp = ((command: string) => {
+      if (command.startsWith("docker ps")) {
+        return "beauty-crm-verdaccio\n";
+      }
+      if (command.includes("curl")) {
+        return "200";
+      }
+      return "";
+    }) as typeof import("node:child_process").execSync;
+
+    const result = checkPrivateNpmRegistry(execUp, projectRoot, "http://localhost:4873");
+
+    expect(result.didPass).toBe(true);
+    expect(result.message).toContain("reachable");
+
+    rmSync(projectRoot, { recursive: true, force: true });
+  });
+});

package/cli/src/commands/__tests__/error-handling.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from "vitest";
+import {
+  createKebabCaseValidator,
+  isValidPort,
+  validateResourceName,
+} from "../../utils/validation.js";
+
+describe("error handling", () => {
+  describe("resource name validation", () => {
+    it("should validate resource names using actual validation utility", () => {
+      expect(validateResourceName("my-service")).toEqual({ valid: true });
+      expect(validateResourceName("service123")).toEqual({ valid: true });
+      expect(validateResourceName("api-gateway")).toEqual({ valid: true });
+
+      expect(validateResourceName("")).toEqual({
+        valid: false,
+        error: "Resource name is required",
+      });
+      expect(validateResourceName("MyService")).toEqual({
+        valid: false,
+        error: "Use lowercase letters, numbers, and hyphens only",
+      });
+      expect(validateResourceName("my_service")).toEqual({
+        valid: false,
+        error: "Use lowercase letters, numbers, and hyphens only",
+      });
+    });
+
+    it("should create kebab-case validators for different contexts", () => {
+      const resourceValidator = createKebabCaseValidator("resource");
+      const stackValidator = createKebabCaseValidator("stack");
+
+      expect(resourceValidator("my-resource")).toBe(true);
+      expect(resourceValidator("")).toBe("Resource name is required");
+      expect(resourceValidator("MyResource")).toBe(
+        "Use lowercase letters, numbers, and hyphens only",
+      );
+
+      expect(stackValidator("my-stack")).toBe(true);
+      expect(stackValidator("")).toBe("Stack name is required");
+      expect(stackValidator("MyStack")).toBe("Use kebab-case (lowercase, numbers, hyphens only)");
+    });
+  });
+
+  describe("port assignment", () => {
+    it("should validate port is within valid range using isValidPort", () => {
+      // Valid ports (isValidPort allows ports 1-65535, not just 1024+)
+      expect(isValidPort(3000)).toBe(true);
+      expect(isValidPort(8080)).toBe(true);
+      expect(isValidPort(1024)).toBe(true);
+      expect(isValidPort(1)).toBe(true); // Valid per isValidPort (just > 0)
+      expect(isValidPort(65535)).toBe(true);
+
+      // Invalid ports
+      expect(isValidPort(65536)).toBe(false);
+      expect(isValidPort(0)).toBe(false);
+      expect(isValidPort(-1)).toBe(false);
+    });
+  });
+
+  describe("stack name validation", () => {
+    it("should validate stack name format using createKebabCaseValidator", () => {
+      const validNames = ["main", "api-services", "v1-stack", "test123"];
+
+      const invalidNames = ["My Stack", "my_stack", "MyStack", ""];
+
+      const stackValidator = createKebabCaseValidator("stack");
+
+      for (const name of validNames) {
+        expect(stackValidator(name)).toBe(true);
+      }
+
+      for (const name of invalidNames) {
+        expect(typeof stackValidator(name)).toBe("string");
+      }
+    });
+  });
+});