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

package/cli/src/utils/service-urls.ts

@@ -0,0 +1,124 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { DiscoveredResource } from "../types/index.js";
+import { findProjectRoot } from "./paths.js";
+
+export interface HealthTarget {
+  name: string;
+  appType: "frontend" | "backend";
+  url: string;
+}
+
+export interface HealthProbe extends HealthTarget {
+  ok: boolean;
+  /** HTTP status code, or undefined when the request never completed. */
+  status?: number;
+  /** Failure reason when the request never completed (DNS, refused, timeout). */
+  error?: string;
+}
+
+export function getProjectName(): string {
+  const root = findProjectRoot();
+  if (root) {
+    try {
+      const content = readFileSync(join(root, ".tdk", "project.json"), "utf-8");
+      const parsed = JSON.parse(content);
+      if (parsed?.project?.name) {
+        return parsed.project.name;
+      }
+    } catch {}
+  }
+  return "beauty-crm";
+}
+
+export function resolveSubdomainBases(): { appBase: string; apiBase: string } {
+  const projectName = getProjectName();
+  const raw = process.env.TDK_SERVICE_BASE_URL ?? `http://${projectName}.localhost`;
+  try {
+    const u = new URL(raw.includes("://") ? raw : `http://${raw}`);
+    const host = u.hostname;
+    if (host === "localhost" || /^\d+\.\d+\.\d+\.\d+$/.test(host)) {
+      return {
+        appBase: `${u.protocol}//${host}${u.port ? `:${u.port}` : ""}`,
+        apiBase: `${u.protocol}//${host}${u.port ? `:${u.port}` : ""}`,
+      };
+    }
+    const bare = host.replace(/^(app|api)\./, "");
+    return {
+      appBase: `${u.protocol}//app.${bare}${u.port ? `:${u.port}` : ""}`,
+      apiBase: `${u.protocol}//api.${bare}${u.port ? `:${u.port}` : ""}`,
+    };
+  } catch {
+    return {
+      appBase: `http://app.${projectName}.localhost`,
+      apiBase: `http://api.${projectName}.localhost`,
+    };
+  }
+}
+
+export function appendHealthPath(path: string): string {
+  return `${path.replace(/\/+$/, "")}/health`;
+}
+
+/** The route `tdk up` advertises for a service, without the /health suffix. */
+export function resolveServicePath(resource: DiscoveredResource): string {
+  if (resource.config?.appType === "backend") {
+    const servicePathName = resource.name.replace(/-api$/, "");
+    return resource.config?.apiPath ?? `/api/${servicePathName}`;
+  }
+  return resource.config?.basePath ?? `/${resource.name}`;
+}
+
+/**
+ * Health URLs for every routable service, matching what `tdk up` prints.
+ * Workers, libraries, SDKs and migrators have no Traefik route, so they are
+ * skipped rather than reported as unreachable.
+ */
+export function buildHealthTargets(resources: DiscoveredResource[]): HealthTarget[] {
+  const { appBase, apiBase } = resolveSubdomainBases();
+
+  return resources
+    .filter(
+      (
+        resource,
+      ): resource is DiscoveredResource & { config: { appType: "frontend" | "backend" } } =>
+        resource.config?.appType === "frontend" || resource.config?.appType === "backend",
+    )
+    .map((resource) => {
+      const base = resource.config.appType === "backend" ? apiBase : appBase;
+      return {
+        name: resource.name,
+        appType: resource.config.appType,
+        url: `${base}${appendHealthPath(resolveServicePath(resource))}`,
+      };
+    });
+}
+
+export async function pingHealthTarget(
+  target: HealthTarget,
+  timeoutMs: number,
+): Promise<HealthProbe> {
+  try {
+    const response = await fetch(target.url, {
+      method: "GET",
+      redirect: "manual",
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    return { ...target, ok: response.ok, status: response.status };
+  } catch (err: unknown) {
+    const error =
+      err instanceof Error && err.name === "TimeoutError"
+        ? `no response within ${timeoutMs}ms`
+        : err instanceof Error
+          ? err.message
+          : String(err);
+    return { ...target, ok: false, error };
+  }
+}
+
+export async function pingHealthTargets(
+  targets: HealthTarget[],
+  timeoutMs: number,
+): Promise<HealthProbe[]> {
+  return Promise.all(targets.map((target) => pingHealthTarget(target, timeoutMs)));
+}

package/cli/src/utils/services.ts

@@ -0,0 +1,363 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import type {
+  AutogeneratedFile,
+  DiscoveredResource,
+  DiscoveredStack,
+  FileType,
+  ResourceConfig,
+  ResourceMetadata,
+  ResourceType,
+  StackMetadata,
+} from "../types/index.js";
+import { Cache, createCacheValidator } from "./cache.js";
+import { AUTOGENERATED_FILE_PATTERNS, SKIP_DIRECTORIES } from "./constants.js";
+import { formatCount } from "./formatting.js";
+import { findProjectRoot } from "./paths.js";
+import { includes } from "./validation.js";
+
+const RESOURCE_JSON_FILENAME = "service.json";
+
+function findServiceJsonFiles(
+  dir: string,
+  maxDepth: number = 5,
+  currentDepth: number = 0,
+): string[] {
+  const results: string[] = [];
+
+  if (currentDepth > maxDepth) {
+    return results;
+  }
+
+  const entries = readdirSync(dir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+      if (shouldSkipDirectory(entry.name)) continue;
+      results.push(...findServiceJsonFiles(fullPath, maxDepth, currentDepth + 1));
+    } else if (entry.isFile() && entry.name === RESOURCE_JSON_FILENAME) {
+      results.push(fullPath);
+    }
+  }
+
+  return results;
+}
+
+function shouldSkipDirectory(name: string): boolean {
+  return includes(SKIP_DIRECTORIES, name) || name.startsWith(".");
+}
+
+function isValidResourceConfig(value: unknown): value is ResourceConfig {
+  if (!value || typeof value !== "object") return false;
+  const config = value as Record<string, unknown>;
+  // Accept runtime, appType, or type (for backward compatibility with existing service.json files)
+  const hasRuntimeOrAppType =
+    typeof config.runtime === "string" ||
+    typeof config.appType === "string" ||
+    typeof config.type === "string";
+  return typeof config.appName === "string" && hasRuntimeOrAppType;
+}
+
+function parseResource(serviceJsonPath: string): DiscoveredResource {
+  const content = readFileSync(serviceJsonPath, "utf-8");
+  const parsed: unknown = JSON.parse(content);
+
+  if (!isValidResourceConfig(parsed)) {
+    throw new Error(
+      `Invalid service.json at ${serviceJsonPath}: missing required fields (appName, runtime or appType)`,
+    );
+  }
+
+  const parsedConfig = parsed as unknown as ResourceConfig;
+  const config: ResourceConfig = {
+    ...parsedConfig,
+    appType: (parsedConfig.appType || (parsedConfig as any).type) as ResourceConfig["appType"],
+  };
+  const resourceDir = dirname(serviceJsonPath);
+
+  return {
+    name: config.appName,
+    path: resourceDir,
+    configPath: serviceJsonPath,
+    config,
+    stack: config.stack,
+  };
+}
+
+export function discoverResourcesFromRoot(projectRoot: string): DiscoveredResource[] {
+  const serviceJsonPaths = findServiceJsonFiles(projectRoot);
+  const resources: DiscoveredResource[] = [];
+
+  for (const path of serviceJsonPaths) {
+    resources.push(parseResource(path));
+  }
+
+  return resources;
+}
+
+export function discoverResources(): DiscoveredResource[] {
+  const projectRoot = findProjectRoot();
+
+  if (!projectRoot) {
+    throw new Error(
+      "Could not find project root (no Tiltfile found). Make sure you're in a root project.",
+    );
+  }
+
+  return discoverResourcesFromRoot(projectRoot);
+}
+
+/**
+ * Unique, sorted `stack` values across discovered service.json files under `projectRoot`.
+ * Tilt's discovery groups services by this same field (see tdk-cli-extensions
+ * discovery_orchestrator.star), so these are the names that must appear in a
+ * stack's `services` list in .tdk/project.json for that group to be enabled.
+ */
+export function discoverStackNames(projectRoot: string): string[] {
+  const resources = discoverResourcesFromRoot(projectRoot);
+  const stacks = new Set<string>();
+
+  for (const resource of resources) {
+    if (resource.stack) {
+      stacks.add(resource.stack);
+    }
+  }
+
+  return Array.from(stacks).sort();
+}
+
+export function getAllStacks(resources?: DiscoveredResource[]): string[] {
+  const resourcesToScan = resources || discoverResources();
+  const stacks = new Set<string>();
+
+  for (const resource of resourcesToScan) {
+    if (resource.stack) {
+      stacks.add(resource.stack);
+    }
+  }
+
+  return Array.from(stacks).sort();
+}
+
+export function discoverStacks(): DiscoveredStack[] {
+  const resources = discoverResources();
+  const stackMap = new Map<string, DiscoveredResource[]>();
+
+  for (const resource of resources) {
+    if (resource.stack) {
+      const stackResources = stackMap.get(resource.stack);
+      if (stackResources) {
+        stackResources.push(resource);
+      } else {
+        stackMap.set(resource.stack, [resource]);
+      }
+    }
+  }
+
+  const stacks: DiscoveredStack[] = [];
+  for (const [name, stackResources] of stackMap) {
+    stacks.push({
+      name,
+      description: formatCount(stackResources.length, "resource"),
+      resources: stackResources,
+      resourceCount: stackResources.length,
+    });
+  }
+
+  return stacks.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function getResourcesForStack(stackName: string): DiscoveredResource[] {
+  const allResources = discoverResources();
+  return allResources.filter((r) => r.stack === stackName);
+}
+
+export function stackExists(stackName: string): boolean {
+  const resources = getResourcesForStack(stackName);
+  return resources.length > 0;
+}
+
+/**
+ * Cache TTL in milliseconds
+ */
+const CACHE_TTL_MS = 5000;
+
+const resourcesCache = new Cache<ResourceMetadata>({ ttlMs: CACHE_TTL_MS });
+const stacksCache = new Cache<StackMetadata>({ ttlMs: CACHE_TTL_MS });
+const cacheValidator = createCacheValidator(CACHE_TTL_MS);
+
+export function clearMetadataCache(): void {
+  resourcesCache.clear();
+  stacksCache.clear();
+  cacheValidator.reset();
+}
+
+function detectFileType(filename: string, content?: string): FileType {
+  if (filename === "Dockerfile" || filename.startsWith("docker-compose")) {
+    return "docker";
+  }
+  if (filename === "Tiltfile" || filename.endsWith(".star")) {
+    return "tilt";
+  }
+  if (
+    filename === "vite.config.ts" ||
+    filename === "tsconfig.json" ||
+    filename === "package.json"
+  ) {
+    return "config";
+  }
+  if (filename === "schema.prisma" || filename.includes("migration")) {
+    return "prisma";
+  }
+  if (content) {
+    const firstLines = content.split("\n").slice(0, 10).join("\n");
+    if (firstLines.includes("GENERATED BY TDK") || firstLines.includes("AUTOGENERATED")) {
+      return "generated";
+    }
+  }
+  return "unknown";
+}
+
+export function getResourceMetadata(resource: DiscoveredResource): ResourceMetadata {
+  const cacheKey = resource.configPath;
+
+  if (cacheValidator.isValid()) {
+    const cached = resourcesCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+  }
+
+  const resourceDir = resource.path;
+
+  const stats = statSync(resource.configPath);
+  const createdAt = stats.mtime.toISOString();
+  const lastModified = stats.mtime.toISOString();
+
+  const autogeneratedFiles = discoverAutogeneratedFiles(resourceDir);
+  const hasDockerfile = existsSync(join(resourceDir, "Dockerfile"));
+  const hasTiltfile = existsSync(join(resourceDir, "Tiltfile"));
+  const hasDockerCompose =
+    existsSync(join(resourceDir, "docker-compose.yml")) ||
+    existsSync(join(resourceDir, "docker-compose.yaml"));
+
+  const configType = resource.config?.appType;
+  let type: ResourceType = configType || "backend";
+  if (!configType) {
+    if (resource.name.includes("frontend")) {
+      type = "frontend";
+    } else if (
+      resource.name.includes("sdk") ||
+      resource.name.includes("lib") ||
+      resource.name.includes("infra")
+    ) {
+      type = "library";
+    }
+  }
+
+  const metadata: ResourceMetadata = {
+    name: resource.name,
+    stack: resource.stack,
+    type,
+    port: resource.config?.port,
+    createdAt,
+    lastModified,
+    dependencies: resource.config?.dependsOn ?? [],
+    hasDockerfile,
+    hasTiltfile,
+    hasDockerCompose,
+    autogeneratedFiles,
+    status: "unknown",
+  };
+
+  resourcesCache.set(cacheKey, metadata);
+  cacheValidator.markUpdated();
+
+  return metadata;
+}
+
+function discoverAutogeneratedFiles(resourceDir: string): AutogeneratedFile[] {
+  const files: AutogeneratedFile[] = [];
+
+  for (const pattern of AUTOGENERATED_FILE_PATTERNS) {
+    const filePath = join(resourceDir, pattern);
+    if (existsSync(filePath)) {
+      const stats = statSync(filePath);
+      const content = readFileSync(filePath, "utf-8");
+
+      files.push({
+        name: pattern,
+        path: filePath,
+        type: detectFileType(pattern, content),
+        size: stats.size,
+        lastModified: stats.mtime.toISOString(),
+      });
+    }
+  }
+
+  const prismaDir = join(resourceDir, "prisma");
+  if (existsSync(prismaDir)) {
+    const entries = readdirSync(prismaDir);
+    for (const entry of entries) {
+      if (entry === "schema.prisma" || entry.includes("migration")) {
+        const filePath = join(prismaDir, entry);
+        const stats = statSync(filePath);
+        files.push({
+          name: `prisma/${entry}`,
+          path: filePath,
+          type: "prisma",
+          size: stats.size,
+          lastModified: stats.mtime.toISOString(),
+        });
+      }
+    }
+  }
+
+  return files.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export function getStackMetadata(stack: DiscoveredStack): StackMetadata {
+  const cacheKey = stack.name;
+
+  if (cacheValidator.isValid()) {
+    const cached = stacksCache.get(cacheKey);
+    if (cached) {
+      return cached;
+    }
+  }
+
+  const resourcesMetadata = stack.resources.map((r) => getResourceMetadata(r));
+  const timestamps = resourcesMetadata.map((r) => new Date(r.createdAt).getTime());
+  const earliestTimestamp = Math.min(...timestamps);
+  const latestTimestamp = Math.max(...timestamps);
+  const totalResources = resourcesMetadata.length;
+
+  let overallStatus: StackMetadata["overallStatus"] = "unknown";
+  if (totalResources > 0) {
+    const readyCount = resourcesMetadata.filter((r) => r.status === "ready").length;
+    const ratio = readyCount / totalResources;
+    if (ratio > 0.9) {
+      overallStatus = "healthy";
+    } else if (ratio > 0.5) {
+      overallStatus = "degraded";
+    } else {
+      overallStatus = "error";
+    }
+  }
+
+  const metadata: StackMetadata = {
+    name: stack.name,
+    resourceCount: resourcesMetadata.length,
+    createdAt: new Date(earliestTimestamp).toISOString(),
+    lastModified: new Date(latestTimestamp).toISOString(),
+    resources: resourcesMetadata,
+    overallStatus,
+  };
+
+  stacksCache.set(cacheKey, metadata);
+  cacheValidator.markUpdated();
+
+  return metadata;
+}

package/cli/src/utils/stack-features.ts

@@ -0,0 +1,30 @@
+export interface StackFeature {
+  name: string;
+  description: string;
+  generatedFiles: string[];
+}
+
+export const STACK_FEATURES: Record<string, StackFeature> = {
+  "database-management": {
+    name: "database-management",
+    description: "Generate and load the stack-level PostgreSQL docker-compose file",
+    generatedFiles: ["services/platform/database-management/docker-compose.yml"],
+  },
+};
+
+export interface StackFeaturePhaseConfig {
+  pre_alpha?: { enabledStacks?: string[] };
+  alpha?: { enabledStacks?: string[] };
+  beta?: { enabledStacks?: string[] };
+  out_of_scope?: { enabledStacks?: string[] };
+}
+
+export function isStackFeatureEnabledInStacks(
+  stacks: StackFeaturePhaseConfig,
+  featureName: string,
+): boolean {
+  if (!STACK_FEATURES[featureName]) return false;
+  return ["pre_alpha", "alpha", "beta"].some((phase) =>
+    stacks[phase as keyof StackFeaturePhaseConfig]?.enabledStacks?.includes(featureName),
+  );
+}

package/cli/src/utils/tar.ts

@@ -0,0 +1,24 @@
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+/**
+ * Extracts a gzipped tarball (as an in-memory buffer) into destDir.
+ * Shells out to the system `tar` binary rather than pulling in a JS tar
+ * implementation - available by default on macOS and Linux.
+ */
+export function extractTarball(data: Buffer, destDir: string): void {
+  const tmpFile = join(mkdtempSync(join(tmpdir(), "tdk-ext-")), "bundle.tar.gz");
+  writeFileSync(tmpFile, data);
+
+  const result = spawnSync("tar", ["xzf", tmpFile, "-C", destDir, "--strip-components=1"], {
+    stdio: "pipe",
+  });
+
+  rmSync(join(tmpFile, ".."), { recursive: true, force: true });
+
+  if (result.status !== 0) {
+    throw new Error(`tar extraction failed: ${result.stderr?.toString() || "unknown error"}`);
+  }
+}

package/cli/src/utils/tilt.ts

@@ -0,0 +1,113 @@
+import { spawn } from "node:child_process";
+import { join } from "node:path";
+import type { TiltCommandResult } from "../types/index.js";
+import { findProjectRoot } from "./paths.js";
+
+export function runTilt(
+  command: string,
+  args: string[] = [],
+  options: {
+    verbose?: boolean;
+    quiet?: boolean;
+    inheritStdio?: boolean;
+    timeoutMs?: number;
+  } = {},
+): Promise<TiltCommandResult> {
+  return new Promise((resolve, reject) => {
+    const tiltArgs = [command, ...args];
+
+    if (options.verbose) {
+      console.log(`Executing: tilt ${tiltArgs.join(" ")}`);
+    }
+
+    const child = spawn("tilt", tiltArgs, {
+      stdio: options.inheritStdio ? "inherit" : "pipe",
+      shell: false,
+      timeout: options.timeoutMs,
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    if (!options.inheritStdio) {
+      child.stdout?.on("data", (data: Buffer) => {
+        stdout += data.toString();
+      });
+
+      child.stderr?.on("data", (data: Buffer) => {
+        stderr += data.toString();
+      });
+    }
+
+    child.on("close", (code) => {
+      resolve({
+        exitCode: code ?? 1,
+        stdout,
+        stderr,
+      });
+    });
+
+    child.on("error", (err) => {
+      reject(new Error(`Failed to spawn tilt: ${err.message}`));
+    });
+  });
+}
+
+export async function isTiltAvailable(): Promise<boolean> {
+  try {
+    const result = await runTilt("version", [], { inheritStdio: false, timeoutMs: 10_000 });
+    return result.exitCode === 0;
+  } catch {
+    // tilt binary not found (or not spawnable) - treat as unavailable
+    return false;
+  }
+}
+
+export function getTiltfilePath(): string {
+  const projectRoot = findProjectRoot();
+  if (!projectRoot) {
+    throw new Error("Not in a TDK project (no .tdk/project.json found)");
+  }
+
+  return join(projectRoot, ".tdk", ".tdk-out", "Tiltfile");
+}
+
+function addTiltfilePath(args: string[]): void {
+  const tiltfilePath = getTiltfilePath();
+  args.push("-f", tiltfilePath);
+}
+
+export function buildTiltUpArgs(
+  serviceNames: string[],
+  options: {
+    verbose?: boolean;
+    quiet?: boolean;
+    force?: boolean;
+    watch?: boolean;
+  } = {},
+): string[] {
+  const args: string[] = [];
+  addTiltfilePath(args);
+  args.push(...serviceNames);
+
+  if (options.verbose && !options.quiet) {
+    args.push("--verbose");
+  }
+
+  if (options.watch) {
+    args.push("--watch");
+  }
+
+  return args;
+}
+
+export function buildTiltDownArgs(options: { force?: boolean } = {}): string[] {
+  const args: string[] = [];
+  addTiltfilePath(args);
+
+  if (options.force) {
+    args.push("--force");
+  }
+
+  return args;
+}