@flisk-sh/flisk 1.4.2 → 1.4.6

package/cli/dist/frontend-frameworks/vue.js

@@ -1,3 +1,81 @@
+const STARTER_STYLE = `<style scoped>
+main { max-width: 640px; margin: 0 auto; padding: 3rem 1.5rem; font-family: system-ui, sans-serif; color: #1f2933; }
+.muted { color: #616e7c; margin-top: 0; }
+.card { border: 1px solid #d9e2ec; border-radius: 8px; padding: 1rem 1.25rem; margin: 1.5rem 0; }
+.card-header { display: flex; justify-content: space-between; align-items: center; }
+.ok { color: #0a7f3f; }
+.unreachable { color: #b42318; }
+pre { background: #f5f7fa; border-radius: 6px; padding: 0.75rem; overflow-x: auto; }
+</style>`;
+/** Hints and links shared by both starters. They need no backend, so they appear in every frontend. */
+const STARTER_HINTS = `    <p>Edit <code>src/App.vue</code> and save. It live-reloads.</p>
+    <ul>
+      <li><a href="http://localhost:10350">Tilt UI</a>: logs and resource status</li>
+      <li><code>flisk status</code>: every resource in this project</li>
+    </ul>`;
+function renderAppWithBackend(name, backendName) {
+    return `<script setup lang="ts">
+import { onMounted, ref } from 'vue';
+
+const API_URL = import.meta.env.VITE_API_URL ?? '';
+const BACKEND_NAME = '${backendName}';
+
+interface Health {
+  ok: boolean;
+  body: unknown;
+}
+
+const health = ref<Health | null>(null);
+
+onMounted(async () => {
+  try {
+    const response = await fetch(API_URL + '/health');
+    health.value = { ok: response.ok, body: await response.json() };
+  } catch (error) {
+    health.value = { ok: false, body: { error: String(error) } };
+  }
+});
+</script>
+
+<template>
+  <main>
+    <h1>${name}</h1>
+    <p class="muted">Flisk frontend</p>
+
+    <section class="card">
+      <div class="card-header">
+        <strong>Backend: {{ BACKEND_NAME }}</strong>
+        <span v-if="health === null">checking…</span>
+        <span v-else-if="health.ok" class="ok">ok</span>
+        <span v-else class="unreachable">unreachable</span>
+      </div>
+      <pre v-if="health">{{ JSON.stringify(health.body, null, 2) }}</pre>
+    </section>
+
+${STARTER_HINTS}
+  </main>
+</template>
+
+${STARTER_STYLE}
+`;
+}
+function renderAppWithoutBackend(name) {
+    return `<script setup lang="ts">
+const appName = '${name}';
+</script>
+
+<template>
+  <main>
+    <h1>{{ appName }}</h1>
+    <p class="muted">Flisk frontend</p>
+
+${STARTER_HINTS}
+  </main>
+</template>
+
+${STARTER_STYLE}
+`;
+}
 export const vueFrontendProvider = {
     id: "vue",
     label: "Vue + Vite",
@@ -8,7 +86,7 @@ export const vueFrontendProvider = {
         "@vitejs/plugin-vue": "^5.2.4",
     },
     compilerOptions: {},
-    createFiles(name) {
+    createFiles(name, options = {}) {
         return [
             {
                 filename: "index.html",
@@ -40,17 +118,9 @@ createApp(App).mount('#app');
             },
             {
                 filename: "src/App.vue",
-                content: `<script setup lang="ts">
-const message = 'Frontend resource created with Flisk';
-</script>
-
-<template>
-  <main style="padding: 2rem; font-family: system-ui">
-    <h1>${name}</h1>
-    <p>{{ message }}</p>
-  </main>
-</template>
-`,
+                content: options.backendName
+                    ? renderAppWithBackend(name, options.backendName)
+                    : renderAppWithoutBackend(name),
                 description: "Generating Vue app",
                 emoji: "💻",
             },

package/cli/dist/generator/resource-templates.js

@@ -122,12 +122,10 @@ main().catch((err) => {
 `;
 }
 export function getTestTemplate(name) {
-    return `import { describe, it, expect } from 'vitest';
+    return `import { describe, it } from 'vitest';
 
 describe('${name}', () => {
-  it('should pass a basic test', () => {
-    expect(true).toBe(true);
-  });
+  it.todo('add a real test for ${name}');
 });
 `;
 }

package/cli/dist/generator/template-engine.js

@@ -34,11 +34,13 @@ export function loadTemplate(filename) {
     const triedPaths = [];
     for (const templateDir of templateDirs) {
         const templatePath = path.join(templateDir, filename);
-        triedPaths.push(templatePath);
         try {
             return fs.readFileSync(templatePath, "utf-8");
         }
-        catch (_error) { }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            triedPaths.push(`${templatePath} (${reason})`);
+        }
     }
     throw new Error(`Failed to load template ${filename} from any of these paths: ${triedPaths.join(", ")}`);
 }
@@ -707,7 +709,7 @@ async function vendorFliskExtension(projectRoot, options = {}) {
         console.warn(`⚠️  Premium overlay skipped: ${err.message}`);
     }
 }
-const FLISK_GENERATED_MARKER = "SYSTEM-GENERATED BY Flisk CLI";
+export const FLISK_GENERATED_MARKER = "SYSTEM-GENERATED BY Flisk CLI";
 export function verifyMasterConfigs(projectRoot, options) {
     const errors = [];
     const warnings = [];

package/cli/dist/utils/bun-requirement.js

@@ -1,10 +1,13 @@
+import { isNativeService } from "./native-service.js";
 import { isApiServiceType } from "./resource-kind.js";
 /**
  * Bun runs the generated JS services. A project without any has nothing for Bun to run, so neither `flisk doctor` nor
- * `flisk up` needs it. Doctor and the start-up preflight share this rule so they cannot disagree.
+ * `flisk up` needs it. A `command` service runs whatever its command names, so it never needs Bun on Flisk's behalf.
+ * Doctor and the start-up preflight share this rule so they cannot disagree.
  */
 export function projectNeedsBun(resources) {
-    return resources.some((resource) => isApiServiceType(resource.config?.appType) ||
-        resource.config?.appType === "frontend" ||
-        resource.config?.appType === "worker");
+    return resources.some((resource) => !isNativeService(resource) &&
+        (isApiServiceType(resource.config?.appType) ||
+            resource.config?.appType === "frontend" ||
+            resource.config?.appType === "worker"));
 }

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. */
@@ -61,7 +71,7 @@ export function requireVerifiedDockerVersions(result) {
         fix: result.fix ?? "Start Docker and ensure Docker Engine 25+ and Compose 2.20.2+ are installed.",
     };
 }
-function usesPrisma(projectRoot) {
+export function usesPrisma(projectRoot) {
     try {
         return discoverResourcesFromRoot(projectRoot).some((resource) => {
             return resource.config?.featuresEnabled?.includes("prisma") ?? false;
@@ -71,11 +81,35 @@ 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,14 +149,15 @@ 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) {
         try {
+            // A cold start of bun can pass 3s on a busy machine; a timeout there reads as "not installed".
             const version = execFileSync(bunPath, ["--version"], {
                 encoding: "utf-8",
-                timeout: 3000,
+                timeout: 10_000,
             }).trim();
             bun = bunMeetsFloor(version);
         }
@@ -140,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") {
@@ -197,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
@@ -216,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 = {}) {
@@ -232,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/config-explain.js

@@ -0,0 +1,197 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { FLISK_GENERATED_MARKER, ProjectConfigNotFoundError, verifyMasterConfigs, } from "../generator/template-engine.js";
+import { AUTOGENERATED_DIR, PACKAGE_JSON, PROJECT_JSON, SERVICE_JSON, TILTIGNORE_FILE, } from "./constants.js";
+import { FliskError } from "./errors.js";
+import { isFliskGeneratedPath } from "./generated-paths.js";
+/** Snapshot directory `flisk up` writes next to a service's `.autogenerated/` outputs. */
+const CONTRACT_DIR = ".flisk-contract";
+/** Generated service file that is exempt from the hand-edit check. */
+const SERVICE_YAML = "service.yaml";
+/**
+ * Explains one project file using the generated-path allowlist and the hand-edit check that `flisk up` runs.
+ * `file` resolves against the current directory, as shell paths do. Throws a FliskError for a path outside the
+ * project, a missing file, or a directory.
+ */
+export function explainConfigFile(projectRoot, file) {
+    const absolute = resolve(file);
+    const rel = relative(projectRoot, absolute).split(sep).join("/");
+    if (rel === "" || rel === ".." || rel.startsWith("../") || isAbsolute(rel)) {
+        throw new FliskError(`${file} is outside the project`, ["Pass a file inside the project root"]);
+    }
+    if (!existsSync(absolute)) {
+        throw new FliskError(`File not found: ${rel}`, ["Check the path and try again"]);
+    }
+    if (!statSync(absolute).isFile()) {
+        throw new FliskError(`Not a file: ${rel}`, ["Pass a file, not a directory"]);
+    }
+    const isEditedNow = isHandEditedNow(projectRoot, rel);
+    if (!isFliskGeneratedPath(rel)) {
+        return userOwned(rel, isEditedNow);
+    }
+    const segments = rel.split("/");
+    const autogenIndex = segments.indexOf(AUTOGENERATED_DIR);
+    if (autogenIndex >= 0) {
+        return explainServiceOutput(projectRoot, rel, segments, autogenIndex, isEditedNow);
+    }
+    // The allowlist names these paths, but the path alone does not show who wrote the file. Flisk creates
+    // package.json only when it is missing and never overwrites an existing one, so it is the user's to edit.
+    if (rel === PACKAGE_JSON) {
+        return {
+            file: rel,
+            ownership: "user-owned",
+            reason: "Flisk creates package.json only when it is missing and never overwrites an existing one.",
+            source: null,
+            driftOnUp: "none",
+            isEditedNow,
+            next: ["Edit it directly."],
+        };
+    }
+    // A root .tiltignore without Flisk's marker belongs to the team, and Flisk leaves it in place.
+    if (rel === TILTIGNORE_FILE &&
+        !readFileSync(absolute, "utf-8").includes(FLISK_GENERATED_MARKER)) {
+        return {
+            file: rel,
+            ownership: "user-owned",
+            reason: "This .tiltignore has no Flisk generated marker, so Flisk leaves it in place.",
+            source: null,
+            driftOnUp: "none",
+            isEditedNow,
+            next: ["Edit it directly."],
+        };
+    }
+    if (isProjectOutput(rel)) {
+        return {
+            file: rel,
+            ownership: "generated",
+            reason: "Generated from .flisk/project.json.",
+            source: `.flisk/${PROJECT_JSON}`,
+            driftOnUp: "none",
+            isEditedNow,
+            next: [
+                `Edit .flisk/${PROJECT_JSON} instead.`,
+                "`flisk config regenerate` rewrites this file from project.json and discards edits.",
+            ],
+        };
+    }
+    return {
+        file: rel,
+        ownership: "generated",
+        reason: "Written by Flisk; this file does not record the input it is generated from.",
+        source: null,
+        driftOnUp: "none",
+        isEditedNow,
+        next: ["Do not edit it; Flisk writes it when it generates outputs."],
+    };
+}
+function userOwned(rel, isEditedNow) {
+    const base = { file: rel, ownership: "user-owned", isEditedNow };
+    if (rel === `.flisk/${PROJECT_JSON}`) {
+        return {
+            ...base,
+            reason: "Flisk input: the project config that generated outputs are built from.",
+            source: null,
+            driftOnUp: "none",
+            next: ["Edit it, then run `flisk config regenerate`."],
+        };
+    }
+    if (rel.split("/").pop() === SERVICE_JSON) {
+        return {
+            ...base,
+            reason: "Flisk input: the service manifest that generated service files are built from.",
+            source: null,
+            driftOnUp: "none",
+            next: ["Edit it, then run `flisk up` to regenerate the service's outputs."],
+        };
+    }
+    return {
+        ...base,
+        reason: "Not in Flisk's generated-file allowlist, so Flisk does not write it.",
+        source: null,
+        driftOnUp: "none",
+        next: ["Edit it directly."],
+    };
+}
+function explainServiceOutput(projectRoot, rel, segments, autogenIndex, isEditedNow) {
+    const serviceDir = segments.slice(0, autogenIndex).join("/");
+    const source = serviceDir ? `${serviceDir}/${SERVICE_JSON}` : SERVICE_JSON;
+    if (!existsSync(join(projectRoot, source))) {
+        return {
+            file: rel,
+            ownership: "unknown",
+            reason: `${AUTOGENERATED_DIR}/ has no ${SERVICE_JSON} beside it, so Flisk cannot tell which input produces this file.`,
+            source: null,
+            driftOnUp: "unknown",
+            isEditedNow,
+            next: ["Find where the file came from before editing it."],
+        };
+    }
+    const inside = segments.slice(autogenIndex + 1);
+    if (inside[0] === CONTRACT_DIR) {
+        return {
+            file: rel,
+            ownership: "generated",
+            reason: "Flisk's snapshot of the generated files; `flisk up` reads it to detect hand edits.",
+            source,
+            driftOnUp: "none",
+            isEditedNow,
+            next: ["Do not edit it; Flisk writes it when it generates outputs."],
+        };
+    }
+    const insidePath = inside.join("/");
+    if (insidePath === SERVICE_YAML) {
+        return {
+            file: rel,
+            ownership: "generated",
+            reason: "Runtime discovery file written by the Tilt extension; exempt from the hand-edit check.",
+            source,
+            driftOnUp: "none",
+            isEditedNow,
+            next: [`Do not edit it; edit ${source} instead.`],
+        };
+    }
+    const snapshot = join(projectRoot, serviceDir, AUTOGENERATED_DIR, CONTRACT_DIR, insidePath);
+    if (!existsSync(snapshot)) {
+        return {
+            file: rel,
+            ownership: "generated",
+            reason: `Generated from ${source}. Flisk has no snapshot of this file, so it cannot tell whether an edit would block flisk up.`,
+            source,
+            driftOnUp: "unknown",
+            isEditedNow,
+            next: ["Run `flisk up` to write the snapshots, then explain the file again."],
+        };
+    }
+    return {
+        file: rel,
+        ownership: "generated",
+        reason: `Generated from ${source}.`,
+        source,
+        driftOnUp: "blocks-up",
+        isEditedNow,
+        next: [
+            `Edit ${source} instead, then run \`flisk up\`.`,
+            "Discard a hand edit with `flisk config regenerate`.",
+            "Keep a hand edit on purpose with `flisk up --ignore-drift`.",
+        ],
+    };
+}
+function isProjectOutput(rel) {
+    return (rel.startsWith(".flisk/.flisk-out/") ||
+        rel === "Tiltfile" ||
+        /^TILT_[^/]+\.star$/.test(rel) ||
+        rel === TILTIGNORE_FILE);
+}
+/** The same hand-edit list `flisk up` blocks on, so explain and the gate cannot disagree. */
+function isHandEditedNow(projectRoot, rel) {
+    try {
+        return verifyMasterConfigs(projectRoot).handEdited.includes(rel);
+    }
+    catch (error) {
+        if (error instanceof ProjectConfigNotFoundError)
+            return false;
+        throw error;
+    }
+}

package/cli/dist/utils/demo-reset.js

@@ -0,0 +1,22 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { execFileSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+/**
+ * Stop the stack of an existing demo folder before the folder is deleted. Deleting the folder alone leaves its
+ * containers running, and a standalone Traefik that stays up keeps port 80 for the next run.
+ * Returns true when a Flisk project was found and its `flisk down` ran.
+ */
+export function stopDemoStack(projectDir, runDown = runFliskDown) {
+    if (!existsSync(join(projectDir, ".flisk", "project.json")))
+        return false;
+    runDown(projectDir);
+    return true;
+}
+function runFliskDown(projectDir) {
+    execFileSync(process.execPath, [process.argv[1] ?? "flisk", "down", "--yes"], {
+        cwd: projectDir,
+        stdio: "inherit",
+    });
+}

package/cli/dist/utils/discovery-paths.js

@@ -52,12 +52,18 @@ export function readDiscoveryPaths(projectRoot) {
     const configPath = join(projectRoot, ".flisk", PROJECT_JSON);
     if (!existsSync(configPath))
         return DEFAULT_DISCOVERY_PATHS;
+    let reason = "discovery.paths must be an array of strings";
     try {
         const paths = JSON.parse(readFileSync(configPath, "utf-8"))?.discovery?.paths;
+        if (paths === undefined)
+            return DEFAULT_DISCOVERY_PATHS;
         if (Array.isArray(paths) && paths.every((p) => typeof p === "string"))
             return paths;
     }
-    catch { }
+    catch (error) {
+        reason = String(error);
+    }
+    console.warn(`Ignoring discovery configuration in ${configPath}: ${reason}; using default paths: ${DEFAULT_DISCOVERY_PATHS.join(", ")}`);
     return DEFAULT_DISCOVERY_PATHS;
 }
 /** Whether Tilt's discovery would find a service.json in `resourceDir` given `patterns`. */

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",
+    };
+}