@flisk-sh/flisk 0.0.0-stage → 1.3.190

package/cli/dist/utils/service-urls.js

@@ -0,0 +1,112 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { PROJECT_JSON } from "./constants.js";
+import { findProjectRoot } from "./paths.js";
+import { isApiServiceType } from "./resource-kind.js";
+export function getProjectName() {
+    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 "tdk-project";
+}
+export function resolveSubdomainBases(ingressPort) {
+    const projectName = getProjectName();
+    const raw = process.env.TDK_SERVICE_BASE_URL ??
+        `http://${projectName}.localhost${ingressPort ? `:${ingressPort}` : ""}`;
+    try {
+        const u = new URL(raw.includes("://") ? raw : `http://${raw}`);
+        const host = u.hostname;
+        // URL drops a default port (80 for http, 443 for https), so u.port is empty
+        // for http://x.localhost:80. Keep it empty instead of re-adding ingressPort.
+        const defaultPort = u.protocol === "https:" ? "443" : "80";
+        const explicitPort = u.port || (ingressPort ? String(ingressPort) : "");
+        const port = explicitPort === defaultPort ? "" : explicitPort;
+        if (host === "localhost" || /^\d+\.\d+\.\d+\.\d+$/.test(host)) {
+            return {
+                appBase: `${u.protocol}//${host}${port ? `:${port}` : ""}`,
+                apiBase: `${u.protocol}//${host}${port ? `:${port}` : ""}`,
+            };
+        }
+        const bare = host.replace(/^(app|api)\./, "");
+        return {
+            appBase: `${u.protocol}//app.${bare}${port ? `:${port}` : ""}`,
+            apiBase: `${u.protocol}//api.${bare}${port ? `:${port}` : ""}`,
+        };
+    }
+    catch {
+        return {
+            appBase: `http://app.${projectName}.localhost`,
+            apiBase: `http://api.${projectName}.localhost`,
+        };
+    }
+}
+export function appendHealthPath(path) {
+    return `${path.replace(/\/+$/, "")}/health`;
+}
+/** The route `flisk up` advertises for a service, without the /health suffix. */
+export function resolveServicePath(resource) {
+    if (isApiServiceType(resource.config?.appType)) {
+        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 `flisk up` prints.
+ * Workers, libraries, SDKs and migrators have no Traefik route, so they are
+ * skipped rather than reported as unreachable.
+ */
+export function buildHealthTargets(resources, ingressPort) {
+    return routableTargets(resources, ingressPort, (path) => appendHealthPath(path));
+}
+/**
+ * The URL `flisk up` and `flisk networks` advertise for each routable service, with no suffix. A service can answer /health while
+ * this URL is a 404 (nothing handles the bare path), which is the dead link users click.
+ */
+export function buildAdvertisedTargets(resources, ingressPort) {
+    return routableTargets(resources, ingressPort, (path) => path);
+}
+function routableTargets(resources, ingressPort, toPath) {
+    const { appBase, apiBase } = resolveSubdomainBases(ingressPort);
+    return resources
+        .filter((resource) => resource.config?.appType === "frontend" || isApiServiceType(resource.config?.appType))
+        .map((resource) => {
+        const base = isApiServiceType(resource.config.appType) ? apiBase : appBase;
+        return {
+            name: resource.name,
+            appType: resource.config.appType,
+            url: `${base}${toPath(resolveServicePath(resource))}`,
+        };
+    });
+}
+export async function pingHealthTarget(target, timeoutMs) {
+    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) {
+        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, timeoutMs) {
+    return Promise.all(targets.map((target) => pingHealthTarget(target, timeoutMs)));
+}

package/cli/dist/utils/services.js

@@ -0,0 +1,360 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import fs, { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { Cache, createCacheValidator } from "./cache.js";
+import { AUTOGENERATED_FILE_PATTERNS, DOCKER_COMPOSE_FILE, PACKAGE_JSON, SERVICE_JSON, SKIP_DIRECTORIES, } from "./constants.js";
+import { errorFactories } from "./errors.js";
+import { formatCount } from "./formatting.js";
+import { findProjectRoot } from "./paths.js";
+import { getInvalidServiceRoutePathFields, validateGeneratedStringFields, validateServiceManifest, } from "./service-manifest.js";
+import { deriveStackStatus } from "./stack-status.js";
+import { includes } from "./validation.js";
+const RESOURCE_JSON_FILENAME = SERVICE_JSON;
+function findServiceJsonFiles(dir, maxDepth = 5, currentDepth = 0) {
+    const results = [];
+    if (currentDepth > maxDepth) {
+        return results;
+    }
+    const entries = fs.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;
+}
+export function discoverServiceManifestPaths(projectRoot) {
+    return findServiceJsonFiles(projectRoot);
+}
+function shouldSkipDirectory(name) {
+    return includes(SKIP_DIRECTORIES, name) || name.startsWith(".");
+}
+function isValidResourceConfig(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const config = value;
+    // 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;
+}
+// Discovery may be invoked more than once per process,
+// so remember what was already printed and show each warning once.
+const printedWarnings = new Set();
+export function resetPrintedServiceWarnings() {
+    printedWarnings.clear();
+}
+class InvalidServiceJsonError extends Error {
+    reason;
+    constructor(reason) {
+        super(reason);
+        this.reason = reason;
+        this.name = "InvalidServiceJsonError";
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function parseResource(serviceJsonPath) {
+    let content;
+    try {
+        content = fs.readFileSync(serviceJsonPath, "utf-8");
+    }
+    catch (error) {
+        throw new InvalidServiceJsonError(`could not read file: ${errorMessage(error)}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch (error) {
+        throw new InvalidServiceJsonError(`invalid JSON: ${errorMessage(error)}`);
+    }
+    if (!isValidResourceConfig(parsed)) {
+        throw new InvalidServiceJsonError("missing required fields (appName, runtime or appType)");
+    }
+    const invalidRoutePathFields = getInvalidServiceRoutePathFields(parsed);
+    if (invalidRoutePathFields.length > 0) {
+        throw new InvalidServiceJsonError(invalidRoutePathFields.map((field) => `${field}: expected a string`).join("; "));
+    }
+    const unsafeFields = validateGeneratedStringFields(parsed, serviceJsonPath);
+    if (unsafeFields.length > 0)
+        throw new InvalidServiceJsonError(unsafeFields.join("; "));
+    const parsedConfig = parsed;
+    for (const warning of validateServiceManifest(parsed, serviceJsonPath).warnings) {
+        // The warning names the file and field and says what is wrong (unknown, deprecated, ignored), so do not prefix it.
+        if (printedWarnings.has(warning))
+            continue;
+        printedWarnings.add(warning);
+        console.warn(`⚠️  ${warning}`);
+    }
+    const config = {
+        ...parsedConfig,
+        appType: (parsedConfig.appType ||
+            parsedConfig.type),
+    };
+    const resourceDir = dirname(serviceJsonPath);
+    return {
+        name: config.appName,
+        path: resourceDir,
+        configPath: serviceJsonPath,
+        config,
+        stack: config.stack,
+        port: config.port,
+        type: config.appType,
+    };
+}
+export function discoverResourcesWithProblems(projectRoot) {
+    const serviceJsonPaths = findServiceJsonFiles(projectRoot);
+    const resources = [];
+    const problems = [];
+    for (const path of serviceJsonPaths) {
+        try {
+            resources.push(parseResource(path));
+        }
+        catch (error) {
+            problems.push({
+                path,
+                reason: error instanceof InvalidServiceJsonError ? error.reason : errorMessage(error),
+            });
+        }
+    }
+    return { resources, problems };
+}
+export function warnAboutSkippedFiles(problems) {
+    for (const problem of problems) {
+        const warning = `skipped ${problem.path}: ${problem.reason}`;
+        if (printedWarnings.has(warning))
+            continue;
+        printedWarnings.add(warning);
+        console.warn(`⚠️  ${warning}`);
+    }
+}
+export function discoverResourcesFromRoot(projectRoot) {
+    const { resources, problems } = discoverResourcesWithProblems(projectRoot);
+    warnAboutSkippedFiles(problems);
+    return resources;
+}
+export function discoverResources() {
+    const projectRoot = findProjectRoot();
+    if (!projectRoot) {
+        throw errorFactories.notInProject();
+    }
+    return discoverResourcesFromRoot(projectRoot);
+}
+export function discoverResourcesStrict(discovered) {
+    let result = discovered;
+    if (!result) {
+        const projectRoot = findProjectRoot();
+        if (!projectRoot) {
+            throw errorFactories.notInProject();
+        }
+        result = discoverResourcesWithProblems(projectRoot);
+    }
+    if (result.problems.length > 0) {
+        throw new Error(result.problems
+            .map((problem) => `Invalid service.json at ${problem.path}: ${problem.reason}`)
+            .join("\n"));
+    }
+    return result.resources;
+}
+/**
+ * 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, resources) {
+    const resourcesToScan = resources ?? discoverResourcesFromRoot(projectRoot);
+    return getAllStacks(resourcesToScan);
+}
+export function getAllStacks(resources) {
+    const resourcesToScan = resources || discoverResources();
+    const stacks = new Set();
+    for (const resource of resourcesToScan) {
+        if (resource.stack) {
+            stacks.add(resource.stack);
+        }
+    }
+    return Array.from(stacks).sort();
+}
+export function discoverStacks(resources = discoverResources()) {
+    const stackMap = new Map();
+    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 = [];
+    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, resources) {
+    const allResources = resources ?? discoverResources();
+    return allResources.filter((r) => r.stack === stackName);
+}
+export function stackExists(stackName, resources) {
+    const resourcesToSearch = resources ?? discoverResources();
+    return resourcesToSearch.some((resource) => resource.stack === stackName);
+}
+/**
+ * Cache TTL in milliseconds
+ */
+const CACHE_TTL_MS = 5000;
+const resourcesCache = new Cache({ ttlMs: CACHE_TTL_MS });
+const stacksCache = new Cache({ ttlMs: CACHE_TTL_MS });
+const cacheValidator = createCacheValidator(CACHE_TTL_MS);
+export function clearMetadataCache() {
+    resourcesCache.clear();
+    stacksCache.clear();
+    cacheValidator.reset();
+}
+function detectFileType(filename, content) {
+    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 Flisk") || firstLines.includes("AUTOGENERATED")) {
+            return "generated";
+        }
+    }
+    return "unknown";
+}
+export function getResourceMetadata(resource) {
+    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_FILE)) ||
+        existsSync(join(resourceDir, "docker-compose.yaml"));
+    const configType = resource.config?.appType;
+    let type = 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 = {
+        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) {
+    const files = [];
+    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) {
+    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 overallStatus = deriveStackStatus(resourcesMetadata.map((r) => r.status));
+    const metadata = {
+        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/dist/utils/shared-infra.js

@@ -0,0 +1,45 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { DATABASE_MANAGEMENT_FEATURE, PROJECT_JSON } from "./constants.js";
+import { POSTGRES_DEPENDENCY_NAMES } from "./shared-platform-postgres.js";
+/** A resource uses the shared database when its features or dependsOn ask for it. */
+export function usesSharedPostgres(resource) {
+    const config = resource.config;
+    if (!config)
+        return false;
+    // service.json is not type-checked here, so a malformed value must not throw inside `flisk status`.
+    if (Array.isArray(config.featuresEnabled) &&
+        config.featuresEnabled.includes(DATABASE_MANAGEMENT_FEATURE))
+        return true;
+    const dependsOn = Array.isArray(config.dependsOn) ? config.dependsOn : [];
+    return dependsOn.some((name) => POSTGRES_DEPENDENCY_NAMES.includes(name));
+}
+export function groupSharedPostgres(projectName, stacks) {
+    const prefix = projectName.replace(/-/g, "_");
+    const databases = [];
+    for (const stack of [...stacks].sort((a, b) => a.name.localeCompare(b.name))) {
+        const services = stack.resources.filter(usesSharedPostgres).map((resource) => resource.name);
+        if (services.length === 0)
+            continue;
+        databases.push({
+            name: `${prefix}_${stack.name.replace(/-/g, "_")}`,
+            stack: stack.name,
+            services: services.sort(),
+        });
+    }
+    if (databases.length === 0)
+        return null;
+    return { name: "postgres", databases };
+}
+/** `project.name` from `.tdk/project.json`, or null when the project file is missing or unreadable. */
+export function readProjectName(projectRoot) {
+    try {
+        const parsed = JSON.parse(readFileSync(join(projectRoot, ".tdk", PROJECT_JSON), "utf-8"));
+        return typeof parsed?.project?.name === "string" ? parsed.project.name : null;
+    }
+    catch {
+        return null;
+    }
+}