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

package/cli/src/utils/__tests__/validation.test.ts

@@ -0,0 +1,148 @@
+import { describe, expect, it } from "vitest";
+import { VALID_RESOURCE_TYPES } from "../constants.js";
+import {
+  createKebabCaseValidator,
+  isValidPort,
+  sanitizeForShell,
+  validateOptionalInfraService,
+  validateResourceName,
+} from "../validation.js";
+
+describe("validateResourceName", () => {
+  it("should validate correct kebab-case names", () => {
+    expect(validateResourceName("my-service")).toEqual({ valid: true });
+    expect(validateResourceName("service123")).toEqual({ valid: true });
+    expect(validateResourceName("api-gateway")).toEqual({ valid: true });
+    expect(validateResourceName("a")).toEqual({ valid: true });
+    expect(validateResourceName("test-123-abc")).toEqual({ valid: true });
+  });
+
+  it("should reject empty names", () => {
+    const result = validateResourceName("");
+    expect(result.valid).toBe(false);
+    expect(result.error).toContain("required");
+  });
+
+  it("should reject whitespace-only names", () => {
+    const result = validateResourceName("   ");
+    expect(result.valid).toBe(false);
+  });
+
+  it("should reject camelCase", () => {
+    expect(validateResourceName("myService").valid).toBe(false);
+  });
+
+  it("should reject underscores", () => {
+    expect(validateResourceName("my_service").valid).toBe(false);
+  });
+
+  it("should reject uppercase letters", () => {
+    expect(validateResourceName("My-Service").valid).toBe(false);
+  });
+
+  it("should reject spaces", () => {
+    expect(validateResourceName("my service").valid).toBe(false);
+  });
+
+  it("should reject dots", () => {
+    expect(validateResourceName("my.service").valid).toBe(false);
+  });
+});
+
+describe("createKebabCaseValidator", () => {
+  it("should return true for valid resource names", () => {
+    const validator = createKebabCaseValidator("resource");
+    expect(validator("my-resource")).toBe(true);
+  });
+
+  it("should return error for empty resource name", () => {
+    const validator = createKebabCaseValidator("resource");
+    expect(validator("")).toBe("Resource name is required");
+  });
+
+  it("should return error for invalid resource name", () => {
+    const validator = createKebabCaseValidator("resource");
+    expect(validator("MyResource")).toBe("Use lowercase letters, numbers, and hyphens only");
+  });
+
+  it("should return error for empty stack name", () => {
+    const validator = createKebabCaseValidator("stack");
+    expect(validator("")).toBe("Stack name is required");
+  });
+
+  it("should return error for invalid stack name", () => {
+    const validator = createKebabCaseValidator("stack");
+    expect(validator("MyStack")).toBe("Use kebab-case (lowercase, numbers, hyphens only)");
+  });
+});
+
+describe("validateOptionalInfraService", () => {
+  it("should accept valid infra services", () => {
+    expect(validateOptionalInfraService("monitoring").valid).toBe(true);
+    expect(validateOptionalInfraService("elk").valid).toBe(true);
+    expect(validateOptionalInfraService("debezium").valid).toBe(true);
+    expect(validateOptionalInfraService("golden_image").valid).toBe(true);
+  });
+
+  it("should reject invalid infra services", () => {
+    const result = validateOptionalInfraService("redis");
+    expect(result.valid).toBe(false);
+    expect(result.error).toContain("Invalid service");
+  });
+
+  it("should reject empty string", () => {
+    expect(validateOptionalInfraService("").valid).toBe(false);
+  });
+});
+
+describe("isValidPort", () => {
+  it("should accept valid ports", () => {
+    expect(isValidPort(1)).toBe(true);
+    expect(isValidPort(1024)).toBe(true);
+    expect(isValidPort(3000)).toBe(true);
+    expect(isValidPort(8080)).toBe(true);
+    expect(isValidPort(65535)).toBe(true);
+  });
+
+  it("should reject port 0", () => {
+    expect(isValidPort(0)).toBe(false);
+  });
+
+  it("should reject negative ports", () => {
+    expect(isValidPort(-1)).toBe(false);
+  });
+
+  it("should reject ports > 65535", () => {
+    expect(isValidPort(65536)).toBe(false);
+  });
+
+  it("should reject NaN", () => {
+    expect(isValidPort(NaN)).toBe(false);
+  });
+
+  it("should reject non-integer ports", () => {
+    expect(isValidPort(80.5)).toBe(false);
+  });
+});
+
+describe("sanitizeForShell", () => {
+  it("should replace special characters", () => {
+    expect(sanitizeForShell("hello$world")).toBe("hello_world");
+  });
+
+  it("should keep alphanumeric and hyphens", () => {
+    expect(sanitizeForShell("my-service-123")).toBe("my-service-123");
+  });
+
+  it("should limit output to 100 chars", () => {
+    const long = "a".repeat(200);
+    expect(sanitizeForShell(long).length).toBe(100);
+  });
+});
+
+describe("VALID_RESOURCE_TYPES", () => {
+  it("should include all expected types", () => {
+    const expected = ["backend", "frontend", "library", "sdk", "worker", "migrator"];
+    expect(VALID_RESOURCE_TYPES.sort()).toEqual(expected.sort());
+  });
+});

package/cli/src/utils/cache.ts

@@ -0,0 +1,76 @@
+import type { CacheEntry, CacheOptions } from "../types/index.js";
+
+export class Cache<T> {
+  private data: Map<string, CacheEntry<T>>;
+  private options: CacheOptions;
+
+  constructor(options: CacheOptions) {
+    this.data = new Map();
+    this.options = options;
+  }
+
+  has(key: string): boolean {
+    const entry = this.data.get(key);
+    if (!entry) return false;
+
+    const isExpired = Date.now() - entry.timestamp > this.options.ttlMs;
+    if (isExpired) {
+      this.data.delete(key);
+      return false;
+    }
+
+    return true;
+  }
+
+  get(key: string): T | undefined {
+    if (!this.has(key)) {
+      return undefined;
+    }
+    return this.data.get(key)?.value;
+  }
+
+  set(key: string, value: T): void {
+    this.data.set(key, {
+      value,
+      timestamp: Date.now(),
+    });
+  }
+
+  delete(key: string): void {
+    this.data.delete(key);
+  }
+
+  clear(): void {
+    this.data.clear();
+  }
+
+  keys(): string[] {
+    const validKeys: string[] = [];
+    for (const key of this.data.keys()) {
+      if (this.has(key)) {
+        validKeys.push(key);
+      }
+    }
+    return validKeys;
+  }
+
+  size(): number {
+    return this.keys().length;
+  }
+}
+
+export function createCacheValidator(ttlMs: number) {
+  let lastUpdated = 0;
+
+  return {
+    isValid(): boolean {
+      return Date.now() - lastUpdated < ttlMs;
+    },
+    markUpdated(): void {
+      lastUpdated = Date.now();
+    },
+    reset(): void {
+      lastUpdated = 0;
+    },
+  };
+}

package/cli/src/utils/command-helpers.ts

@@ -0,0 +1,54 @@
+import type { ValidationResult } from "../types/index.js";
+import { showErrorAndExit } from "./errors.js";
+import { showCancelled } from "./formatting.js";
+import { promptConfirm } from "./prompt.js";
+
+export async function confirmAction(message: string, defaultValue = true): Promise<boolean> {
+  const confirm = await promptConfirm({ message, initial: defaultValue });
+
+  if (!confirm) {
+    showCancelled();
+  }
+
+  return confirm;
+}
+
+export function assertValid(
+  validation: ValidationResult,
+  exitCode: number = 1,
+): asserts validation is { valid: true } {
+  if (!validation.valid) {
+    showErrorAndExit(validation.error ?? "Validation failed", exitCode);
+  }
+}
+
+export function handleDryRun(
+  options: { dryRun?: boolean },
+  description: string,
+  command: string,
+): boolean {
+  if (options.dryRun) {
+    console.log(`Dry run - ${description}`);
+    console.log(`Would run: ${command}`);
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Prompt for confirmation with cancellation handling.
+ * Displays a confirmation prompt and exits/cancels if user declines.
+ * @param message - The confirmation message to display
+ * @param onCancel - Optional callback when user cancels (defaults to returning false)
+ * @returns Promise<boolean> - true if confirmed, false if cancelled (with callback)
+ */
+export async function confirmOrCancel(message: string, onCancel?: () => void): Promise<boolean> {
+  const confirmed = await confirmAction(message, true);
+  if (!confirmed) {
+    if (onCancel) {
+      onCancel();
+    }
+    return false;
+  }
+  return true;
+}

package/cli/src/utils/constants.ts

@@ -0,0 +1,126 @@
+import type { ResourceType } from "../types/index.js";
+
+export const MASTER_CONFIG_FILES = [
+  "TILT_TECH_STACK.star",
+  "TILT_RESOURCE_DEFAULTS.star",
+  "spec.master",
+] as const;
+
+export const VALID_RESOURCE_TYPES: ResourceType[] = [
+  "backend",
+  "frontend",
+  "library",
+  "sdk",
+  "worker",
+  "migrator",
+] as const;
+
+// Frontend/library/sdk services are served statically or consumed as
+// packages, so they never need a "start" script - only backend/worker/
+// migrator processes are run in production via `<runtime> run start`.
+export const REQUIRED_PACKAGE_SCRIPTS: Record<ResourceType, readonly string[]> = {
+  backend: ["dev", "build", "start"],
+  worker: ["dev", "build", "start"],
+  migrator: ["dev", "build", "start"],
+  frontend: ["dev", "build"],
+  library: ["dev", "build"],
+  sdk: ["dev", "build"],
+} as const;
+
+export const OPTIONAL_INFRA_SERVICES = [
+  "monitoring",
+  "elk",
+  "debezium",
+  "golden_image",
+  "verdaccio",
+] as const;
+
+export const PORT_RANGES = {
+  frontend: { base: 3000, min: 3000, max: 3999, range: "3000-3999" as const },
+  backend: { base: 4000, min: 4000, max: 4999, range: "4000-4999" as const },
+  worker: { base: 6000, min: 6000, max: 6999, range: "6000-6999" as const },
+  health: { base: 5000, min: 5000, max: 5999, range: "5000-5999" as const },
+  migrator: { base: 7000, min: 7000, max: 7999, range: "7000-7999" as const },
+} as const;
+
+export const STANDARD_PORTS = {
+  tiltUi: 10350,
+  traefik: 8080,
+} as const;
+
+export const QUICKSTART_DOCS_URL = "https://tdk-landscape.github.io/tdk-website/docs/quickstart/";
+
+export const BASE_DOMAIN_DEFAULT = "beauty-crm.localhost";
+export const APP_SUBDOMAIN_PREFIX = "app";
+export const API_SUBDOMAIN_PREFIX = "api";
+
+export function getBaseDomain(): string {
+  const override = process.env.TDK_SERVICE_BASE_URL ?? process.env.TDK_PUBLIC_HOST;
+  if (override) {
+    try {
+      const u = new URL(override.includes("://") ? override : `http://${override}`);
+      return u.hostname;
+    } catch {
+      return override.replace(/^https?:\/\//, "").split("/")[0];
+    }
+  }
+  return BASE_DOMAIN_DEFAULT;
+}
+
+export function frontendBaseUrl(protocol = "http"): string {
+  return `${protocol}://${APP_SUBDOMAIN_PREFIX}.${getBaseDomain()}`;
+}
+
+export function apiBaseUrl(protocol = "http"): string {
+  return `${protocol}://${API_SUBDOMAIN_PREFIX}.${getBaseDomain()}`;
+}
+
+export const SKIP_DIRECTORIES = [
+  "node_modules",
+  ".git",
+  ".tilt",
+  ".tilt-engine",
+  "dist",
+  "build",
+  ".prisma",
+  ".turbo",
+  "coverage",
+  "tmp",
+  "temp",
+  "__tests__",
+  "test",
+  "tests",
+  ".github",
+  ".vscode",
+  "docs",
+] as const;
+
+export const AUTOGENERATED_FILE_PATTERNS = [
+  "Dockerfile",
+  "docker-compose.yml",
+  "docker-compose.yaml",
+  "Tiltfile",
+  "vite.config.ts",
+  "tsconfig.json",
+  "tsconfig.build.json",
+] as const;
+
+// Stack emojis - generic, no hardcoded service names
+// Users can add their own stack emojis via project config
+const STACK_EMOJIS: Record<string, string> = {
+  infra: "🏗️",
+  core: "🔧",
+  api: "⚡",
+  app: "🎨",
+  orchestrator: "⚙️",
+} as const;
+
+export function getStackEmoji(stackName: string): string {
+  const lowerName = stackName.toLowerCase();
+  for (const [key, emoji] of Object.entries(STACK_EMOJIS)) {
+    if (lowerName.includes(key)) {
+      return emoji;
+    }
+  }
+  return "📦";
+}

package/cli/src/utils/discovery-context.ts

@@ -0,0 +1,49 @@
+import type { DiscoveredResource, DiscoveryContext } from "../types/index.js";
+import { createCacheValidator } from "./cache.js";
+import { discoverResources, discoverStacks, getAllStacks } from "./services.js";
+
+let cachedContext: DiscoveryContext | null = null;
+const cacheValidator = createCacheValidator(1000);
+
+export function clearDiscoveryCache(): void {
+  cachedContext = null;
+  cacheValidator.reset();
+}
+
+function isCacheValid(): boolean {
+  return cachedContext !== null && cacheValidator.isValid();
+}
+
+export function createDiscoveryContext(forceRefresh = false): DiscoveryContext {
+  if (!forceRefresh && isCacheValid() && cachedContext) {
+    return cachedContext;
+  }
+
+  const resources = discoverResources();
+  const stacks = discoverStacks();
+  const stackNames = getAllStacks(resources);
+
+  const unassignedResources = resources.filter((r) => !r.stack);
+
+  const resourcesByStack = new Map<string, DiscoveredResource[]>();
+  for (const resource of resources) {
+    if (resource.stack) {
+      const stackResources = resourcesByStack.get(resource.stack) || [];
+      stackResources.push(resource);
+      resourcesByStack.set(resource.stack, stackResources);
+    }
+  }
+
+  const context: DiscoveryContext = {
+    resources,
+    stacks,
+    stackNames,
+    unassignedResources,
+    resourcesByStack,
+  };
+
+  cachedContext = context;
+  cacheValidator.markUpdated();
+
+  return context;
+}

package/cli/src/utils/docker.ts

@@ -0,0 +1,20 @@
+import { execSync } from "node:child_process";
+
+// A wedged daemon makes `docker ps` block forever instead of failing.
+const RUNTIME_CHECK_TIMEOUT_MS = 10_000;
+
+export type ContainerRuntimeStatus = "running" | "unresponsive" | "missing";
+
+/** Whether Docker, Colima, or Podman is reachable, hung, or absent. */
+export function getContainerRuntimeStatus(): ContainerRuntimeStatus {
+  let sawTimeout = false;
+  for (const command of ["docker ps", "colima status", "podman ps"]) {
+    try {
+      execSync(command, { stdio: "ignore", timeout: RUNTIME_CHECK_TIMEOUT_MS });
+      return "running";
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === "ETIMEDOUT") sawTimeout = true;
+    }
+  }
+  return sawTimeout ? "unresponsive" : "missing";
+}