@flisk-sh/flisk 0.0.0-stage → 1.3.190

package/cli/dist/index.js

@@ -0,0 +1,10 @@
+export { CREATABLE_RESOURCE_TYPES, isCreatableResourceType, } from "./types/index.js";
+export { Cache, createCacheValidator, } from "./utils/cache.js";
+export { assertValid, confirmAction, confirmOrCancel, handleDryRun, } from "./utils/command-helpers.js";
+// Re-export discovery-context functions for resources-by-stack operations
+export { createDiscoveryContext } from "./utils/discovery-context.js";
+export { writeFilesWithProgress } from "./utils/file-helpers.js";
+export { findProjectRoot } from "./utils/paths.js";
+export { checkPortStatus, findAvailablePort, } from "./utils/port-assignment.js";
+export { clearMetadataCache, discoverResources, discoverStacks, getAllStacks, getResourceMetadata, getResourcesForStack, getStackMetadata, stackExists, } from "./utils/services.js";
+export { buildTiltDownArgs, buildTiltUpArgs, getTiltfilePath, isTiltAvailable, runTilt, } from "./utils/tilt.js";

package/cli/dist/mcp/server.js

@@ -0,0 +1,101 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+/**
+ * A minimal Model Context Protocol server over newline-delimited JSON-RPC 2.0 (the stdio transport). It implements only
+ * what a tools-only server needs: initialize, ping, tools/list and tools/call. Keeping it dependency-free keeps the
+ * published CLI small; the protocol surface used here is stable across the listed protocol versions.
+ */
+export const SUPPORTED_PROTOCOL_VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"];
+const ERROR = {
+    parse: -32700,
+    invalidRequest: -32600,
+    methodNotFound: -32601,
+    invalidParams: -32602,
+};
+function reply(id, result) {
+    return JSON.stringify({ jsonrpc: "2.0", id, result });
+}
+function fail(id, code, message) {
+    return JSON.stringify({ jsonrpc: "2.0", id: id ?? null, error: { code, message } });
+}
+export function createMcpServer(tools, info) {
+    const byName = new Map(tools.map((tool) => [tool.name, tool]));
+    async function handle(message) {
+        const isNotification = message.id === undefined;
+        if (message.jsonrpc !== "2.0" || typeof message.method !== "string") {
+            return isNotification ? null : fail(message.id, ERROR.invalidRequest, "Invalid request");
+        }
+        switch (message.method) {
+            case "initialize": {
+                const requested = String(message.params?.protocolVersion ?? "");
+                const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requested)
+                    ? requested
+                    : SUPPORTED_PROTOCOL_VERSIONS[0];
+                return reply(message.id, {
+                    protocolVersion,
+                    capabilities: { tools: { listChanged: false } },
+                    serverInfo: info,
+                });
+            }
+            case "ping":
+                return reply(message.id, {});
+            case "tools/list":
+                return reply(message.id, {
+                    tools: tools.map(({ name, description, inputSchema }) => ({
+                        name,
+                        description,
+                        inputSchema,
+                    })),
+                });
+            case "tools/call": {
+                const name = message.params?.name;
+                const tool = typeof name === "string" ? byName.get(name) : undefined;
+                if (!tool)
+                    return fail(message.id, ERROR.invalidParams, `Unknown tool: ${String(name)}`);
+                const args = message.params?.arguments;
+                if (args !== undefined &&
+                    (typeof args !== "object" || args === null || Array.isArray(args))) {
+                    return fail(message.id, ERROR.invalidParams, "arguments must be an object");
+                }
+                try {
+                    const result = await tool.handler((args ?? {}));
+                    return reply(message.id, {
+                        content: [{ type: "text", text: JSON.stringify(result.data) }],
+                        structuredContent: result.data,
+                        isError: result.isError,
+                    });
+                }
+                catch (error) {
+                    // A tool failure is a tool result, not a protocol error, so the model can read and react to it.
+                    const text = error instanceof Error ? error.message : String(error);
+                    return reply(message.id, {
+                        content: [{ type: "text", text }],
+                        isError: true,
+                    });
+                }
+            }
+            default:
+                // Notifications such as notifications/initialized need no reply; unknown requests do.
+                return isNotification
+                    ? null
+                    : fail(message.id, ERROR.methodNotFound, `Method not found: ${message.method}`);
+        }
+    }
+    return {
+        async handleLine(line) {
+            if (!line.trim())
+                return null;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                return fail(null, ERROR.parse, "Parse error");
+            }
+            if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+                return fail(null, ERROR.invalidRequest, "Invalid request");
+            }
+            return handle(parsed);
+        },
+    };
+}

package/cli/dist/mcp/tools.js

@@ -0,0 +1,351 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { spawn } from "node:child_process";
+import { closeSync, existsSync, openSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { isAbsolute, join } from "node:path";
+import { createMachineEnvelope } from "../utils/machine-output.js";
+/** A service or stack name. A leading "-" is rejected so a value can never be read as a flag. */
+const NAME = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const SINCE = /^(\d+(\.\d+)?(ns|us|µs|ms|s|m|h))+$/;
+/**
+ * How to run this CLI again: `node <script>` / `bun <script>` when started from a script, or the executable alone when it is
+ * a `bun build --compile` binary, whose argv[1] is a virtual path that exists only inside the binary.
+ */
+export function cliInvocation(execPath = process.execPath, script = process.argv[1], fileExists = existsSync) {
+    if (!script || script.startsWith("/$bunfs/") || script.includes("~BUN") || !fileExists(script)) {
+        return [execPath];
+    }
+    return [execPath, script];
+}
+/** Runs this same CLI (`flisk <args>`) so every tool behaves exactly like its command. */
+export const runTdkCli = (args, options = {}) => new Promise((resolve, reject) => {
+    const [command, ...prefix] = cliInvocation();
+    const child = spawn(command, [...prefix, ...args], {
+        cwd: options.cwd,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: { ...process.env, NO_COLOR: "1" },
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+        stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+        stderr += chunk.toString();
+    });
+    const timer = setTimeout(() => child.kill("SIGTERM"), options.timeoutMs ?? 120_000);
+    child.once("error", (error) => {
+        clearTimeout(timer);
+        reject(error);
+    });
+    child.once("close", (exitCode) => {
+        clearTimeout(timer);
+        resolve({ exitCode, stdout, stderr });
+    });
+});
+function names(value, field) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || !NAME.test(item))) {
+        throw new Error(`${field} must be an array of service names (letters, digits, ".", "_", "-")`);
+    }
+    return value;
+}
+function optionalName(value, field) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || !NAME.test(value)) {
+        throw new Error(`${field} must be a name (letters, digits, ".", "_", "-")`);
+    }
+    return value;
+}
+function flag(value, field) {
+    if (value === undefined)
+        return false;
+    if (typeof value !== "boolean")
+        throw new Error(`${field} must be a boolean`);
+    return value;
+}
+/** Turn a command's `--json` stdout into a tool result. A parseable envelope with errors, or `ok: false`, is an error result. */
+export function toToolResult(run) {
+    const text = run.stdout.trim();
+    // The envelope is the last JSON line; anything before it is incidental output.
+    const lastLine = text
+        .split("\n")
+        .filter((line) => line.trim().startsWith("{"))
+        .pop();
+    if (!lastLine) {
+        return {
+            data: {
+                errors: [
+                    {
+                        code: "NO_JSON",
+                        message: run.stderr.trim() || `flisk exited with code ${run.exitCode}`,
+                    },
+                ],
+            },
+            isError: true,
+        };
+    }
+    try {
+        const envelope = JSON.parse(lastLine);
+        const failed = (envelope.errors?.length ?? 0) > 0 || envelope.data?.ok === false;
+        return { data: envelope, isError: failed };
+    }
+    catch {
+        return {
+            data: { errors: [{ code: "BAD_JSON", message: lastLine.slice(0, 200) }] },
+            isError: true,
+        };
+    }
+}
+export const defaultUpDeps = {
+    spawnUp(args, logFile, cwd) {
+        const fd = openSync(logFile, "a");
+        const [command, ...prefix] = cliInvocation();
+        const child = spawn(command, [...prefix, ...args], {
+            cwd,
+            detached: true,
+            stdio: ["ignore", fd, fd],
+            env: { ...process.env, NO_COLOR: "1" },
+        });
+        closeSync(fd);
+        return child;
+    },
+    readLog(logFile) {
+        try {
+            return readFileSync(logFile, "utf-8");
+        }
+        catch {
+            return "";
+        }
+    },
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    now: () => Date.now(),
+    logFile: () => join(tmpdir(), `flisk-mcp-up-${Date.now()}.log`),
+};
+export function buildUpArgs(args) {
+    const stack = optionalName(args.stack, "stack");
+    const only = names(args.only, "only");
+    const out = ["up"];
+    if (stack)
+        out.push(stack);
+    if (only.length > 0)
+        out.push(...only.map((name) => `--only=${name}`));
+    if (flag(args.force, "force"))
+        out.push("--force");
+    if (flag(args.dryRun, "dryRun"))
+        out.push("--dry-run");
+    out.push("--json");
+    return out;
+}
+/**
+ * Starts the stack detached and returns without waiting for it to be ready (a build can take minutes, longer than a tool
+ * call may last). It watches only for an early result, which is how a refusal such as UNKNOWN_SERVICE, TILT_ALREADY_RUNNING
+ * or an unsupported host arrives; otherwise the caller polls the `status` tool for `data.tilt.readiness`.
+ */
+export async function startUp(args, deps = defaultUpDeps) {
+    const argv = buildUpArgs(args);
+    const logFile = deps.logFile();
+    const child = deps.spawnUp(argv, logFile, projectPath(args.projectPath));
+    let exited;
+    child.once("exit", (code) => {
+        exited = code;
+    });
+    const waitMs = typeof args.waitSeconds === "number"
+        ? Math.min(Math.max(args.waitSeconds, 0), 60) * 1000
+        : 15_000;
+    const deadline = deps.now() + waitMs;
+    for (;;) {
+        const log = deps.readLog(logFile);
+        const line = log
+            .split("\n")
+            .filter((l) => l.startsWith('{"schemaVersion"'))
+            .pop();
+        if (line)
+            return { ...toToolResult({ exitCode: exited ?? null, stdout: line, stderr: "" }) };
+        if (exited !== undefined) {
+            return toToolResult({ exitCode: exited, stdout: "", stderr: log.slice(-2000) });
+        }
+        if (deps.now() >= deadline)
+            break;
+        await deps.sleep(250);
+    }
+    child.unref();
+    return {
+        data: createMachineEnvelope({
+            ok: true,
+            started: true,
+            pid: child.pid ?? null,
+            logFile,
+            next: "Poll the status tool until data.tilt.readiness.ready is true. Call down to stop it.",
+        }),
+        isError: false,
+    };
+}
+export function buildLogsArgs(args) {
+    const out = ["logs", "--json"];
+    for (const name of names(args.services, "services"))
+        out.push(`--service=${name}`);
+    if (args.tail !== undefined) {
+        if (!Number.isInteger(args.tail) || args.tail < 1) {
+            throw new Error("tail must be a positive integer");
+        }
+        out.push(`--tail=${args.tail}`);
+    }
+    if (args.since !== undefined) {
+        if (typeof args.since !== "string" || !SINCE.test(args.since)) {
+            throw new Error("since must be a duration such as 30s, 5m or 1h");
+        }
+        out.push(`--since=${args.since}`);
+    }
+    return out;
+}
+const OBJECT = (properties) => ({
+    type: "object",
+    properties,
+    additionalProperties: false,
+});
+const PROJECT_PATH = {
+    type: "string",
+    description: "Absolute path to the Flisk project root; run this operation from that directory.",
+};
+function projectPath(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || !isAbsolute(value)) {
+        throw new Error("projectPath must be an absolute path to a Flisk project root");
+    }
+    return value;
+}
+export function createTdkTools(run = runTdkCli, up = defaultUpDeps) {
+    const viaCli = (build) => async (args) => toToolResult(await run(build(args), { cwd: projectPath(args.projectPath) }));
+    return [
+        {
+            name: "doctor",
+            description: "Check whether this machine can run the Flisk stack. Optionally set projectPath to include checks for a specific Flisk project. Returns data.ready and data.host.canUp; run it before `up`.",
+            inputSchema: OBJECT({
+                projectPath: PROJECT_PATH,
+                noPing: { type: "boolean", description: "Skip pinging running services' health endpoints" },
+            }),
+            handler: viaCli((args) => [
+                "doctor",
+                "--json",
+                ...(flag(args.noPing, "noPing") ? ["--no-ping"] : []),
+            ]),
+        },
+        {
+            name: "up",
+            description: "Start the stack (or part of it) detached from the optional projectPath and return without waiting for it to be ready. Poll `status` for data.tilt.readiness.ready. Fails fast on an unknown service, an unsupported host, or a Tilt already running.",
+            inputSchema: OBJECT({
+                projectPath: PROJECT_PATH,
+                stack: { type: "string", description: "Only this stack" },
+                only: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Start only these services plus what they depend on and shared infrastructure",
+                },
+                force: { type: "boolean", description: "Replace a Tilt that is already running" },
+                dryRun: { type: "boolean", description: "Show what would be started without starting" },
+                waitSeconds: {
+                    type: "number",
+                    description: "How long to watch for an early failure before returning (default 15, max 60)",
+                },
+            }),
+            handler: (args) => startUp(args, up),
+        },
+        {
+            name: "down",
+            description: "Stop the running stack, optionally selecting its project with projectPath.",
+            inputSchema: OBJECT({
+                projectPath: PROJECT_PATH,
+                dryRun: { type: "boolean", description: "Show what would be stopped without stopping" },
+            }),
+            handler: viaCli((args) => [
+                "down",
+                "--json",
+                ...(flag(args.dryRun, "dryRun") ? ["--dry-run"] : []),
+            ]),
+        },
+        {
+            name: "status",
+            description: "Stacks, resources, their ingress URLs and container ports, the stack-level ports, and Tilt readiness (data.tilt.readiness: ready, pending, failures, enabled; null when no Tilt answers). Optionally select the project with projectPath.",
+            inputSchema: OBJECT({ projectPath: PROJECT_PATH }),
+            handler: viaCli(() => ["status", "--json"]),
+        },
+        {
+            name: "logs",
+            description: "A bounded snapshot of recent logs from the running stack (default the last 200 lines, at most 10000). Optionally select the project with projectPath. Not a stream.",
+            inputSchema: OBJECT({
+                projectPath: PROJECT_PATH,
+                services: { type: "array", items: { type: "string" }, description: "Only these services" },
+                tail: { type: "integer", minimum: 1, maximum: 10000 },
+                since: {
+                    type: "string",
+                    description: "Only logs newer than this, for example 30s, 5m, 1h",
+                },
+            }),
+            handler: viaCli(buildLogsArgs),
+        },
+        {
+            name: "resource_list",
+            description: "List the selected project's services (resources) with their stack, type and port. Set projectPath when the MCP server is not running from the project root.",
+            inputSchema: OBJECT({
+                projectPath: PROJECT_PATH,
+                stack: { type: "string", description: "Only this stack" },
+            }),
+            handler: viaCli((args) => {
+                const stack = optionalName(args.stack, "stack");
+                return ["resources", "--json", ...(stack ? [`--stack=${stack}`] : [])];
+            }),
+        },
+        {
+            name: "restart_resource",
+            description: "Restart a running resource in the stack (or trigger its rebuild). Set projectPath when the MCP server is not running from the project root.",
+            inputSchema: OBJECT({
+                projectPath: PROJECT_PATH,
+                resource: { type: "string", description: "Name of the resource to restart" },
+            }),
+            handler: viaCli((args) => {
+                const resource = optionalName(args.resource, "resource");
+                if (!resource)
+                    throw new Error("resource is required");
+                return ["restart", resource, "--json"];
+            }),
+        },
+        {
+            name: "list_agents",
+            description: "List AI agent resources (appType: 'agent') in the project with their stack, runtime, durability and port. Set projectPath when the MCP server is not running from the project root.",
+            inputSchema: OBJECT({
+                projectPath: PROJECT_PATH,
+                stack: { type: "string", description: "Only this stack" },
+            }),
+            handler: viaCli((args) => {
+                const stack = optionalName(args.stack, "stack");
+                return ["resources", "--type=agent", "--json", ...(stack ? [`--stack=${stack}`] : [])];
+            }),
+        },
+        {
+            name: "get_agent_sessions",
+            description: "Inspect session checkpoints from a running AI agent resource. Set projectPath when the MCP server is not running from the project root.",
+            inputSchema: {
+                ...OBJECT({
+                    projectPath: PROJECT_PATH,
+                    resource: { type: "string", description: "Name of the agent resource" },
+                    sessionId: { type: "string", description: "Session ID to fetch (required)" },
+                }),
+                required: ["resource", "sessionId"],
+            },
+            handler: viaCli((args) => {
+                const resource = optionalName(args.resource, "resource");
+                if (!resource)
+                    throw new Error("resource is required");
+                const sessionId = optionalName(args.sessionId, "sessionId");
+                if (!sessionId)
+                    throw new Error("sessionId is required");
+                return ["agent", "sessions", resource, `--session-id=${sessionId}`, "--json"];
+            }),
+        },
+    ];
+}

package/cli/dist/program.js

@@ -0,0 +1,37 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+/**
+ * The root program.
+ *
+ * The commands live in `commands/registry.ts`; this module wires them into a Commander program.
+ * The shell completion generator reads the same program, so the completions and the CLI can never
+ * disagree about which commands and flags exist.
+ */
+import chalk from "chalk";
+import { Command } from "commander";
+import pkg from "../package.json" with { type: "json" };
+import { showHelp } from "./commands/help.js";
+import { getRegisteredCommands } from "./commands/registry.js";
+/** Builds the root program with every registered command. */
+export function createProgram() {
+    const program = new Command();
+    program
+        .name("flisk")
+        .description("Flisk CLI — start services on your machine.")
+        .version(pkg.version, "-v, --version", "Display version number")
+        .option("--verbose", "Enable verbose output", false)
+        .configureOutput({
+        outputError: (str, write) => write(chalk.red(str)),
+        writeOut: (str) => process.stdout.write(str),
+        writeErr: (str) => process.stderr.write(str),
+    });
+    program.helpCommand("help [command]", "Show colorful help").on("--help", () => {
+        showHelp();
+        process.exit(0);
+    });
+    program.addHelpText("before", "");
+    for (const command of getRegisteredCommands()) {
+        program.addCommand(command);
+    }
+    return program;
+}

package/cli/dist/types/index.js

@@ -0,0 +1,38 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { RESOURCE_DEFAULTS_FILE, TECH_STACK_FILE } from "../utils/constants.js";
+export const RESOURCE_CONFIG_APP_TYPES = [
+    "backend",
+    "frontend",
+    "library",
+    "sdk",
+    "worker",
+    "migrator",
+    "mcp",
+    "agent",
+    "bring-your-own",
+];
+export const CREATABLE_RESOURCE_TYPES = [
+    "backend",
+    "frontend",
+    "worker",
+    "mcp",
+    "agent",
+    "bring-your-own",
+];
+/**
+ * Every value `flisk resource --type` accepts: the creatable types plus `sdk`, which registers a
+ * package that already exists instead of scaffolding one.
+ */
+export const RESOURCE_TYPE_VALUES = [...CREATABLE_RESOURCE_TYPES, "sdk"];
+export function isCreatableResourceType(value) {
+    return (typeof value === "string" && CREATABLE_RESOURCE_TYPES.includes(value));
+}
+/**
+ * Type guard to validate filename is a known master config file.
+ * Eliminates the need for 'as MasterConfigFileName' assertion.
+ */
+export function isMasterConfigFileName(filename) {
+    const validNames = [TECH_STACK_FILE, RESOURCE_DEFAULTS_FILE, "spec.master"];
+    return validNames.includes(filename);
+}

package/cli/dist/utils/agent-host.js

@@ -0,0 +1,36 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { existsSync } from "node:fs";
+export const WEBCONTAINER_DOCS = "docs/agent-hosts.md";
+export const WEBCONTAINER_UP_MESSAGE = `WebContainers cannot run Flisk: there is no Docker daemon or Tilt. Run \`flisk up\` on a machine with Docker. See ${WEBCONTAINER_DOCS}.`;
+export const DEVCONTAINER_DOCKER_FIX = `Docker is not reachable from this Dev Container. Mount the host Docker socket (-v /var/run/docker.sock:/var/run/docker.sock) or add the docker-outside-of-docker feature to devcontainer.json, then retry. Docker-in-docker is not supported. See ${WEBCONTAINER_DOCS}.`;
+function defaultInputs() {
+    return {
+        env: process.env,
+        versions: process.versions,
+        platform: process.platform,
+        fileExists: existsSync,
+    };
+}
+/** Classify where the CLI is running. Informational: Docker reachability is still decided by the runtime checks. */
+export function detectHost(inputs = defaultInputs()) {
+    const { env, versions, platform, fileExists } = inputs;
+    if (versions.webcontainer) {
+        return { kind: "webcontainer", canUp: false };
+    }
+    if (env.CODESPACES === "true")
+        return { kind: "codespaces", canUp: true };
+    if (env.REMOTE_CONTAINERS || (fileExists("/.dockerenv") && env.DEVCONTAINER)) {
+        return { kind: "devcontainer", canUp: true };
+    }
+    // Mirrors nativeWindowsUpRefusal in commands/up.ts: native Windows is inspect-only unless explicitly overridden.
+    if (platform === "win32") {
+        return { kind: "native-windows", canUp: env.TDK_ALLOW_NATIVE_WINDOWS === "1" };
+    }
+    if (platform === "linux" && env.WSL_DISTRO_NAME)
+        return { kind: "wsl2", canUp: true };
+    return { kind: "local", canUp: true };
+}
+export function isContainerHost(kind) {
+    return kind === "devcontainer" || kind === "codespaces";
+}

package/cli/dist/utils/atomic-write.js

@@ -0,0 +1,36 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { randomBytes } from "node:crypto";
+import { closeSync, fchmodSync, fsyncSync, openSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { basename, dirname, join } from "node:path";
+/**
+ * Replaces `filePath` in one step. A plain writeFileSync truncates first, so an interrupt mid-write leaves a
+ * half-written file that looks current; here readers see the old content or the new content, never a mix.
+ */
+export function writeTextFileAtomic(filePath, content) {
+    const tempPath = join(dirname(filePath), `.${basename(filePath)}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`);
+    let mode;
+    try {
+        mode = statSync(filePath).mode & 0o777;
+    }
+    catch {
+        mode = undefined;
+    }
+    try {
+        const fd = openSync(tempPath, "wx");
+        try {
+            if (mode !== undefined)
+                fchmodSync(fd, mode);
+            writeFileSync(fd, content, "utf-8");
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+        renameSync(tempPath, filePath);
+    }
+    catch (error) {
+        rmSync(tempPath, { force: true });
+        throw error;
+    }
+}

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

@@ -0,0 +1,9 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { MIN_BUN_VERSION, versionMeetsMinimum } from "../commands/doctor.js";
+/** The Bun floor `flisk doctor` enforces, so `flisk up` cannot drift from it. */
+export function bunMeetsFloor(version) {
+    return versionMeetsMinimum(version, MIN_BUN_VERSION);
+}
+/** "1.2+" for a floor of 1.2.0, the wording the preflight already printed. */
+export const BUN_FLOOR_LABEL = `${MIN_BUN_VERSION[0]}.${MIN_BUN_VERSION[1]}+`;

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

@@ -0,0 +1,10 @@
+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.
+ */
+export function projectNeedsBun(resources) {
+    return resources.some((resource) => isApiServiceType(resource.config?.appType) ||
+        resource.config?.appType === "frontend" ||
+        resource.config?.appType === "worker");
+}