@flisk-sh/flisk 0.0.0-stage → 1.3.190

package/cli/dist/backend-frameworks/fastify.js

@@ -0,0 +1,43 @@
+export function getFastifyIndexTemplate(name) {
+    return `import Fastify from 'fastify';
+
+const app = Fastify();
+
+// Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
+app.get('/health', async () => ({ status: 'ok', service: '${name}' }));
+
+app.get('/health/live', async () => ({ status: 'alive', timestamp: Date.now() }));
+
+app.get('/health/ready', async (_request, reply) => {
+  const dependencies: Record<string, string> = {};
+  let allReady = true;
+
+  // Add dependency checks here (database, cache, etc.)
+  // Mark allReady = false if any dependency is unhealthy
+
+  const status = allReady ? 'ready' : 'not_ready';
+  return reply.code(allReady ? 200 : 503).send({ status, dependencies });
+});
+
+app.get('/', async () => ({
+  service: '${name}',
+  version: '1.0.0',
+  endpoints: ['/health', '/health/live', '/health/ready']
+}));
+
+const port = Number(process.env.PORT || 3000);
+
+// Bind beyond loopback: Traefik reaches the container over the Docker network.
+await app.listen({ port, host: '0.0.0.0' });
+
+console.log('\\n🚀 ${name} running on http://localhost:' + port);
+console.log('📊 Health check: http://localhost:' + port + '/health\\n');
+`;
+}
+export const fastifyBackendProvider = {
+    id: "fastify",
+    label: "Bun + Fastify",
+    dependencies: { fastify: "^5.0.0" },
+    devDependencies: {},
+    createIndex: getFastifyIndexTemplate,
+};

package/cli/dist/backend-frameworks/h3.js

@@ -0,0 +1,37 @@
+export function getH3IndexTemplate(name) {
+    return `import { createServer } from 'node:http';
+import { createApp, createRouter, defineEventHandler, toNodeListener } from 'h3';
+
+const app = createApp();
+const router = createRouter();
+
+// Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
+router.get('/health', defineEventHandler(() => ({ status: 'ok', service: '${name}' })));
+
+router.get('/health/live', defineEventHandler(() => ({ status: 'alive', timestamp: Date.now() })));
+
+router.get('/', defineEventHandler(() => ({
+  service: '${name}',
+  version: '1.0.0',
+  endpoints: ['/health', '/health/live']
+})));
+
+app.use(router);
+
+const port = Number(process.env.PORT || 3000);
+
+// node:http works on Bun. Bind beyond loopback: Traefik reaches the container over the Docker network.
+createServer(toNodeListener(app)).listen(port, '0.0.0.0', () => {
+  console.log('\\n🚀 ${name} running on http://localhost:' + port);
+  console.log('📊 Health check: http://localhost:' + port + '/health\\n');
+});
+`;
+}
+export const h3BackendProvider = {
+    id: "h3",
+    label: "Bun + h3",
+    // h3's npm "latest" tag is a 2.0 release candidate; the scaffold stays on the stable 1.x line.
+    dependencies: { h3: "^1.15.0" },
+    devDependencies: {},
+    createIndex: getH3IndexTemplate,
+};

package/cli/dist/backend-frameworks/koa.js

@@ -0,0 +1,47 @@
+export function getKoaIndexTemplate(name) {
+    return `import Koa from 'koa';
+
+const app = new Koa();
+
+// Plain Koa middleware, so the scaffold needs no router dependency.
+app.use(async (ctx) => {
+  // Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
+  if (ctx.path === '/health') {
+    ctx.body = { status: 'ok', service: '${name}' };
+    return;
+  }
+
+  if (ctx.path === '/health/live') {
+    ctx.body = { status: 'alive', timestamp: Date.now() };
+    return;
+  }
+
+  if (ctx.path === '/') {
+    ctx.body = {
+      service: '${name}',
+      version: '1.0.0',
+      endpoints: ['/health', '/health/live']
+    };
+    return;
+  }
+
+  ctx.status = 404;
+  ctx.body = { error: 'not_found' };
+});
+
+const port = Number(process.env.PORT || 3000);
+
+// Bind beyond loopback: Traefik reaches the container over the Docker network.
+app.listen(port, '0.0.0.0', () => {
+  console.log('\\n🚀 ${name} running on http://localhost:' + port);
+  console.log('📊 Health check: http://localhost:' + port + '/health\\n');
+});
+`;
+}
+export const koaBackendProvider = {
+    id: "koa",
+    label: "Bun + Koa",
+    dependencies: { koa: "^3.0.0" },
+    devDependencies: { "@types/koa": "^3.0.0" },
+    createIndex: getKoaIndexTemplate,
+};

package/cli/dist/backend-frameworks/mcp.js

@@ -0,0 +1,86 @@
+export function getMcpIndexTemplate(name) {
+    return `import { createServer } from 'node:http';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { z } from 'zod';
+
+// A new McpServer per request keeps the endpoint stateless, so there is no session to lose when the container restarts.
+function buildServer() {
+  const server = new McpServer({ name: '${name}', version: '1.0.0' });
+
+  // Add your tools, resources and prompts here. This one is a placeholder you can delete.
+  server.registerTool(
+    'echo',
+    { description: 'Echo a message back', inputSchema: { message: z.string() } },
+    async ({ message }) => ({ content: [{ type: 'text', text: message }] })
+  );
+
+  return server;
+}
+
+async function readBody(req: import('node:http').IncomingMessage) {
+  const chunks: Buffer[] = [];
+  for await (const chunk of req) chunks.push(chunk as Buffer);
+  const raw = Buffer.concat(chunks).toString('utf8');
+  return raw ? JSON.parse(raw) : undefined;
+}
+
+const httpServer = createServer(async (req, res) => {
+  const path = (req.url ?? '/').split('?')[0];
+
+  // Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
+  if (path === '/health') {
+    res.setHeader('content-type', 'application/json');
+    res.end(JSON.stringify({ status: 'ok', service: '${name}' }));
+    return;
+  }
+
+  // MCP over Streamable HTTP. Clients POST JSON-RPC here.
+  if (path === '/mcp') {
+    if (req.method !== 'POST') {
+      res.statusCode = 405;
+      res.setHeader('allow', 'POST');
+      res.setHeader('content-type', 'application/json');
+      res.end(JSON.stringify({ jsonrpc: '2.0', error: { code: -32000, message: 'Method not allowed' }, id: null }));
+      return;
+    }
+
+    const server = buildServer();
+    const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+    res.on('close', () => {
+      transport.close();
+      server.close();
+    });
+    await server.connect(transport);
+    await transport.handleRequest(req, res, await readBody(req));
+    return;
+  }
+
+  res.statusCode = 404;
+  res.setHeader('content-type', 'application/json');
+  res.end(JSON.stringify({ error: 'not_found' }));
+});
+
+const port = Number(process.env.PORT || 3000);
+
+// Bind beyond loopback: Traefik reaches the container over the Docker network.
+httpServer.listen(port, '0.0.0.0', () => {
+  console.log('\\n🚀 ${name} MCP server on http://localhost:' + port + '/mcp');
+  console.log('📊 Health check: http://localhost:' + port + '/health\\n');
+});
+`;
+}
+/**
+ * The scaffold for \`--type mcp\`. It is not in BACKEND_FRAMEWORKS: \`mcp\` is a resource type of its own, not a \`--framework\`
+ * choice for a backend.
+ */
+export const mcpBackendProvider = {
+    id: "mcp",
+    label: "Bun + Model Context Protocol server",
+    dependencies: {
+        "@modelcontextprotocol/sdk": "^1.32.0",
+        zod: "^4.0.0",
+    },
+    devDependencies: {},
+    createIndex: getMcpIndexTemplate,
+};

package/cli/dist/backend-frameworks/nestjs.js

@@ -0,0 +1,55 @@
+export function getNestIndexTemplate(name) {
+    return `import 'reflect-metadata';
+import { Controller, Get, Module } from '@nestjs/common';
+import { NestFactory } from '@nestjs/core';
+
+@Controller()
+class AppController {
+  // Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
+  @Get('health')
+  health() {
+    return { status: 'ok', service: '${name}' };
+  }
+
+  @Get('health/live')
+  live() {
+    return { status: 'alive', timestamp: Date.now() };
+  }
+
+  @Get()
+  root() {
+    return { service: '${name}', version: '1.0.0', endpoints: ['/health', '/health/live'] };
+  }
+}
+
+@Module({ controllers: [AppController] })
+class AppModule {}
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule, { logger: ['error', 'warn', 'log'] });
+  const port = Number(process.env.PORT || 3000);
+
+  // Bind beyond loopback: Traefik reaches the container over the Docker network.
+  await app.listen(port, '0.0.0.0');
+  console.log('\\n🚀 ${name} running on http://localhost:' + port);
+  console.log('📊 Health check: http://localhost:' + port + '/health\\n');
+}
+
+bootstrap();
+`;
+}
+export const nestBackendProvider = {
+    id: "nestjs",
+    label: "Bun + NestJS",
+    dependencies: {
+        "@nestjs/common": "^11.0.0",
+        "@nestjs/core": "^11.0.0",
+        "@nestjs/platform-express": "^11.0.0",
+        "reflect-metadata": "^0.2.2",
+        rxjs: "^7.8.1",
+    },
+    devDependencies: {},
+    // Nest's decorators need these; the engine's generated Docker tsconfig already sets them.
+    compilerOptions: { experimentalDecorators: true, emitDecoratorMetadata: true },
+    createIndex: getNestIndexTemplate,
+};

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

@@ -0,0 +1,134 @@
+// Copyright (c) 2026 Flisk Landscape contributors
+// SPDX-License-Identifier: MIT
+import { resolveAgentRuntime } from "../agent-runtimes/registry.js";
+import { getBackendIndexTemplate } from "../backend-languages/bun.js";
+import { BACKEND_LANGUAGES, getBackendLanguage } from "../backend-languages/registry.js";
+import { TdkError } from "../utils/errors.js";
+import { elysiaBackendProvider } from "./elysia.js";
+import { expressBackendProvider } from "./express.js";
+import { fastifyBackendProvider } from "./fastify.js";
+import { h3BackendProvider } from "./h3.js";
+import { koaBackendProvider } from "./koa.js";
+import { mcpBackendProvider } from "./mcp.js";
+import { nestBackendProvider } from "./nestjs.js";
+/** Hono is the historical default; omitting --framework keeps the exact historical output. */
+export const DEFAULT_BACKEND_FRAMEWORK = "hono";
+export const honoBackendProvider = {
+    id: "hono",
+    label: "Bun + Hono",
+    dependencies: { hono: "^4.0.0" },
+    devDependencies: {},
+    createIndex: getBackendIndexTemplate,
+};
+export const BACKEND_FRAMEWORKS = {
+    hono: honoBackendProvider,
+    express: expressBackendProvider,
+    elysia: elysiaBackendProvider,
+    fastify: fastifyBackendProvider,
+    h3: h3BackendProvider,
+    koa: koaBackendProvider,
+    nestjs: nestBackendProvider,
+};
+/**
+ * The languages a framework can be combined with, decided by the same validation the resource command
+ * uses: a language that owns its runtime (python, go, rust, node) cannot be combined with a framework.
+ */
+function compatibleLanguages(frameworkId) {
+    return Object.keys(BACKEND_LANGUAGES).filter((languageId) => {
+        try {
+            resolveBackendFramework("backend", frameworkId, BACKEND_LANGUAGES[languageId]);
+            return true;
+        }
+        catch (error) {
+            // Only the "a language that owns its runtime cannot be combined with a framework" rule is
+            // expected here. Any other error is a bug and must surface instead of silently shrinking
+            // the language column.
+            if (error instanceof TdkError)
+                return false;
+            throw error;
+        }
+    });
+}
+/**
+ * Lists the registered backend frameworks with the language (and runtime) they are scaffolded with, so
+ * `flisk resource --type backend --frameworks` is the whole backend discovery surface.
+ *
+ * `languageId` is the language the listing is judged against; the default Bun language is used when it
+ * is omitted. A language that was asked for is named in the printed command, so copying a row never
+ * scaffolds a different language than the one the listing was about.
+ */
+export function listBackendFrameworks(languageId) {
+    const requested = getBackendLanguage(languageId);
+    const namesLanguage = languageId !== undefined;
+    return Object.entries(BACKEND_FRAMEWORKS).map(([id, provider]) => {
+        const languages = compatibleLanguages(id);
+        const compatible = languages.includes(requested.id);
+        const languageFlag = namesLanguage ? ` --language ${requested.id}` : "";
+        // A language that owns its runtime cannot be combined with a framework, so the row carries the
+        // command that creates the resource in that language, without a framework.
+        const command = compatible
+            ? `flisk resource <name> --type backend --framework ${id}${languageFlag}`
+            : `flisk resource <name> --type backend${languageFlag}`;
+        return {
+            id,
+            label: provider.label,
+            languages,
+            compatible,
+            command,
+        };
+    });
+}
+export function getBackendFramework(frameworkId) {
+    const id = (frameworkId ?? DEFAULT_BACKEND_FRAMEWORK).trim().toLowerCase();
+    const provider = Object.hasOwn(BACKEND_FRAMEWORKS, id) ? BACKEND_FRAMEWORKS[id] : undefined;
+    if (!provider) {
+        const supportedIds = Object.keys(BACKEND_FRAMEWORKS).join(", ");
+        throw new TdkError(`Unknown backend framework "${frameworkId}". Supported frameworks: ${supportedIds}.`, [`Use one of: ${supportedIds}`, `Omit --framework to use ${DEFAULT_BACKEND_FRAMEWORK}`]);
+    }
+    return provider;
+}
+/**
+ * Returns the provider for an explicit `--framework` on a backend, or undefined when none was given
+ * (the historical Hono scaffold). Python owns its runtime, so a framework cannot be combined with it.
+ */
+export function resolveBackendFramework(resourceType, frameworkId, language) {
+    // `mcp` is a resource type with one fixed scaffold, so a framework choice does not apply to it.
+    if (resourceType === "mcp") {
+        if (frameworkId !== undefined) {
+            throw new TdkError("--framework cannot be combined with --type mcp.", [
+                "An mcp resource always scaffolds a Model Context Protocol server",
+                "Drop --framework, or use --type backend --framework <id>",
+            ]);
+        }
+        if (language?.createFiles) {
+            throw new TdkError(`--language ${language.id} cannot be combined with --type mcp.`, [
+                "An mcp resource is a Bun service; drop --language",
+            ]);
+        }
+        return mcpBackendProvider;
+    }
+    // `agent` is scaffolded by an agent runtime (src/agent-runtimes/), not a framework. Only the default runtime is reachable here:
+    // `flisk resource` validates --runtime before it scaffolds, so the package.json and tsconfig always match the chosen runtime.
+    if (resourceType === "agent") {
+        if (frameworkId !== undefined && frameworkId !== "custom") {
+            throw new TdkError("--framework cannot be combined with --type agent.", [
+                "An agent resource is scaffolded by an agent runtime; use --runtime <id> instead",
+            ]);
+        }
+        if (language?.createFiles) {
+            throw new TdkError(`--language ${language.id} cannot be combined with --type agent.`, [
+                "An agent resource is a Bun service; drop --language",
+            ]);
+        }
+        return resolveAgentRuntime();
+    }
+    if (resourceType !== "backend" || frameworkId === undefined)
+        return undefined;
+    if (language?.createFiles) {
+        throw new TdkError(`--framework cannot be combined with --language ${language.id}.`, [
+            `The ${language.id} provider owns its runtime and framework`,
+            "Drop --framework, or use --language bun",
+        ]);
+    }
+    return getBackendFramework(frameworkId);
+}

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

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

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

@@ -0,0 +1,76 @@
+export function getBackendIndexTemplate(name) {
+    return renderBackendIndex(name, false);
+}
+/** The Bun + Hono backend with a `/health/db` route that runs a query through the Drizzle client. */
+export function getDrizzleBackendIndexTemplate(name) {
+    return renderBackendIndex(name, true);
+}
+function renderBackendIndex(name, drizzle) {
+    const drizzleImports = drizzle
+        ? "import { sql } from 'drizzle-orm';\nimport { db } from './db.js';\n"
+        : "";
+    const drizzleRoute = drizzle
+        ? `// Database check: runs a trivial query through the Drizzle client (src/db.ts).
+app.get('/health/db', async (c) => {
+  try {
+    await db.execute(sql\`select 1\`);
+    return c.json({ status: 'ok', database: 'up' });
+  } catch (error) {
+    console.error('Database health check failed:', error);
+    return c.json({ status: 'error', database: 'down' }, 503);
+  }
+});
+
+`
+        : "";
+    return `import { Hono } from 'hono';
+${drizzleImports}
+const app = new Hono();
+
+// Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
+app.get('/health', (c) => {
+  return c.json({ status: 'ok', service: '${name}' });
+});
+
+app.get('/health/live', (c) => {
+  return c.json({ status: 'alive', timestamp: Date.now() });
+});
+
+app.get('/health/ready', async (c) => {
+  const dependencies: Record<string, string> = {};
+  let allReady = true;
+
+  // Add dependency checks here (database, cache, etc.)
+  // Mark allReady = false if any dependency is unhealthy
+
+  const status = allReady ? 'ready' : 'not_ready';
+  return c.json({ status, dependencies }, allReady ? 200 : 503);
+});
+
+${drizzleRoute}app.get('/', (c) => {
+  return c.json({
+    service: '${name}',
+    version: '1.0.0',
+    endpoints: ['/health', '/health/live', '/health/ready'${drizzle ? ", '/health/db'" : ""}]
+  });
+});
+
+const port = process.env.PORT || 3000;
+console.log('\\n🚀 ${name} running on http://localhost:' + port);
+console.log('📊 Health check: http://localhost:' + port + '/health\\n');
+
+export default {
+  port,
+  fetch: app.fetch,
+};
+`;
+}
+/**
+ * The historical default. Package scripts, tsconfig, Dockerfile, and the vitest smoke test stay in
+ * the shared scaffold so omitted-language output is byte-identical to before providers existed.
+ */
+export const bunBackendProvider = {
+    id: "bun",
+    label: "Bun + Hono",
+    installHint: "bun install",
+};

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

@@ -0,0 +1,125 @@
+/**
+ * Go has no reload process inside the image, 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 GO_DEV_COMMAND = "go run .";
+export const goBackendProvider = {
+    id: "go",
+    label: "Go 1.23 (net/http)",
+    devCommand: GO_DEV_COMMAND,
+    watch: ["**/*.go", "go.mod", "go.sum"],
+    installHint: "go mod tidy   # optional: Docker builds the image for you",
+    createFiles(name) {
+        return [
+            {
+                filename: "go.mod",
+                content: `module ${name}
+
+go 1.23
+`,
+                description: "Generating go.mod",
+                emoji: "📦",
+            },
+            {
+                filename: "main.go",
+                content: `package main
+
+import (
+	"encoding/json"
+	"log"
+	"net/http"
+	"os"
+)
+
+func writeJSON(w http.ResponseWriter, status int, body any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(body)
+}
+
+func newMux() *http.ServeMux {
+	mux := http.NewServeMux()
+
+	// Health check endpoint (required by TILT_RESOURCE_DEFAULTS.star)
+	mux.HandleFunc("GET /health", func(w http.ResponseWriter, r *http.Request) {
+		writeJSON(w, http.StatusOK, map[string]string{"status": "ok", "service": "${name}"})
+	})
+
+	mux.HandleFunc("GET /{$}", func(w http.ResponseWriter, r *http.Request) {
+		writeJSON(w, http.StatusOK, map[string]any{
+			"service":   "${name}",
+			"version":   "1.0.0",
+			"endpoints": []string{"/health"},
+		})
+	})
+
+	return mux
+}
+
+func main() {
+	port := os.Getenv("PORT")
+	if port == "" {
+		port = "3000"
+	}
+
+	// ":" + port listens on every interface, which Traefik needs inside the container network.
+	log.Printf("${name} listening on :%s", port)
+	log.Fatal(http.ListenAndServe(":"+port, newMux()))
+}
+`,
+                description: "Generating backend source",
+                emoji: "💻",
+            },
+            {
+                filename: "main_test.go",
+                content: `package main
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestHealth(t *testing.T) {
+	rec := httptest.NewRecorder()
+	newMux().ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/health", nil))
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("GET /health = %d, want %d", rec.Code, http.StatusOK)
+	}
+}
+
+func TestRoot(t *testing.T) {
+	rec := httptest.NewRecorder()
+	newMux().ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/", nil))
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("GET / = %d, want %d", rec.Code, http.StatusOK)
+	}
+	if got := rec.Header().Get("Content-Type"); got != "application/json" {
+		t.Fatalf("GET / Content-Type = %q, want %q", got, "application/json")
+	}
+
+	var body map[string]any
+	if err := json.NewDecoder(rec.Body).Decode(&body); err != nil {
+		t.Fatalf("GET / body is not JSON: %v", err)
+	}
+	if body["service"] != "${name}" {
+		t.Errorf("service = %v, want %q", body["service"], "${name}")
+	}
+	if body["version"] != "1.0.0" {
+		t.Errorf("version = %v, want %q", body["version"], "1.0.0")
+	}
+	endpoints, ok := body["endpoints"].([]any)
+	if !ok || len(endpoints) != 1 || endpoints[0] != "/health" {
+		t.Errorf("endpoints = %v, want [/health]", body["endpoints"])
+	}
+}
+`,
+                description: "Generating smoke test",
+                emoji: "🧪",
+            },
+        ];
+    },
+};