@tdk-landscape/tdk-cli-core 1.3.53 → 1.3.54

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

@@ -1,172 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-
-// Mock findProjectRoot to return a controlled path for all tests
-vi.mock("../paths.js", () => ({
-  findProjectRoot: vi.fn(),
-  getPackageVersion: vi.fn(() => "1.1.0"),
-}));
-
-import { findProjectRoot } from "../paths.js";
-
-describe("getTiltfilePath", () => {
-  beforeEach(() => {
-    vi.mocked(findProjectRoot).mockReturnValue("/fake/project");
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("should return correct tiltfile path for valid project", async () => {
-    const { getTiltfilePath } = await import("../tilt.js");
-    const tiltfilePath = getTiltfilePath();
-    expect(tiltfilePath).toBe("/fake/project/.tdk/.tdk-out/Tiltfile");
-  });
-
-  it("should not have double slashes in path", async () => {
-    const { getTiltfilePath } = await import("../tilt.js");
-    // Ensure root doesn't have trailing slash
-    const tiltfilePath = getTiltfilePath();
-    expect(tiltfilePath).not.toContain("//");
-  });
-});
-
-describe("getTiltfilePath error", () => {
-  beforeEach(() => {
-    vi.mocked(findProjectRoot).mockReturnValue(null);
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("should throw when not in a TDK project", async () => {
-    const { getTiltfilePath } = await import("../tilt.js");
-    expect(() => getTiltfilePath()).toThrow("Not in a TDK project");
-  });
-});
-
-describe("buildTiltUpArgs", () => {
-  beforeEach(() => {
-    vi.mocked(findProjectRoot).mockReturnValue("/fake/project");
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("should include -f flag with tiltfile path", async () => {
-    const { buildTiltUpArgs } = await import("../tilt.js");
-    const args = buildTiltUpArgs(["service-a", "service-b"], {});
-    expect(args).toContain("-f");
-    const fIndex = args.indexOf("-f");
-    expect(fIndex).toBeGreaterThanOrEqual(0);
-    expect(args[fIndex + 1]).toContain(".tdk/.tdk-out/Tiltfile");
-  });
-
-  it("should include service names in order", async () => {
-    const { buildTiltUpArgs } = await import("../tilt.js");
-    const args = buildTiltUpArgs(["service-a", "service-b"], {});
-    expect(args).toContain("service-a");
-    expect(args).toContain("service-b");
-  });
-
-  it("should include --verbose flag when verbose is set", async () => {
-    const { buildTiltUpArgs } = await import("../tilt.js");
-    const args = buildTiltUpArgs([], { verbose: true });
-    expect(args).toContain("--verbose");
-  });
-
-  it("should NOT include --verbose when quiet is set even if verbose is true", async () => {
-    const { buildTiltUpArgs } = await import("../tilt.js");
-    const args = buildTiltUpArgs([], { verbose: true, quiet: true });
-    expect(args).not.toContain("--verbose");
-  });
-
-  it("should include --watch flag when watch is set", async () => {
-    const { buildTiltUpArgs } = await import("../tilt.js");
-    const args = buildTiltUpArgs([], { watch: true });
-    expect(args).toContain("--watch");
-  });
-
-  it("should order args: -f, tiltfile, services, options", async () => {
-    const { buildTiltUpArgs } = await import("../tilt.js");
-    const args = buildTiltUpArgs(["svc-a", "svc-b"], { verbose: true });
-    expect(args[0]).toBe("-f");
-    expect(args[1]).toContain("Tiltfile");
-    expect(args[2]).toBe("svc-a");
-    expect(args[3]).toBe("svc-b");
-    expect(args[4]).toBe("--verbose");
-  });
-
-  it("should call findProjectRoot once", async () => {
-    const { buildTiltUpArgs } = await import("../tilt.js");
-    buildTiltUpArgs([], {});
-    expect(findProjectRoot).toHaveBeenCalledTimes(1);
-  });
-
-  it("should include -- --focus=<stack> before service names when focusTargets is set", async () => {
-    // Regression test: `tdk up <stack>` used to pass only bare positional service
-    // names, which the generated Tiltfile's focus filter never reads (it only reads
-    // --focus), so it silently fell back to building every stack instead of the one
-    // requested. --focus must be present, carry the stack name, and be preceded by
-    // `--` (tilt up rejects "--focus" as an unrecognized top-level flag otherwise -
-    // `--` is what routes it to the Tiltfile's own config.parse()).
-    const { buildTiltUpArgs } = await import("../tilt.js");
-    const args = buildTiltUpArgs(["finance-api", "finance-app"], { focusTargets: ["finance"] });
-    const dashDashIndex = args.indexOf("--");
-    expect(dashDashIndex).toBeGreaterThanOrEqual(0);
-    expect(args[dashDashIndex + 1]).toBe("--focus=finance");
-    expect(args.indexOf("--focus=finance")).toBeLessThan(args.indexOf("finance-api"));
-  });
-
-  it("should join multiple focusTargets with commas in a single --focus flag", async () => {
-    const { buildTiltUpArgs } = await import("../tilt.js");
-    const args = buildTiltUpArgs([], { focusTargets: ["finance", "hr"] });
-    expect(args).toContain("--focus=finance,hr");
-  });
-
-  it("should NOT include --focus when focusTargets is empty or omitted", async () => {
-    const { buildTiltUpArgs } = await import("../tilt.js");
-    const withEmpty = buildTiltUpArgs(["svc"], { focusTargets: [] });
-    const withOmitted = buildTiltUpArgs(["svc"], {});
-    expect(withEmpty.some((a) => a.startsWith("--focus"))).toBe(false);
-    expect(withOmitted.some((a) => a.startsWith("--focus"))).toBe(false);
-  });
-});
-
-describe("buildTiltDownArgs", () => {
-  beforeEach(() => {
-    vi.mocked(findProjectRoot).mockReturnValue("/fake/project");
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it("should include -f flag with tiltfile path", async () => {
-    const { buildTiltDownArgs } = await import("../tilt.js");
-    const args = buildTiltDownArgs({});
-    expect(args).toContain("-f");
-  });
-
-  it("should include --force flag when force is set", async () => {
-    const { buildTiltDownArgs } = await import("../tilt.js");
-    const args = buildTiltDownArgs({ force: true });
-    expect(args).toContain("--force");
-  });
-
-  it("should not include --force flag when force is not set", async () => {
-    const { buildTiltDownArgs } = await import("../tilt.js");
-    const args = buildTiltDownArgs({});
-    expect(args).not.toContain("--force");
-  });
-});
-
-describe("isTiltAvailable", () => {
-  it("should return a boolean", async () => {
-    const { isTiltAvailable } = await import("../tilt.js");
-    const available = await isTiltAvailable();
-    expect(typeof available).toBe("boolean");
-  });
-});

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

@@ -1,148 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,130 +0,0 @@
-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;
-
-// Version specifiers that pin nothing at all - a fresh `bun install`/`npm install`
-// can pull a different (possibly breaking) version on every run.
-export const UNPINNED_DEPENDENCY_VERSIONS = new Set(["latest", "*"]);
-
-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 = "tdk-project.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

@@ -1,49 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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";
-}