@flisk-sh/flisk 1.4.5 → 1.4.6

package/cli/dist/utils/cold-preflight.js

@@ -11,9 +11,19 @@ import { checkColima } from "./colima.js";
 import { PROJECT_JSON } from "./constants.js";
 import { checkNatsBroker } from "./doctor-wiring.js";
 import { getHostPortPlan } from "./host-port-config.js";
+import { isNativeProject } from "./native-service.js";
 import { findProjectRoot } from "./paths.js";
 import { discoverResourcesFromRoot } from "./services.js";
 import { findOnPath } from "./which.js";
+/** Checks a project of `command` services needs: no container runtime, no Tilt, no gateway or database ports. */
+export const NATIVE_CHECK_IDS = ["node", "bun"];
+function blockingCheckIds(scope) {
+    if (scope === "scaffold")
+        return SCAFFOLD_CHECK_IDS;
+    if (scope === "native")
+        return NATIVE_CHECK_IDS;
+    return MACHINE_CHECK_IDS;
+}
 /** Checks that only the local runtime (starting a stack) needs. */
 export const RUNTIME_CHECK_IDS = ["docker", "compose", "tilt"];
 /** Checks that writing project configuration needs. */
@@ -71,11 +81,35 @@ export function usesPrisma(projectRoot) {
         return false;
     }
 }
+async function hostPortsItem(root, scope) {
+    try {
+        // Scaffolding must not talk to Docker at all, so the port plan is planned
+        // from the host ports alone.
+        const plan = await getHostPortPlan(root, scope === "scaffold" ? { inspectDocker: false } : {});
+        return {
+            id: "ports",
+            ok: true,
+            message: `HTTP ${plan.ingressHttp}, HTTPS ${plan.ingressHttps}, Postgres ${plan.postgres}`,
+        };
+    }
+    catch (error) {
+        return {
+            id: "ports",
+            ok: false,
+            message: error instanceof Error ? error.message : String(error),
+            fix: "Set FLISK_HTTP_PORT, FLISK_HTTPS_PORT, or FLISK_POSTGRES_PORT to available host ports.",
+        };
+    }
+}
 export async function runColdPreflight(opts = {}) {
     const cwd = opts.cwd ?? process.cwd();
-    const scope = opts.scope ?? "runtime";
     const projectRoot = findProjectRoot(cwd);
     const inProject = Boolean(projectRoot);
+    const resources = projectRoot ? discoverResourcesFromRoot(projectRoot) : [];
+    // A project whose services all declare `command` runs them as local processes (#2231): Docker, Compose, Tilt, the
+    // gateway/database host ports and the container wiring checks do not apply, so they are not run or reported.
+    const isNative = isNativeProject(resources);
+    const scope = isNative ? "native" : (opts.scope ?? "runtime");
     const items = [];
     const nodeVersion = process.versions.node;
     items.push({
@@ -115,7 +149,7 @@ export async function runColdPreflight(opts = {}) {
         items.push(await safeCheck("tilt", checkTilt, "Tilt CLI not found"));
     }
     // Outside a project Bun stays required: `flisk project` is about to create services that need it.
-    const bunNeeded = projectRoot ? projectNeedsBun(discoverResourcesFromRoot(projectRoot)) : true;
+    const bunNeeded = projectRoot ? projectNeedsBun(resources) : true;
     let bun = false;
     const bunPath = bunNeeded ? findOnPath("bun") : undefined;
     if (bunPath) {
@@ -141,24 +175,9 @@ export async function runColdPreflight(opts = {}) {
             fix: bun ? undefined : "curl -fsSL https://bun.sh/install | bash",
         }
         : { id: "bun", ok: true, message: "Bun not needed: no generated JS services" });
-    try {
-        // Scaffolding must not talk to Docker at all, so the port plan is planned
-        // from the host ports alone.
-        const plan = await getHostPortPlan(projectRoot ?? cwd, scope === "scaffold" ? { inspectDocker: false } : {});
-        items.push({
-            id: "ports",
-            ok: true,
-            message: `HTTP ${plan.ingressHttp}, HTTPS ${plan.ingressHttps}, Postgres ${plan.postgres}`,
-        });
-    }
-    catch (error) {
-        items.push({
-            id: "ports",
-            ok: false,
-            message: error instanceof Error ? error.message : String(error),
-            fix: "Set FLISK_HTTP_PORT, FLISK_HTTPS_PORT, or FLISK_POSTGRES_PORT to available host ports.",
-        });
-    }
+    // The host port plan places the gateway and Postgres, which only the container runtime starts.
+    if (scope !== "native")
+        items.push(await hostPortsItem(projectRoot ?? cwd, scope));
     // Project wiring (NATS, Prisma database) describes a running stack, so it is
     // only probed for the runtime scope.
     if (projectRoot && scope === "runtime") {
@@ -198,18 +217,20 @@ export async function runColdPreflight(opts = {}) {
         }
     }
     const failures = items.filter((check) => !check.ok).slice(0, 8);
-    const blockingIds = scope === "scaffold" ? SCAFFOLD_CHECK_IDS : MACHINE_CHECK_IDS;
+    const blockingIds = blockingCheckIds(scope);
     const machineFailed = failures.some((check) => blockingIds.includes(check.id));
     const bunFailed = failures.some((check) => check.id === "bun");
     const header = failures.length
         ? machineFailed
-            ? scope === "scaffold"
-                ? bunFailed
-                    ? `Project setup blocked. Bun ${BUN_FLOOR_LABEL} must be installed on PATH.\nFix the machine checks below.`
-                    : "Project setup blocked. Fix the machine checks below."
-                : bunFailed
-                    ? `Cold start blocked. Bun ${BUN_FLOOR_LABEL} must be installed on PATH.\nPrisma/NATS configuration is project-specific and generated after \`flisk project\`. Fix the machine checks below.`
-                    : "Cold start blocked. Bun/Prisma/NATS are not the first failure.\nThey are generated after `flisk project`. Fix the machine checks below."
+            ? scope === "native"
+                ? "Cannot start the local processes. Fix the machine checks below."
+                : scope === "scaffold"
+                    ? bunFailed
+                        ? `Project setup blocked. Bun ${BUN_FLOOR_LABEL} must be installed on PATH.\nFix the machine checks below.`
+                        : "Project setup blocked. Fix the machine checks below."
+                    : bunFailed
+                        ? `Cold start blocked. Bun ${BUN_FLOOR_LABEL} must be installed on PATH.\nPrisma/NATS configuration is project-specific and generated after \`flisk project\`. Fix the machine checks below.`
+                        : "Cold start blocked. Bun/Prisma/NATS are not the first failure.\nThey are generated after `flisk project`. Fix the machine checks below."
             : "Machine is ready. Project wiring is not."
         : "";
     const footer = failures.length
@@ -217,7 +238,7 @@ export async function runColdPreflight(opts = {}) {
         : inProject
             ? "Environment ready for Flisk"
             : `This machine is ready for Flisk.\n${readyNextStep()}`;
-    return { ok: failures.length === 0, inProject, items: failures, header, footer };
+    return { ok: failures.length === 0, inProject, scope, items: failures, header, footer };
 }
 /** Formats only failed preflight checks and the applicable readiness message. */
 export function formatColdPreflight(result, options = {}) {
@@ -233,9 +254,8 @@ export function formatColdPreflight(result, options = {}) {
 }
 /** Exits before machine-dependent command work when any machine check fails. */
 export async function assertMachineReadyOrExit(opts = {}) {
-    const scope = opts.scope ?? "runtime";
-    const result = await runColdPreflight({ scope });
-    const blockingIds = scope === "scaffold" ? SCAFFOLD_CHECK_IDS : MACHINE_CHECK_IDS;
+    const result = await runColdPreflight({ scope: opts.scope });
+    const blockingIds = blockingCheckIds(result.scope);
     const machineFailure = result.items.some((check) => blockingIds.includes(check.id));
     if (machineFailure) {
         console.error(formatColdPreflight(result));

package/cli/dist/utils/doctor-native.js

@@ -0,0 +1,96 @@
+import { formatCount } from "./formatting.js";
+import { findMissingPrograms, isPortListening, isProcessAlive, localUrl, planNativeRun, readNativeRunState, } from "./native-runtime.js";
+import { isNativeService } from "./native-service.js";
+import { findOnPath } from "./which.js";
+/**
+ * Doctor checks for a project whose services all declare `command` (#2231). Such a project runs as local processes, so doctor
+ * checks what those processes need (their programs, their dependsOn, their ports) instead of Docker, Compose and Tilt.
+ */
+/** Says which runtime doctor checked, so a missing Docker check reads as intended and not as forgotten. */
+export function checkNativeRuntime(resources) {
+    return {
+        name: "Runtime",
+        didPass: true,
+        message: `Local processes: ${formatCount(resources.length, "service")} declare a command, so Docker, Compose and Tilt are not needed`,
+    };
+}
+/** Each service's command starts a program that is installed. */
+export function checkNativeCommands(resources, find = findOnPath) {
+    const missing = findMissingPrograms(planNativeRun(resources.filter(isNativeService)).services, find);
+    if (missing.length === 0) {
+        return {
+            name: "Service commands",
+            didPass: true,
+            message: "Every service command starts a program that is installed",
+        };
+    }
+    return {
+        name: "Service commands",
+        didPass: false,
+        message: `${formatCount(missing.length, "service")} run a program that is not on PATH:\n    ${missing.map(({ name, program }) => `${name}: ${program}`).join("\n    ")}`,
+        fix: 'Install the program, or change "command" in the service.json',
+    };
+}
+/** A dependsOn name must be another service of the project: local processes cannot start a database or gateway for it. */
+export function checkNativeDependsOn(resources) {
+    const names = new Set(resources.map((resource) => resource.name));
+    const problems = resources.flatMap((resource) => {
+        const deps = resource.config?.dependsOn;
+        return (Array.isArray(deps) ? deps : [])
+            .filter((dep) => !names.has(dep))
+            .map((dep) => `${resource.name} dependsOn "${dep}", which is not a service of this project`);
+    });
+    if (problems.length === 0) {
+        return {
+            name: "Service dependencies",
+            didPass: true,
+            message: "Every dependsOn names a service of this project",
+        };
+    }
+    return {
+        name: "Service dependencies",
+        didPass: false,
+        message: problems.join("\n    "),
+        fix: "Add the missing service with a command, or remove it from dependsOn. A database or the gateway still needs the Docker path.",
+    };
+}
+/**
+ * When a native run is up, each service answers on its health URL (or accepts connections on its port). Skipped when nothing
+ * runs: doctor is also used before the first `flisk up`.
+ */
+export async function checkNativeServiceHealth(projectRoot, resources, timeoutMs) {
+    const state = readNativeRunState(projectRoot);
+    if (!state || !isProcessAlive(state.pid)) {
+        return {
+            name: "Service Health",
+            didPass: true,
+            isSkipped: true,
+            message: "Not running - start it with flisk up",
+        };
+    }
+    const failing = [];
+    for (const plan of planNativeRun(resources.filter(isNativeService)).services) {
+        if (plan.port === undefined)
+            continue;
+        const answered = plan.healthUrl
+            ? await fetch(plan.healthUrl, { signal: AbortSignal.timeout(timeoutMs) })
+                .then((response) => response.status < 400)
+                .catch(() => false)
+            : await isPortListening(plan.port, timeoutMs);
+        if (!answered)
+            failing.push(`${plan.name}: no answer from ${plan.healthUrl ?? localUrl(plan.port)}`);
+    }
+    if (failing.length === 0) {
+        return {
+            name: "Service Health",
+            didPass: true,
+            message: "Every running service answers",
+        };
+    }
+    return {
+        name: "Service Health",
+        didPass: false,
+        message: failing.join("\n    "),
+        fix: "Read the service output in .flisk/native/logs/<service>.log, or the flisk up terminal",
+    };
+}

package/cli/dist/utils/native-project.js

@@ -0,0 +1,41 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { SERVICE_JSON } from "./constants.js";
+import { isNativeProject } from "./native-service.js";
+import { findProjectRoot } from "./paths.js";
+import { discoverResourcesWithProblems } from "./services.js";
+/** True when `dir` or a directory up to two levels below it has a service.json; a cheap test before a full discovery scan. */
+export function hasNearbyServiceJson(dir, depth = 0) {
+    if (existsSync(join(dir, SERVICE_JSON)))
+        return true;
+    if (depth >= 2)
+        return false;
+    try {
+        return readdirSync(dir, { withFileTypes: true }).some((entry) => entry.isDirectory() &&
+            !entry.name.startsWith(".") &&
+            entry.name !== "node_modules" &&
+            hasNearbyServiceJson(join(dir, entry.name), depth + 1));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The project a command for local processes works on: the Flisk project around `cwd`, or, before the first `flisk up` wrote
+ * .flisk/project.json, `cwd` itself when every service.json near it declares `command` (the directory `flisk up` adopts).
+ * Returns its services only when they all declare `command`; null otherwise, including outside any project.
+ */
+export function findNativeProject(cwd = process.cwd()) {
+    const projectRoot = findProjectRoot(cwd) ?? (hasNearbyServiceJson(cwd) ? cwd : null);
+    if (!projectRoot)
+        return null;
+    try {
+        const { resources } = discoverResourcesWithProblems(projectRoot);
+        return isNativeProject(resources) ? { projectRoot, resources } : null;
+    }
+    catch {
+        return null;
+    }
+}