@flisk-sh/flisk 0.0.0-stage → 1.3.190

package/cli/dist/backend-languages/node.js

@@ -0,0 +1,122 @@
+export const NODE_DEV_COMMAND = "node --watch src/index.js";
+export const nodeBackendProvider = {
+    id: "node",
+    label: "Node.js 22",
+    devCommand: NODE_DEV_COMMAND,
+    watch: ["src/**/*"],
+    installHint: "npm install   # optional: Docker builds the image for you",
+    createFiles(name) {
+        return [
+            {
+                filename: "package.json",
+                content: `{
+  "name": "${name}",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "node --watch src/index.js",
+    "start": "node src/index.js",
+    "test": "node --test"
+  }
+}
+`,
+                description: "Generating package.json",
+                emoji: "📦",
+            },
+            {
+                // The generated Dockerfile runs `npm ci`, which needs a lockfile. This one matches the dependency-free package.json;
+                // `npm install` regenerates it once the project adds dependencies.
+                filename: "package-lock.json",
+                content: `{
+  "name": "${name}",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "${name}",
+      "version": "1.0.0"
+    }
+  }
+}
+`,
+                description: "Generating package-lock.json",
+                emoji: "🔒",
+            },
+            {
+                filename: "src/index.js",
+                content: `import http from "node:http";
+
+const name = "${name}";
+const port = Number(process.env.PORT) || 3000;
+
+function sendJson(res, status, data) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(data));
+}
+
+export const server = http.createServer((req, res) => {
+  const url = new URL(req.url, \`http://\${req.headers.host || "localhost"}\`);
+
+  // Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
+  if (req.method === "GET" && url.pathname === "/health") {
+    return sendJson(res, 200, { status: "ok", service: name });
+  }
+
+  if (req.method === "GET" && url.pathname === "/") {
+    return sendJson(res, 200, {
+      service: name,
+      version: "1.0.0",
+      endpoints: ["/health"],
+    });
+  }
+
+  return sendJson(res, 404, { error: "Not Found" });
+});
+
+if (process.env.NODE_ENV !== "test") {
+  // "0.0.0.0" listens on every interface, which Traefik needs inside the container network.
+  server.listen(port, "0.0.0.0", () => {
+    console.log(\`\\n🚀 \${name} running on http://localhost:\${port}\`);
+    console.log(\`📊 Health check: http://localhost:\${port}/health\\n\`);
+  });
+}
+`,
+                description: "Generating backend source",
+                emoji: "💻",
+            },
+            {
+                filename: "tests/health.test.js",
+                content: `import assert from "node:assert/strict";
+import { after, before, describe, it } from "node:test";
+import { server } from "../src/index.js";
+
+describe("health check", () => {
+  let baseUrl;
+
+  before((_, done) => {
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      baseUrl = \`http://127.0.0.1:\${address.port}\`;
+      done();
+    });
+  });
+
+  after((_, done) => {
+    server.close(done);
+  });
+
+  it("GET /health returns 200 with ok status", async () => {
+    const res = await fetch(\`\${baseUrl}/health\`);
+    assert.equal(res.status, 200);
+    const body = await res.json();
+    assert.deepEqual(body, { status: "ok", service: "${name}" });
+  });
+});
+`,
+                description: "Generating smoke test",
+                emoji: "🧪",
+            },
+        ];
+    },
+};

package/cli/dist/backend-languages/python.js

@@ -0,0 +1,94 @@
+export const PYTHON_DEV_COMMAND = "uvicorn main:app --app-dir src --host 0.0.0.0 --port ${PORT:-4000} --reload --reload-dir src";
+export const pythonBackendProvider = {
+    id: "python",
+    label: "Python 3.12 + FastAPI",
+    devCommand: PYTHON_DEV_COMMAND,
+    watch: ["src/**/*"],
+    installHint: 'pip install -e ".[dev]"   # optional: Docker builds the image for you',
+    createFiles(name) {
+        return [
+            {
+                filename: "pyproject.toml",
+                content: `[project]
+name = "${name}"
+version = "0.0.1"
+requires-python = ">=3.12"
+dependencies = [
+  "fastapi==0.115.6",
+  "uvicorn[standard]==0.34.0",
+]
+
+[project.optional-dependencies]
+dev = [
+  "pytest==9.0.3",
+  "httpx==0.28.1",
+]
+
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+# Only the dependencies are installed into the image; the source is synced for live reload.
+[tool.setuptools]
+py-modules = []
+
+[tool.pytest.ini_options]
+pythonpath = ["src"]
+testpaths = ["tests"]
+`,
+                description: "Generating pyproject.toml",
+                emoji: "📦",
+            },
+            {
+                filename: "src/main.py",
+                content: `import os
+
+from fastapi import FastAPI
+
+app = FastAPI(title="${name}")
+
+
+@app.get("/health")
+def health() -> dict[str, str]:
+    return {"status": "ok", "service": "${name}"}
+
+
+@app.get("/")
+def root() -> dict[str, object]:
+    return {"service": "${name}", "version": "1.0.0", "endpoints": ["/health"]}
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run(app, host="0.0.0.0", port=int(os.environ.get("PORT", "3000")))
+`,
+                description: "Generating backend source",
+                emoji: "💻",
+            },
+            {
+                filename: "tests/test_health.py",
+                content: `from fastapi.testclient import TestClient
+
+from main import app
+
+client = TestClient(app)
+
+
+def test_health() -> None:
+    response = client.get("/health")
+    assert response.status_code == 200
+    assert response.json() == {"status": "ok", "service": "${name}"}
+
+
+def test_root() -> None:
+    response = client.get("/")
+    assert response.status_code == 200
+    assert response.json() == {"service": "${name}", "version": "1.0.0", "endpoints": ["/health"]}
+`,
+                description: "Generating test file",
+                emoji: "🧪",
+            },
+        ];
+    },
+};

package/cli/dist/backend-languages/registry.js

@@ -0,0 +1,37 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { TdkError } from "../utils/errors.js";
+import { bunBackendProvider } from "./bun.js";
+import { goBackendProvider } from "./go.js";
+import { nodeBackendProvider } from "./node.js";
+import { pythonBackendProvider } from "./python.js";
+import { rustBackendProvider } from "./rust.js";
+export const DEFAULT_BACKEND_LANGUAGE = "bun";
+export const BACKEND_LANGUAGES = {
+    bun: bunBackendProvider,
+    python: pythonBackendProvider,
+    go: goBackendProvider,
+    rust: rustBackendProvider,
+    node: nodeBackendProvider,
+};
+export function getBackendLanguage(languageId) {
+    const id = (languageId ?? DEFAULT_BACKEND_LANGUAGE).trim().toLowerCase();
+    const provider = Object.hasOwn(BACKEND_LANGUAGES, id) ? BACKEND_LANGUAGES[id] : undefined;
+    if (!provider) {
+        const supportedIds = Object.keys(BACKEND_LANGUAGES).join(", ");
+        throw new TdkError(`Unknown backend language "${languageId}". Supported languages: ${supportedIds}.`, [`Use one of: ${supportedIds}`, `Omit --language to use ${DEFAULT_BACKEND_LANGUAGE}`]);
+    }
+    return provider;
+}
+/** Returns the provider for a backend, or undefined for other types. Rejects --language elsewhere. */
+export function resolveBackendLanguage(resourceType, languageId) {
+    if (resourceType !== "backend") {
+        if (languageId !== undefined) {
+            throw new TdkError("--language can only be used with --type backend.", [
+                "Add --type backend, or drop --language for this resource type",
+            ]);
+        }
+        return undefined;
+    }
+    return getBackendLanguage(languageId);
+}

package/cli/dist/backend-languages/rust.js

@@ -0,0 +1,82 @@
+/**
+ * Rust is compiled into the image and has no reload process, so the dev command is only what a developer
+ * would run by hand. Tilt rebuilds the image when a watched file changes (the engine returns no live-update rules).
+ */
+export const RUST_DEV_COMMAND = "cargo run";
+export const rustBackendProvider = {
+    id: "rust",
+    label: "Rust (axum)",
+    devCommand: RUST_DEV_COMMAND,
+    watch: ["src/**/*.rs", "Cargo.toml", "Cargo.lock"],
+    installHint: "cargo build   # optional: Docker builds the image for you",
+    createFiles(name) {
+        return [
+            {
+                filename: "Cargo.toml",
+                content: `[package]
+name = "${name}"
+version = "0.1.0"
+edition = "2021"
+
+# The image copies the release binary by this fixed name.
+[[bin]]
+name = "app"
+path = "src/main.rs"
+
+[dependencies]
+axum = "0.8"
+serde_json = "1"
+tokio = { version = "1", features = ["macros", "rt-multi-thread", "net"] }
+`,
+                description: "Generating Cargo.toml",
+                emoji: "📦",
+            },
+            {
+                filename: "src/main.rs",
+                content: `use axum::{routing::get, Json, Router};
+use serde_json::{json, Value};
+
+fn app() -> Router {
+    Router::new()
+        .route("/", get(root))
+        // Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
+        .route("/health", get(health))
+}
+
+async fn root() -> Json<Value> {
+    Json(json!({ "service": "${name}", "version": "1.0.0", "endpoints": ["/health"] }))
+}
+
+async fn health() -> Json<Value> {
+    Json(json!({ "status": "ok", "service": "${name}" }))
+}
+
+#[tokio::main]
+async fn main() {
+    let port = std::env::var("PORT").unwrap_or_else(|_| "3000".to_string());
+
+    // 0.0.0.0 listens on every interface, which Traefik needs inside the container network.
+    let listener = tokio::net::TcpListener::bind(format!("0.0.0.0:{port}"))
+        .await
+        .expect("failed to bind the port");
+    println!("${name} listening on 0.0.0.0:{port}");
+    axum::serve(listener, app()).await.expect("server error");
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn health_reports_ok() {
+        let Json(body) = health().await;
+        assert_eq!(body["status"], "ok");
+    }
+}
+`,
+                description: "Generating backend source and smoke test",
+                emoji: "💻",
+            },
+        ];
+    },
+};

package/cli/dist/backend-languages/types.js

@@ -0,0 +1 @@
+export {};

package/cli/dist/cli.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { showHelp } from "./commands/help.js";
+import { createProgram } from "./program.js";
+import { formatColdPreflight, runColdPreflight } from "./utils/cold-preflight.js";
+import { unknownHelpTarget } from "./utils/help-command.js";
+const program = createProgram();
+// Default: show help if no command provided
+if (process.argv.length === 2) {
+    const result = await runColdPreflight();
+    console.log(formatColdPreflight(result));
+    console.log("\nCommands: flisk doctor | flisk project --yes | flisk --help");
+    process.exit(result.ok ? 0 : 1);
+}
+if (process.argv[2] === "--doctor")
+    process.argv[2] = "doctor";
+if (process.argv.length === 3 && ["-h", "--help", "help"].includes(process.argv[2])) {
+    showHelp();
+    process.exit(0);
+}
+const unknownHelp = unknownHelpTarget(process.argv.slice(2), program.commands);
+if (unknownHelp) {
+    program.error(`error: unknown command '${unknownHelp}'`, {
+        exitCode: 1,
+        code: "commander.unknownCommand",
+    });
+}
+program.parse();

package/cli/dist/commands/__tests__/project-e2e-helpers.js

@@ -0,0 +1,49 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { execFileSync, spawnSync } from "node:child_process";
+import { cpSync, mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { expect } from "vitest";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export const repoRoot = resolve(__dirname, "../../../..");
+export const cliBin = join(repoRoot, "cli", "bin", "flisk.js");
+export function runTdk(args, cwd, input) {
+    return execFileSync(process.execPath, [cliBin, ...args], {
+        cwd,
+        encoding: "utf-8",
+        input,
+        env: {
+            ...process.env,
+            TDK_EXTENSION_SOURCE: repoRoot,
+        },
+    });
+}
+/** `flisk doctor` exits non-zero on machines without Docker, so read its output either way. */
+export function runTdkAllowFailure(args, cwd) {
+    const result = spawnSync(process.execPath, [cliBin, ...args], {
+        cwd,
+        encoding: "utf-8",
+        env: { ...process.env, TDK_EXTENSION_SOURCE: repoRoot },
+    });
+    return `${result.stdout}${result.stderr}`;
+}
+/**
+ * Copies a project that `flisk project --yes` already generated into a fresh temp directory. Scaffolding costs
+ * several seconds per run, so a file generates one base project in `beforeAll` and each test copies it instead.
+ * Only use a copy for a test that starts from a generated project; a test that checks generation itself must
+ * generate its own.
+ */
+export function copyProject(source) {
+    const target = mkdtempSync(join(tmpdir(), "flisk-project-copy-"));
+    cpSync(source, target, { recursive: true });
+    return target;
+}
+export function starlarkSection(content, name) {
+    const start = content.indexOf(`${name} = {`);
+    expect(start).toBeGreaterThanOrEqual(0);
+    const end = content.indexOf("\n}", start);
+    expect(end).toBeGreaterThan(start);
+    return content.slice(start, end + 2);
+}

package/cli/dist/commands/__tests__/ui-loading-screen.test.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { renderToString } from "ink";
+import { describe, expect, it } from "vitest";
+import { LoadingScreen } from "../ui.js";
+describe("ui LoadingScreen", () => {
+    it("shows honest text with no percentage", () => {
+        const out = renderToString(_jsx(LoadingScreen, { animated: false }));
+        expect(out).toContain("Discovering resources...");
+        expect(out).not.toContain("%");
+    });
+    it("renders a spinner frame only when animated", () => {
+        expect(renderToString(_jsx(LoadingScreen, { animated: true }))).toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏] Discovering/);
+        expect(renderToString(_jsx(LoadingScreen, { animated: false }))).not.toMatch(/[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏]/);
+    });
+});
+//# sourceMappingURL=ui-loading-screen.test.js.map

package/cli/dist/commands/agent.js

@@ -0,0 +1,182 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import * as http from "node:http";
+import chalk from "chalk";
+import { Command } from "commander";
+import { createDiscoveryContext } from "../utils/discovery-context.js";
+import { errorFactories, runCommand, TdkError } from "../utils/errors.js";
+import { getHostPortPlan } from "../utils/host-port-config.js";
+import { createMachineEnvelope, writeMachineError } from "../utils/machine-output.js";
+import { findProjectRoot } from "../utils/paths.js";
+import { buildServicePorts } from "../utils/status-ports.js";
+const SESSION_REQUEST_TIMEOUT_MS = 10_000;
+/** GET with node:http because fetch silently drops a custom Host header, which is what Traefik routes on. */
+export function httpGet(url, headers, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        // One signal covers the connection and the body read, so a hung agent cannot block the CLI.
+        const req = http.get(url, { headers, signal: AbortSignal.timeout(timeoutMs) }, (res) => {
+            const chunks = [];
+            res.on("data", (chunk) => chunks.push(chunk));
+            res.on("end", () => {
+                const status = res.statusCode ?? 0;
+                resolve({
+                    ok: status >= 200 && status < 300,
+                    status,
+                    text: Buffer.concat(chunks).toString("utf-8"),
+                });
+            });
+            res.on("error", reject);
+        });
+        req.on("error", reject);
+    });
+}
+/**
+ * Agent containers publish no host port; the only way in is the Traefik route that `flisk status` prints as `url`
+ * (for example http://api.<project>.localhost:8080/api/bot). `*.localhost` does not resolve everywhere (glibc without
+ * systemd-resolved), so connect to loopback and keep the route's host in the Host header, which is all Traefik matches on.
+ */
+export function agentSessionRequest(routeUrl, sessionId) {
+    const route = new URL(routeUrl);
+    const headers = { "x-session-id": sessionId };
+    if (route.hostname.endsWith(".localhost")) {
+        headers.host = route.host;
+        route.hostname = "127.0.0.1";
+    }
+    return { url: `${route.origin}${route.pathname.replace(/\/$/, "")}/session`, headers };
+}
+export const agentCommand = new Command("agent").description("Inspect and operate AI agent resources");
+agentCommand
+    .command("sessions <resource>")
+    .description("Inspect session checkpoints from a running AI agent resource")
+    .option("--session-id <id>", "Session ID to fetch (required)")
+    .option("--json", "Output one JSON object and exit", false)
+    .action(async (resourceName, options) => {
+    const action = async () => {
+        const root = findProjectRoot();
+        if (!root) {
+            const error = errorFactories.notInProject();
+            if (options.json)
+                writeMachineError(error);
+            error.exit();
+        }
+        const discovery = createDiscoveryContext();
+        const resource = discovery.resources.find((r) => r.name === resourceName);
+        if (!resource) {
+            const msg = `Resource "${resourceName}" not found in project.`;
+            if (options.json) {
+                console.log(JSON.stringify(createMachineEnvelope(null, [{ code: "UNKNOWN_RESOURCE", message: msg }])));
+                process.exit(1);
+            }
+            throw new TdkError(msg);
+        }
+        const appType = resource.config?.appType ?? resource.type;
+        if (appType !== "agent") {
+            const msg = `Resource "${resourceName}" is of type "${appType}", not "agent".`;
+            if (options.json) {
+                console.log(JSON.stringify(createMachineEnvelope(null, [{ code: "NOT_AN_AGENT", message: msg }])));
+                process.exit(1);
+            }
+            throw new TdkError(msg);
+        }
+        const port = resource.port;
+        if (!port) {
+            const msg = `Agent "${resourceName}" has no assigned port.`;
+            if (options.json) {
+                console.log(JSON.stringify(createMachineEnvelope(null, [{ code: "NO_PORT", message: msg }])));
+                process.exit(1);
+            }
+            throw new TdkError(msg);
+        }
+        // The agent runtime keys GET /session by x-session-id and has no list endpoint, so a missing id
+        // would only come back as a confusing 400. Fail before any request. Checked after resource
+        // validation so UNKNOWN_RESOURCE, NOT_AN_AGENT and NO_PORT keep their precedence.
+        const sessionId = typeof options.sessionId === "string" ? options.sessionId.trim() : "";
+        if (!sessionId) {
+            const msg = `--session-id is required: the agent "${resourceName}" returns the checkpoint of one session.`;
+            if (options.json) {
+                console.log(JSON.stringify(createMachineEnvelope(null, [{ code: "SESSION_ID_REQUIRED", message: msg }])));
+                process.exit(1);
+            }
+            throw new TdkError(msg, [`Run: flisk agent sessions ${resourceName} --session-id <id>`]);
+        }
+        const portPlan = root
+            ? await getHostPortPlan(root, { inspectDocker: false }).catch(() => null)
+            : null;
+        const routeUrl = buildServicePorts(resource, portPlan?.ingressHttp).url;
+        if (!routeUrl) {
+            const msg = `Agent "${resourceName}" has no ingress route to reach it through.`;
+            if (options.json) {
+                console.log(JSON.stringify(createMachineEnvelope(null, [{ code: "NO_ROUTE", message: msg }])));
+                process.exit(1);
+            }
+            throw new TdkError(msg);
+        }
+        const request = agentSessionRequest(routeUrl, sessionId);
+        // Nothing answered, or Traefik answered for a missing backend: either way the agent is not up.
+        const notRunning = () => {
+            const msg = `Agent "${resourceName}" is not responding at ${routeUrl}. Is the stack running?`;
+            if (options.json) {
+                console.log(JSON.stringify(createMachineEnvelope(null, [{ code: "AGENT_NOT_RUNNING", message: msg }])));
+                process.exit(1);
+            }
+            throw new TdkError(msg, ["Start the stack with: flisk up"]);
+        };
+        let res;
+        let bodyText;
+        try {
+            const reply = await httpGet(request.url, request.headers, SESSION_REQUEST_TIMEOUT_MS);
+            res = reply;
+            bodyText = reply.text;
+        }
+        catch {
+            return notRunning();
+        }
+        let body = {};
+        try {
+            body = bodyText ? JSON.parse(bodyText) : {};
+        }
+        catch {
+            body = { raw: bodyText };
+        }
+        // Traefik answers 502/503/504 when the route has no live container and a plain-text 404 when it has no route at
+        // all. An agent's own errors are JSON, so a non-JSON 404 is the gateway, not the agent.
+        const gatewayText = typeof body === "object" && body !== null && "raw" in body;
+        if (!res.ok &&
+            ([502, 503, 504].includes(res.status) || (res.status === 404 && gatewayText))) {
+            return notRunning();
+        }
+        if (!res.ok) {
+            const detail = body?.error ?? bodyText;
+            if (options.json) {
+                console.log(JSON.stringify(createMachineEnvelope(null, [
+                    {
+                        code: "AGENT_REQUEST_FAILED",
+                        message: `Agent returned ${res.status}: ${detail}`,
+                    },
+                ])));
+                process.exit(1);
+            }
+            throw new TdkError(`Agent error (${res.status}): ${detail}`);
+        }
+        if (options.json) {
+            console.log(JSON.stringify(createMachineEnvelope({
+                agent: resourceName,
+                port,
+                session: body,
+            })));
+            return;
+        }
+        console.log(chalk.bold(`Sessions for ${resourceName}:`));
+        console.log(JSON.stringify(body, null, 2));
+    };
+    if (options.json) {
+        try {
+            await action();
+        }
+        catch (err) {
+            writeMachineError(err);
+        }
+        return;
+    }
+    await runCommand(action);
+});