@flisk-sh/flisk 1.4.5 → 1.4.6

package/README.md

@@ -114,13 +114,13 @@ flisk resource shop-web --type frontend --stack shop --yes
 flisk up shop
 ```
 
-You get an orders API and a storefront behind one local gateway, with Postgres and live reload. You need Docker, [Tilt](https://docs.tilt.dev/install.html), Node.js 22.12+, and [Bun](https://bun.sh/) 1.2+; `flisk doctor` checks your machine. Prefer to answer questions instead? `npm init create-microservices my-project` asks what to create. See the [quick start](#quick-start) for every option.
+You get an orders API and a storefront behind one local gateway, with Postgres and live reload. You need Docker, [Tilt](https://docs.tilt.dev/install.html), Node.js 22.12+, and [Bun](https://bun.sh/) 1.2+; `flisk doctor` checks your machine. A simpler app needs none of those: give each service a `command` and [run it as local processes](docs/run-without-docker.md). Prefer to answer questions instead? `npm init create-microservices my-project` asks what to create. See the [quick start](#quick-start) for every option.
 
 <div align="center">
 
 <p><strong><a href="#quick-start">Quick start</a> · <a href="#why-flisk-cli">Why Flisk</a> · <a href="#examples">Examples</a> · <a href="#installation">Installation</a> · <a href="#faq">FAQ</a> · <a href="#docs">Documentation</a></strong></p>
 
-[Website](https://flisk.sh/) · [Quickstart](https://flisk.sh/docs/quickstart/) · [Examples](https://flisk.sh/docs/examples/) · [Awesome Flisk](https://github.com/flisk-sh/awesome-tdk-framework) · [Demo](https://flisk-sh.github.io/flisk-demo-animation/) · [Report a bug](https://github.com/flisk-sh/flisk/issues)
+[Website](https://flisk.sh/) · [Quickstart](https://flisk.sh/docs/quickstart/) · [Examples](https://flisk.sh/docs/examples/) · [Awesome Flisk](https://github.com/flisk-sh/awesome-flisk-framework) · [Demo](https://flisk-sh.github.io/flisk-demo-animation/) · [Report a bug](https://github.com/flisk-sh/flisk/issues)
 
 <a id="readme-languages"></a>
 
@@ -245,7 +245,7 @@ flisk up shop
 Agents get durable checkpoint volumes that survive `flisk down`, sticky session routing via `x-session-id`, graceful SIGTERM drain during hot reloads, a Docker health check on `/health`, and application-level readiness checks on `/ready`. See the [AI agents guide](docs/agents/ai-agents.md) and [honest comparison with agent frameworks](docs/compare-honest.md#ai-agent-frameworks-and-workflow-engines-libfx-langgraph-mastra-vercel-workflows-temporal).
 
 
-**What Flisk is:** a local development runtime. Define each service in `service.json` and run `flisk up`. Docker runs the containers, Tilt live-updates them while you code, and Flisk writes the configuration both use. No local Kubernetes is needed.
+**What Flisk is:** a local development runtime. Define each service in `service.json` and run `flisk up`. A service with a `command` runs as a local process, with nothing else installed. When you need a database, one gateway URL, or the container you deploy, Docker runs the containers, Tilt live-updates them while you code, and Flisk writes the configuration both use. No local Kubernetes is needed.
 
 **What Flisk is not:** a deploy tool or a Compose file. Production deployment stays with Helm, Argo CD, or Kustomize.
 
@@ -337,19 +337,42 @@ Get a running local stack in **3 commands**. Works on macOS, Linux, and Windows
 
 ### Prerequisites (install once)
 
-| Tool | Version | Install | Install path |
-|------|---------|---------|--------------|
-| **Docker** | Engine 25+, Compose 2.20.2+ | [docker.com](https://www.docker.com/products/docker-desktop/) | All paths |
-| **Tilt** | 0.25+ | `curl -fsSL https://raw.githubusercontent.com/tilt-dev/tilt/master/scripts/install.sh \| bash` | All paths |
-| **Node.js** | 22.12+ | [nodejs.org](https://nodejs.org/) | npm path (`npm install -g @flisk-sh/flisk`) |
-| **Bun** | 1.2+ | `curl -fsSL https://bun.sh/install \| bash` | Bun path (`bun add -g @flisk-sh/flisk`) |
+| Tool | Version | Install | Needed for |
+|------|---------|---------|------------|
+| **Your app's runtime** | whatever your app uses | Node.js, Python, Go, Bun, ... | Every path: it runs your code |
+| **Node.js** | 22.12+ | [nodejs.org](https://nodejs.org/) | npm install (`npm install -g @flisk-sh/flisk`) |
+| **Docker** | Engine 25+, Compose 2.20.2+ | [docker.com](https://www.docker.com/products/docker-desktop/) | Docker + Tilt path only |
+| **Tilt** | 0.25+ | `curl -fsSL https://raw.githubusercontent.com/tilt-dev/tilt/master/scripts/install.sh \| bash` | Docker + Tilt path only |
+| **Bun** | 1.2+ | `curl -fsSL https://bun.sh/install \| bash` | Bun install (`bun add -g @flisk-sh/flisk`), or generated JavaScript services |
 
-> **Conditional prerequisites**: Node.js is only required when you install Flisk via npm (`npm install -g @flisk-sh/flisk`). Bun is only required when you install via Bun or your project has generated JavaScript services. Docker and Tilt are required for every path.
+> **Two paths.** A project whose services each declare a `command` runs them as local processes: you need only Flisk and your app's runtime ([simplest path](#simplest-path-no-docker)). Docker and Tilt are needed for the Docker + Tilt path: databases such as Postgres, one gateway URL for every service, and running the same container you deploy. `flisk doctor` checks only what your project uses.
 
 > **Windows?** Use WSL2 Ubuntu. See the [Windows & WSL2 guide](docs/wsl2.md) for the recommended setup.
 
 ---
 
+### Simplest path: no Docker
+
+For an app made of services you can start with one command each (an API, a website, a worker), put a `service.json` next to each one:
+
+```json
+{ "schemaVersion": 1, "name": "api", "command": "node server.js", "port": 4000, "healthCheckPath": "/health" }
+```
+
+```json
+{ "schemaVersion": 1, "name": "web", "command": "node server.js", "port": 3000, "dependsOn": ["api"] }
+```
+
+Then start everything from the project folder:
+
+```bash
+flisk up
+```
+
+Flisk starts the API, waits until it answers, starts the website, prints both URLs, prefixes each line of output with the service name, and restarts a service that crashes. Ctrl+C or `flisk down` stops them. No Docker, no Tilt, no generated files. See [Run your app without Docker](docs/run-without-docker.md) for every field, and for when to switch to the Docker + Tilt path.
+
+---
+
 ### Fastest path: one-command demo (no manual steps)
 
 ```bash
@@ -596,11 +619,11 @@ Runnable examples show Flisk on real stacks. Start with the smallest one:
 | [one-backend-helm](examples/one-backend-helm/README.md) | Working alongside Helm |
 | [byo](examples/byo/README.md) | Bringing your own existing resources |
 | [byo-jobs](examples/byo-jobs/README.md) | Bring-your-own jobs |
-| [tdk-example](examples/tdk-example/README.md) | A full multi-service stack |
+| [flisk-example](examples/flisk-example/README.md) | A full multi-service stack |
 
 ## Use Flisk with your AI agent
 
-The repository ships five agent skills for common Flisk work under [`.agents/skills`](.agents/skills): `flisk-doctor` (environment checks), `flisk-up` (preview and start a stack), `flisk-resource` (create a service), `flisk-status` (health and URLs), and `flisk-troubleshoot` (fixing `flisk` and Tilt errors). Agents working in this repo also follow [AGENTS.md](AGENTS.md). Use these skills to let your agent check your setup and explain failures instead of guessing at Docker or Tilt configuration.
+The repository ships agent skills for common Flisk work under [`.agents/skills`](.agents/skills): `flisk-build` (turn "build me a shop" into Flisk steps, check every URL, and report them), `flisk-recipe-starters` (start from a working restaurant, SaaS, store, AI agent or user-management app), recipes for a shop, a SaaS with login and billing, an AI agent with MCP tools and a database, and a blog (`flisk-recipe-shop`, `flisk-recipe-saas`, `flisk-recipe-ai-agent`, `flisk-recipe-blog`), `flisk-doctor` (environment checks), `flisk-up` (preview and start a stack), `flisk-resource` (create a service), `flisk-status` (health and URLs), and `flisk-troubleshoot` (fixing `flisk` and Tilt errors). More prompts to copy, by category (spreadsheets, recruiting, product management, shops, AI agents), are in the [prompt gallery](docs/recipes/build-with-your-agent.md). Agents working in this repo also follow [AGENTS.md](AGENTS.md). Use these skills to let your agent check your setup and explain failures instead of guessing at Docker or Tilt configuration.
 
 ## Installation
 
@@ -648,7 +671,7 @@ Set `FLISK_DEBUG=1` before running `flisk up --verbose` to include Starlark debu
 - [Generated service files and drift checks](docs/generated-files.md)
 - [Runnable one-backend example](examples/one-backend/README.md)
 - [Runnable Python backend example](examples/one-backend-python/README.md)
-- [Full multi-service example](examples/tdk-example/README.md)
+- [Full multi-service example](examples/flisk-example/README.md)
 - [Features and license limits](docs/FEATURES.md)
 - [Tool comparison: docker-compose, Tilt, Skaffold, DevSpace, kind](docs/comparison.md)
 - [Honest comparison and known limits](docs/compare-honest.md)
@@ -686,7 +709,7 @@ On native Windows, `flisk --version`, `flisk doctor`, and `flisk up --dry-run` a
 
 Core stays free. Premium is a separate key for the extras above; no key required to run `flisk up`.
 
-**Ecosystem map:** examples, articles, related tools, and notes live in [awesome-tdk-framework](https://github.com/flisk-sh/awesome-tdk-framework). Star this repo (`flisk`) if the CLI is what you run; use the awesome list to browse the rest.
+**Ecosystem map:** examples, articles, related tools, and notes live in [awesome-flisk-framework](https://github.com/flisk-sh/awesome-flisk-framework). Star this repo (`flisk`) if the CLI is what you run; use the awesome list to browse the rest.
 
 <p align="center">
 

package/cli/dist/commands/doctor.js

@@ -15,6 +15,7 @@ import { isPathDiscovered, readDiscoveryPaths } from "../utils/discovery-paths.j
 import { checkCrashLoopingContainers } from "../utils/doctor-crashloop.js";
 import { applyDoctorFixes, checkDuplicateFliskInstalls, hasFailedActions, planDoctorFixes, projectTiltPids, } from "../utils/doctor-fix.js";
 import { checkDiskSpace, dockerDesktopStuck } from "../utils/doctor-host.js";
+import { checkNativeCommands, checkNativeDependsOn, checkNativeRuntime, checkNativeServiceHealth, } from "../utils/doctor-native.js";
 import { collectDoctorChecks, createDoctorReport, getDoctorExitCode, } from "../utils/doctor-report.js";
 import { checkHealthRoutes, checkIngressPorts, checkPrivateNpmRegistry, checkTiltResourceHealth, projectConfigEnablesVerdaccio, summarizeAdvertisedProbes, summarizeServiceProbes, summarizeSmokeResults, } from "../utils/doctor-runtime.js";
 import { checkStarlarkLoadExports } from "../utils/doctor-starlark.js";
@@ -25,6 +26,7 @@ import { evaluateFliskVersionFloor } from "../utils/flisk-version.js";
 import { formatCount } from "../utils/formatting.js";
 import { getHostPortPlan, resolveRuntimeIngressPort } from "../utils/host-port-config.js";
 import { createHostPortPlan } from "../utils/host-port-plan.js";
+import { findNativeProject } from "../utils/native-project.js";
 import { findProjectRoot, getPackageVersion } from "../utils/paths.js";
 import { promptConfirm } from "../utils/prompt.js";
 import { EnvUnreadableError, envSecretValues, redactSecrets, redactValue, } from "../utils/secret-redaction.js";
@@ -1285,8 +1287,13 @@ export const doctorCommand = new Command("doctor")
         process.exit(2);
         return;
     }
+    // A project whose services all declare `command` runs as local processes: doctor checks only what they need (#2231).
+    const nativeProject = findNativeProject();
+    const nativeResources = nativeProject?.resources ?? null;
     if (!options.json) {
-        console.log("Flisk doctor checks your local Docker + Tilt development environment; it does not check cluster deployments.");
+        console.log(nativeResources
+            ? "Flisk doctor checks what this project's local processes need; its services declare commands, so Docker and Tilt are not checked."
+            : "Flisk doctor checks your local Docker + Tilt development environment; it does not check cluster deployments.");
     }
     const host = detectHost();
     if (process.platform === "win32") {
@@ -1343,10 +1350,15 @@ export const doctorCommand = new Command("doctor")
         console.log(`\n${chalk.bold("🔍 Flisk Doctor")}\n`);
         console.log("Checking environment...\n");
     }
-    const projectRoot = findProjectRoot();
+    // A directory of command services is a project for doctor even before `flisk up` writes its .flisk/project.json.
+    const projectRoot = findProjectRoot() ?? nativeProject?.projectRoot ?? null;
     // Repairs run before the checks so the checks report the state after the fix.
     let fixActions;
-    if (options.fix) {
+    if (options.fix && nativeResources) {
+        // The repairs are for Docker networks and Tilt probes, which a project of local processes does not have.
+        fixActions = [];
+    }
+    else if (options.fix) {
         try {
             let projectName;
             if (projectRoot) {
@@ -1388,16 +1400,19 @@ export const doctorCommand = new Command("doctor")
         if (!options.json)
             printFixActions(fixActions, options.dryRun);
     }
+    // The host port plan places the gateway and Postgres containers; a project of local processes has neither.
     let hostPortPlan;
     let portPlanError;
-    try {
-        hostPortPlan = await getHostPortPlan(projectRoot ?? process.cwd());
-    }
-    catch (error) {
-        hostPortPlan = null;
-        portPlanError = error instanceof Error ? error.message : String(error);
+    if (!nativeResources) {
+        try {
+            hostPortPlan = await getHostPortPlan(projectRoot ?? process.cwd());
+        }
+        catch (error) {
+            hostPortPlan = null;
+            portPlanError = error instanceof Error ? error.message : String(error);
+        }
     }
-    const machineChecks = [
+    const containerMachineChecks = [
         () => hostPortPlan
             ? {
                 name: "Host Ports",
@@ -1434,7 +1449,7 @@ export const doctorCommand = new Command("doctor")
         requiresContainerRuntime("Docker Network Pool", () => checkDockerNetworkCapacity()),
         () => checkDuplicateFliskInstalls(),
     ];
-    const projectChecks = [
+    const containerProjectChecks = [
         () => checkFliskVersion(),
         checkMasterConfigs,
         checkGeneratedProjectRuntimeAssets,
@@ -1495,8 +1510,31 @@ export const doctorCommand = new Command("doctor")
         // When Tilt is up, surface red resources (Traefik/apps never started).
         requiresContainerRuntime("Tilt Resources", checkTiltResourceHealth),
     ];
+    const machineChecks = nativeResources
+        ? [
+            () => checkNativeRuntime(nativeResources),
+            () => checkNativeCommands(nativeResources),
+            () => checkWslProjectLocation(findProjectRoot() ?? process.cwd(), options.strict),
+            () => checkDuplicateFliskInstalls(),
+        ]
+        : containerMachineChecks;
+    const projectChecks = nativeResources
+        ? [
+            () => checkFliskVersion(),
+            () => checkDuplicateResourceNames(),
+            () => checkDependsOnShape(),
+            () => checkNativeDependsOn(nativeResources),
+            () => checkCircularDependencies(),
+            () => checkServicePorts(),
+            () => checkSchemaVersions(undefined, options.strict),
+            () => checkDuplicateResourcePorts(),
+        ]
+        : containerProjectChecks;
+    if (options.ping && nativeResources && projectRoot) {
+        projectChecks.push(() => checkNativeServiceHealth(projectRoot, nativeResources, pingTimeout));
+    }
     // Runs last: needs routable services (and working Traefik) to mean anything.
-    if (options.ping) {
+    if (options.ping && !nativeResources) {
         // Probe the port a running stack is actually on, not the one the next `flisk up` would pick.
         const pingPort = projectRoot
             ? resolveRuntimeIngressPort(projectRoot, hostPortPlan?.ingressHttp)

package/cli/dist/commands/down.js

@@ -8,8 +8,10 @@ import { pruneProjectNetworks, stopProjectTiltUp, waitForTiltUpExit, } from "../
 import { errorFactories, handleTiltFailure, withTiltCheck } from "../utils/errors.js";
 import { createJsonEmitter } from "../utils/json-output.js";
 import { writeMachineError } from "../utils/machine-output.js";
+import { readNativeRunState, stopNativeRun } from "../utils/native-runtime.js";
+import { isNativeProject } from "../utils/native-service.js";
 import { findProjectRoot } from "../utils/paths.js";
-import { discoverResources, discoverStacks } from "../utils/services.js";
+import { discoverResources, discoverResourcesFromRoot, discoverStacks } from "../utils/services.js";
 import { buildTiltDownArgs, getTiltfilePath, runTilt } from "../utils/tilt.js";
 function allStackNames() {
     try {
@@ -20,6 +22,17 @@ function allStackNames() {
         return undefined;
     }
 }
+/** True when `flisk down` stops local processes instead of Tilt: a native run is on record, or every service declares `command`. */
+function isNativeRun(projectRoot) {
+    if (readNativeRunState(projectRoot))
+        return true;
+    try {
+        return isNativeProject(discoverResourcesFromRoot(projectRoot));
+    }
+    catch {
+        return false;
+    }
+}
 function pruneNetworksOrWarn(json) {
     const root = findProjectRoot();
     if (!root)
@@ -64,6 +77,25 @@ export const downCommand = addYesOption(new Command("down"))
         }
     }
     const emit = options.json ? createJsonEmitter("DOWN_FAILED", "flisk down") : undefined;
+    // A project of `command` services (or one with a native run on record) stops without Docker or Tilt.
+    const projectRoot = findProjectRoot();
+    if (isNativeRun(projectRoot)) {
+        if (emit && options.dryRun) {
+            emit({ ok: true, dryRun: true, runtime: "native" });
+            return;
+        }
+        if (handleDryRun(options, "not stopping local processes", "stop the local processes of this project")) {
+            return;
+        }
+        const stopped = await stopNativeRun(projectRoot);
+        if (!options.json) {
+            console.log(stopped.wasRunning
+                ? chalk.blue(`Stopped local processes: ${stopped.services.join(", ")}`)
+                : chalk.gray("Nothing is running for this project."));
+        }
+        emit?.({ ok: true, runtime: "native", stopped: stopped.services });
+        return;
+    }
     await withTiltCheck(async () => {
         if (emit && options.dryRun) {
             emit({ ok: true, dryRun: true });

package/cli/dist/commands/logs.js

@@ -4,10 +4,13 @@ import { Command } from "commander";
 import { STANDARD_PORTS } from "../utils/constants.js";
 import { errorFactories, FliskError, runCommand, showErrorAndExit } from "../utils/errors.js";
 import { createMachineEnvelope } from "../utils/machine-output.js";
+import { readNativeLogLines } from "../utils/native-runtime.js";
+import { isNativeProject } from "../utils/native-service.js";
 import { findProjectRoot } from "../utils/paths.js";
 import { EnvUnreadableError, envSecretValues, redactSecrets, redactValue, } from "../utils/secret-redaction.js";
+import { discoverResourcesFromRoot } from "../utils/services.js";
 import { isTiltAvailable, runTilt } from "../utils/tilt.js";
-import { DEFAULT_LOG_TAIL, isTiltConnectionFailure, isValidPort, isValidSince, isValidTail, MAX_LOG_TAIL, parseTiltLogLines, } from "../utils/tilt-logs.js";
+import { DEFAULT_LOG_TAIL, isTiltConnectionFailure, isValidPort, isValidSince, isValidTail, MAX_LOG_TAIL, parseTiltLogLines, sinceMilliseconds, } from "../utils/tilt-logs.js";
 import { tiltUnreachableMessage } from "../utils/tilt-unreachable-message.js";
 /** Resource names Tilt knows about, or null when they cannot be listed (the logs call then reports the real error). */
 async function tiltResourceNames(port) {
@@ -25,6 +28,17 @@ async function tiltResourceNames(port) {
         return null;
     }
 }
+/** The project's services when every one declares `command` (they run as local processes), else null. */
+function nativeResources(projectRoot) {
+    try {
+        const resources = discoverResourcesFromRoot(projectRoot);
+        return isNativeProject(resources) ? resources : null;
+    }
+    catch {
+        // Discovery problems are reported by the commands that start the stack; logs still asks Tilt.
+        return null;
+    }
+}
 export const logsCommand = new Command("logs")
     .description("Print a bounded snapshot of recent logs from the running stack")
     .showHelpAfterError("\nService names are not positional. Use: flisk logs --service <name>")
@@ -81,6 +95,29 @@ export const logsCommand = new Command("logs")
                 "Fix the read permission on .env, or move it out of the project",
             ]);
         }
+        // A project of `command` services keeps its output in .flisk/native/logs, so no Tilt is involved.
+        const resources = nativeResources(projectRoot);
+        if (resources) {
+            const known = resources.map((resource) => resource.name);
+            const unknown = services.filter((name) => !known.includes(name));
+            if (unknown.length > 0) {
+                const error = errorFactories.unknownServices(unknown, known);
+                fail("UNKNOWN_SERVICE", error.message, error.exitCode, error.suggestions);
+            }
+            const lines = readNativeLogLines(projectRoot, services.length > 0 ? services : known, {
+                tail,
+                sinceMs: options.since === undefined ? undefined : sinceMilliseconds(options.since),
+            });
+            if (options.json) {
+                console.log(JSON.stringify(redactValue(createMachineEnvelope({ services, tail, since: options.since ?? null, lines }), secrets)));
+                return;
+            }
+            const width = Math.max(0, ...lines.map((line) => line.resource.length));
+            for (const line of lines) {
+                console.log(redactSecrets(`${line.resource.padEnd(width)} | ${line.text}`, secrets));
+            }
+            return;
+        }
         if (!(await isTiltAvailable())) {
             fail("TILT_MISSING", "Tilt is not installed. Run: flisk doctor");
         }

package/cli/dist/commands/project.js

@@ -213,6 +213,17 @@ const DEFAULT_PROJECT_JSON = {
     },
     overrides: {},
 };
+/**
+ * Writes .flisk/project.json with the defaults `flisk project --yes` uses, and nothing else: no generated Tiltfile, Compose file,
+ * .env or engine copy. `flisk up` uses it to adopt a directory of `command` services as a project, so `flisk down` and
+ * `flisk doctor` find it afterwards.
+ */
+export function writeDefaultProjectConfig(projectRoot) {
+    const projectConfig = JSON.parse(JSON.stringify(DEFAULT_PROJECT_JSON));
+    projectConfig.project.name = basename(projectRoot) || "my-project";
+    ensureDirectory(join(projectRoot, ".flisk"));
+    writeJsonFile(join(projectRoot, ".flisk", PROJECT_JSON), projectConfig);
+}
 export const projectCommand = addYesOption(new Command("project"))
     .alias("init")
     .description("Initialize or validate project-level master configuration")

package/cli/dist/commands/status.js

@@ -8,6 +8,8 @@ import { runCommand } from "../utils/errors.js";
 import { formatCount, showDetail, showStep } from "../utils/formatting.js";
 import { getHostPortPlan } from "../utils/host-port-config.js";
 import { createMachineEnvelope, writeMachineError } from "../utils/machine-output.js";
+import { nativeServiceStates } from "../utils/native-runtime.js";
+import { isNativeProject } from "../utils/native-service.js";
 import { findProjectRoot } from "../utils/paths.js";
 import { deriveServiceStates } from "../utils/service-runtime-state.js";
 import { groupSharedPostgres, readProjectName } from "../utils/shared-infra.js";
@@ -31,19 +33,30 @@ export const statusCommand = new Command("status")
         const sharedInfraGroup = projectName
             ? groupSharedPostgres(projectName, discovery.stacks)
             : null;
+        // A project of `command` services runs as local processes: its state comes from the run on record, not from Tilt.
+        const nativeStates = projectRoot && isNativeProject(discovery.resources)
+            ? nativeServiceStates(projectRoot, discovery.resources.map((resource) => resource.name))
+            : null;
         let tiltAvailable = false;
-        try {
-            tiltAvailable = await isTiltAvailable();
-        }
-        catch {
-            // Tilt not available (spawn error)
-            tiltAvailable = false;
+        if (!nativeStates) {
+            try {
+                tiltAvailable = await isTiltAvailable();
+            }
+            catch {
+                // Tilt not available (spawn error)
+                tiltAvailable = false;
+            }
         }
         if (!options.json) {
             showStep("Flisk Status\n");
-            console.log(chalk.bold("Tilt:"), tiltAvailable ? chalk.green("available") : chalk.red("not found"));
-            if (!tiltAvailable) {
-                showDetail("Install Tilt: https://docs.tilt.dev/install.html");
+            if (nativeStates) {
+                console.log(chalk.bold("Runtime:"), "local processes (no Docker, no Tilt)");
+            }
+            else {
+                console.log(chalk.bold("Tilt:"), tiltAvailable ? chalk.green("available") : chalk.red("not found"));
+                if (!tiltAvailable) {
+                    showDetail("Install Tilt: https://docs.tilt.dev/install.html");
+                }
             }
             console.log();
         }
@@ -53,7 +66,7 @@ export const statusCommand = new Command("status")
         // Tilt answers or its output cannot be read.
         let readiness = null;
         // The same look at Tilt feeds readiness and each service's state, so `flisk status` and `flisk ui` cannot disagree.
-        let serviceStates = null;
+        let serviceStates = nativeStates;
         const tiltPort = getTiltPollingPort(process.env.TILT_PORT);
         // Port plan is best effort; service URLs are shown in both JSON and terminal output.
         let portPlan = null;
@@ -99,7 +112,23 @@ export const statusCommand = new Command("status")
         }
         if (options.json) {
             const errors = queryError ? [{ code: "TILT_STATUS_UNAVAILABLE", message: queryError }] : [];
+            // A native run answers the readiness question agents poll (data.tilt.readiness.ready) from its own run state.
+            if (nativeStates) {
+                const states = Object.entries(nativeStates);
+                const isRunning = states.some(([, state]) => state.status !== "unknown");
+                readiness = isRunning
+                    ? {
+                        ready: states.every(([, state]) => state.status === "ready"),
+                        failures: [],
+                        pending: states.filter(([, state]) => state.status !== "ready").length,
+                        timedOut: false,
+                        enabled: states.map(([name]) => name),
+                    }
+                    : null;
+            }
             const data = {
+                // Only a project of local processes says so; a container project's report keeps its shape.
+                ...(nativeStates ? { runtime: "native" } : {}),
                 tilt: {
                     available: tiltAvailable,
                     resourcesQueried: options.tilt && tiltAvailable,

package/cli/dist/commands/up.js

@@ -20,6 +20,9 @@ import { exportHostPortPlan, getHostPortPlan, writeSavedHostPortPlan, } from "..
 import { formatHostPortPlan } from "../utils/host-port-plan.js";
 import { createJsonEmitter } from "../utils/json-output.js";
 import { toMachineError } from "../utils/machine-output.js";
+import { hasNearbyServiceJson } from "../utils/native-project.js";
+import { formatMixedRuntimeRefusal, isNativeProject, isNativeService, resolveRuntimeMode, } from "../utils/native-service.js";
+import { runNativeUp } from "../utils/native-up.js";
 import { nativeWindowsStackRefusal } from "../utils/native-windows.js";
 import { findProjectRoot, getPackageVersion } from "../utils/paths.js";
 import { findAvailablePort } from "../utils/port-assignment.js";
@@ -38,7 +41,7 @@ import { stopTiltOnPort } from "../utils/tilt-process.js";
 import { parseTiltPort, resolveTiltPort, secondUpAction, stopTiltForUp, } from "../utils/tilt-startup.js";
 import { findUnknownServices, resolveOnlySelection } from "../utils/up-only.js";
 import { tiltGetUiResources, waitForTiltResourcesReady } from "../utils/up-readiness.js";
-import { enableDiscoveredStacks } from "./project.js";
+import { enableDiscoveredStacks, writeDefaultProjectConfig } from "./project.js";
 export function formatUpSuccess(port, options = {}) {
     const { appUrls = [], serviceHealth = [], showLogsHint = serviceHealth.length > 0 } = options;
     const lines = [];
@@ -235,6 +238,67 @@ function envFileFailure(error) {
         exitCode: error instanceof FliskError ? error.exitCode : 2,
     };
 }
+/**
+ * Decides whether `flisk up` runs the selection as local processes (#2229). Returns null for today's Docker + Tilt path, which
+ * a project without any `command` service always takes. Outside a project, a directory whose services all declare `command`
+ * becomes the project. Refuses (through `fail`) an unknown stack or service, an invalid service.json, and a run that would mix
+ * native and container services.
+ */
+export function selectNativeRun(stackName, only, fail, cwd = process.cwd()) {
+    const foundRoot = findProjectRoot(cwd);
+    if (!foundRoot && !hasNearbyServiceJson(cwd))
+        return null;
+    const projectRoot = foundRoot ?? cwd;
+    let discovered;
+    try {
+        discovered = discoverResourcesWithProblems(projectRoot);
+    }
+    catch {
+        return null;
+    }
+    const all = discovered.resources;
+    if (!all.some(isNativeService))
+        return null;
+    if (!foundRoot && !isNativeProject(all))
+        return null;
+    if (discovered.problems.length > 0) {
+        fail("INVALID_SERVICE_CONFIG", discovered.problems
+            .map((problem) => `Invalid service.json at ${problem.path}: ${problem.reason}`)
+            .join("\n"));
+    }
+    let requested = all;
+    if (stackName) {
+        if (!stackExists(stackName, all)) {
+            const error = errorFactories.stackNotFound(stackName, discoverStacks(all).map((s) => s.name));
+            fail("STACK_NOT_FOUND", error.message, error.suggestions);
+        }
+        requested = getResourcesForStack(stackName, all);
+    }
+    if (only) {
+        const unknown = findUnknownServices(only, requested);
+        if (unknown.length > 0) {
+            const error = errorFactories.unknownServices(unknown, requested.map((service) => service.name));
+            fail("UNKNOWN_SERVICE", error.message, error.suggestions);
+        }
+    }
+    // A process cannot start before what it depends on, so a stack or --only selection always brings its dependsOn closure.
+    const names = only ?? requested.map((service) => service.name);
+    const selection = resolveOnlySelection(names, all);
+    const { mode, mixed } = resolveRuntimeMode(selection.selected, all);
+    if (mode === "container") {
+        const containerNames = (selection.selected.some(isNativeService) ? selection.selected : all)
+            .filter((service) => !isNativeService(service))
+            .map((service) => service.name);
+        fail("MIXED_RUNTIME", formatMixedRuntimeRefusal(mixed, containerNames));
+    }
+    return {
+        projectRoot,
+        isNewProject: !foundRoot,
+        all,
+        selected: selection.selected,
+        dependencies: only ? selection.dependencies : [],
+    };
+}
 export const upCommand = new Command("up")
     .description("Start all services (optionally filtered by stack)")
     .alias("deploy")
@@ -266,6 +330,60 @@ export const upCommand = new Command("up")
             onFail: (message) => emit?.({ ok: false }, [{ code: "FLISK_VERSION_TOO_OLD", message }]),
         });
     }
+    // Every selected service declares `command`: run them as local processes, with no Docker, Compose, Tilt or generated
+    // files (#2229). Decided before any Docker or Tilt check; a project without `command` services never enters this branch.
+    const nativeRun = selectNativeRun(stackName, options.only, (code, message, suggestions) => {
+        emit?.({ ok: false }, [
+            { code, message, ...(suggestions && suggestions.length > 0 ? { suggestions } : {}) },
+        ]);
+        return showErrorAndExit(message, 1, suggestions);
+    });
+    if (nativeRun) {
+        const platformRefusal = nativeWindowsUpRefusal(process.platform, process.env.FLISK_ALLOW_NATIVE_WINDOWS);
+        if (platformRefusal)
+            showErrorAndExit(platformRefusal);
+        const { projectRoot } = nativeRun;
+        let envFilePath;
+        if (options.envFile !== undefined) {
+            try {
+                envFilePath = selectEnvFile(projectRoot, options.envFile).path;
+            }
+            catch (error) {
+                const { failure, exitCode } = envFileFailure(error);
+                emit?.({ ok: false }, [failure]);
+                showErrorAndExit(failure.message, exitCode, failure.suggestions);
+            }
+        }
+        if (!nativeRun.isNewProject) {
+            enforceSchemaVersionGate(projectRoot, {
+                resources: nativeRun.all,
+                onInvalid: (message) => emit?.({ ok: false }, [{ code: "INVALID_SCHEMA_VERSION", message }]),
+            });
+        }
+        enforceServiceConfigGate(projectRoot, {
+            resources: nativeRun.all,
+            onInvalid: (message) => emit?.({ ok: false }, [{ code: "INVALID_SERVICE_CONFIG", message }]),
+        });
+        if (nativeRun.isNewProject && !options.dryRun) {
+            writeDefaultProjectConfig(projectRoot);
+            if (!options.quiet) {
+                console.log(chalk.gray("Created .flisk/project.json (this directory is now a Flisk project)"));
+            }
+        }
+        await runNativeUp({
+            projectRoot,
+            selected: nativeRun.selected,
+            dependencies: nativeRun.dependencies,
+            stackName,
+            only: options.only,
+            envFilePath,
+            dryRun: options.dryRun,
+            quiet: options.quiet,
+            force: options.force,
+            emit,
+        });
+        return;
+    }
     // The env file of the run. `--env-file` replaces the project .env for this run, so the file is
     // resolved and read before any prerequisite check, any write and any service starts.
     const envFileRoot = versionRoot;

package/cli/dist/commands/upgrade.js

@@ -140,7 +140,7 @@ export function detectAllInstallations() {
     return [...unique.values()];
 }
 const BINARY_RELEASE_REPO = "flisk-sh/releases";
-const ENGINE_ASSET_NAME = "tdk-cli-engine.tar.gz";
+const ENGINE_ASSET_NAME = "flisk-cli-engine.tar.gz";
 const CHECKSUMS_ASSET_NAME = "checksums.txt";
 /** Parses `shasum -a 256` / `sha256sum` output ("<hash>  <name>" or "<hash> *<name>"). */
 /** @internal Exported for unit tests only; not part of the package API. */
@@ -656,7 +656,7 @@ export function createUpgradeCommand() {
                     showErrorAndExit("Flisk Windows v1 supports AMD64 only. Use WSL2 Ubuntu or a 64-bit Intel/AMD PC.");
                 }
                 if (process.platform === "win32") {
-                    showErrorAndExit("No Windows AMD64 binary in this Flisk release. Need asset tdk-windows-amd64.exe.");
+                    showErrorAndExit("No Windows AMD64 binary in this Flisk release. Need asset flisk-windows-amd64.exe.");
                 }
                 showErrorAndExit(`Unsupported OS: Flisk does not support this OS: ${process.platform}. Supported: linux, darwin, win32.`);
             }

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"));
 }