flarecms 0.1.0

package/src/cli/commands.ts

@@ -0,0 +1,217 @@
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { downloadTemplate } from "giget";
+import { existsSync, readFileSync, writeFileSync, cpSync, mkdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { runMcpBridge } from "./mcp.ts";
+
+import { fileURLToPath } from "node:url";
+
+const execAsync = promisify(exec);
+const PROJECT_NAME_PATTERN = /^[a-z0-9-]+$/;
+
+// Template definitions
+const TEMPLATES = {
+  starter: {
+    name: "Starter (Hono + React)",
+    description: "Unified single-process FlareCMS starter for Cloudflare Workers",
+    dir: "templates/starter",
+  },
+  blog: {
+    name: "Blog (Coming Soon)",
+    description: "A pre-configured blog template",
+    dir: "templates/blog",
+  },
+  nextjs: {
+    name: "Next.js (App Router)",
+    description: "Modern Next.js template with FlareCMS + Hono API",
+    dir: "templates/nextjs",
+  },
+} as const;
+
+export async function createProjectCommand() {
+  console.clear();
+  console.log(`\n  ${pc.bold(pc.yellow("— F L A R E C M S —"))}\n`);
+  p.intro("Create a new FlareCMS project");
+
+  const projectName = await p.text({
+    message: "Project name?",
+    placeholder: "my-flare-site",
+    defaultValue: "my-flare-site",
+    validate: (value) => {
+      if (!value) return "Project name is required";
+      if (!PROJECT_NAME_PATTERN.test(value))
+        return "Project name can only contain lowercase letters, numbers, and hyphens";
+      return undefined;
+    },
+  });
+
+  if (p.isCancel(projectName)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+
+  const projectDir = resolve(process.cwd(), projectName as string);
+
+  if (existsSync(projectDir)) {
+    const overwrite = await p.confirm({
+      message: `Directory ${projectName} already exists. Overwrite?`,
+      initialValue: false,
+    });
+
+    if (p.isCancel(overwrite) || !overwrite) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+  }
+
+  // Step 2: Template Selection
+  const templateKey = await p.select({
+    message: "Which template would you like to use?",
+    options: Object.entries(TEMPLATES).map(([key, t]) => ({
+      value: key,
+      label: t.name,
+      hint: t.description,
+    })),
+    initialValue: "starter",
+  });
+
+  if (p.isCancel(templateKey)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+
+  const shouldInstall = await p.confirm({
+    message: "Install dependencies with bun?",
+    initialValue: true,
+  });
+
+  if (p.isCancel(shouldInstall)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+
+  const s = p.spinner();
+  s.start("Creating project...");
+
+  try {
+    if (templateKey === 'nextjs') {
+      s.stop("Starting Next.js setup...");
+      
+      // 1. Run create-next-app
+      const nextVersion = "15.1.0"; // Stable default, can be customized
+      p.log.info(`${pc.cyan("Running:")} bun create next-app@${nextVersion} ${projectName} --typescript --tailwind --eslint --app --src-dir false --import-alias "@/*" --use-bun`);
+      
+      try {
+        await execAsync(`bun create next-app@${nextVersion} ${projectName} --typescript --tailwind --eslint --app --src-dir false --import-alias "@/*" --use-bun --yes`, {
+            env: { ...process.env, NEXT_TELEMETRY_DISABLED: "1" }
+        });
+      } catch (err) {
+        // Fallback or handle error
+        p.log.warn("create-next-app failed or was already present. Continuing with injection...");
+      }
+
+      s.start("Injecting FlareCMS configuration...");
+    }
+
+    const template = TEMPLATES[templateKey as keyof typeof TEMPLATES];
+    const currentFilePath = fileURLToPath(import.meta.url);
+    const cliDir = resolve(currentFilePath, "..");
+    const localTemplatesRoot = resolve(cliDir, "..", "..", "..", "..", "templates");
+    const localTemplatePath = resolve(localTemplatesRoot, template.dir.split('/').pop() || '');
+
+    if (existsSync(localTemplatePath)) {
+      if (!existsSync(projectDir)) {
+        mkdirSync(projectDir, { recursive: true });
+      }
+      cpSync(localTemplatePath, projectDir, { recursive: true });
+    } else if (templateKey !== 'nextjs') {
+      // Production flow: download from GitHub
+      const remoteSource = `github:fhorray/flarecms/${template.dir}`;
+      await downloadTemplate(remoteSource, {
+        dir: projectDir,
+        force: true,
+      });
+    }
+
+    // 1. Update package.json
+    const pkgPath = resolve(projectDir, "package.json");
+    if (existsSync(pkgPath)) {
+      const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+      pkg.name = projectName;
+      pkg.version = "0.1.0";
+      // Ensure flarecms dependency is present
+      pkg.dependencies = pkg.dependencies || {};
+      pkg.dependencies["flarecms"] = "latest";
+      pkg.dependencies["hono"] = "latest";
+
+      writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+    }
+
+    // 2. Setup Wrangler logic
+    const wranglerPath = resolve(projectDir, "wrangler.jsonc");
+    if (existsSync(wranglerPath)) {
+      let wranglerContent = readFileSync(wranglerPath, "utf-8");
+      // Basic JSON string replacement for simplicity in CLI
+      wranglerContent = wranglerContent.replace(/"name":\s*".*"/, `"name": "${projectName}"`);
+      wranglerContent = wranglerContent.replace(/"database_name":\s*".*"/, `"database_name": "${projectName}-db"`);
+      writeFileSync(wranglerPath, wranglerContent);
+    }
+
+    s.stop("Project created!");
+
+    if (shouldInstall) {
+      s.start(`Installing dependencies with ${pc.cyan("bun")}...`);
+      try {
+        await execAsync("bun install", { cwd: projectDir });
+        s.stop("Dependencies installed!");
+
+        s.start("Generating TypeScript bindings...");
+        try {
+          await execAsync("bun wrangler types", { cwd: projectDir });
+          s.stop("TypeScript bindings generated!");
+        } catch (err) {
+          s.stop("Failed to generate bindings (this is normal if wrangler.jsonc is incomplete)");
+        }
+      } catch (err) {
+        s.stop("Failed to install dependencies");
+        p.log.warn(`Run ${pc.cyan(`cd ${projectName} && bun install && bun cf-typegen`)} manually`);
+      }
+    }
+
+    const steps = [`cd ${projectName}`, "bun run dev"];
+    p.note(steps.join("\n"), "Next steps");
+
+    p.outro(`${pc.green("Done!")} Your FlareCMS project is ready at ${pc.cyan(projectName)}`);
+
+  } catch (error) {
+    s.stop("Failed to create project");
+    p.log.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
+export async function mcpCommand(args: string[]) {
+  // Simple argument parsing for CLI
+  let url: string = (process.env.FLARE_API_URL as string) || "http://localhost:8787";
+  let token = process.env.FLARE_API_TOKEN;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--url" && i + 1 < args.length) {
+      url = args[i + 1] as string;
+      i++;
+    } else if (args[i] === "--token" && i + 1 < args.length) {
+      token = args[i + 1];
+      i++;
+    }
+  }
+
+  if (!url) {
+    console.error(pc.red("Error: --url is required or must be set via FLARE_API_URL"));
+    process.exit(1);
+  }
+
+  await runMcpBridge({ url, token });
+}

package/src/cli/index.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env bun
+import { createProjectCommand, mcpCommand } from "./commands.ts";
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  // Simplistic command router
+  if (args[0] === "mcp") {
+    await mcpCommand(args.slice(1));
+  } else if (args.length === 0 || args[0] === "create") {
+    await createProjectCommand();
+  } else {
+    console.log("Unknown command. Available commands: create, mcp");
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/src/cli/mcp.ts

@@ -0,0 +1,210 @@
+/**
+ * FlareCMS MCP Bridge Server (CLI Implementation)
+ * Implements MCP (Model Context Protocol) over stdio
+ */
+
+export interface McpOptions {
+  url: string;
+  token?: string;
+}
+
+const TOOLS = [
+  {
+    name: "list_collections",
+    description: "Fetches all defined content schema collections available in FlareCMS.",
+    inputSchema: { type: "object", properties: {} }
+  },
+  {
+    name: "get_collection_schema",
+    description: "Fetches the full field structure and metadata of a specific FlareCMS collection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        collection: { type: "string", description: "The slug of the collection to inspect" }
+      },
+      required: ["collection"]
+    }
+  },
+  {
+    name: "read_content",
+    description: "Reads the paginated content of a specific FlareCMS collection dynamically.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        collection: { type: "string", description: "The slug of the collection to read" },
+        limit: { type: "number", description: "Number of records to fetch (default 10)" }
+      },
+      required: ["collection"]
+    }
+  },
+  {
+    name: "create_document",
+    description: "Creates a new document in a specified collection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        collection: { type: "string", description: "The collection slug" },
+        data: { 
+          type: "object", 
+          description: "The document data (e.g. { title: 'Hello', status: 'published' })" 
+        }
+      },
+      required: ["collection", "data"]
+    }
+  },
+  {
+    name: "update_document",
+    description: "Updates an existing document in a specified collection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        collection: { type: "string", description: "The collection slug" },
+        id: { type: "string", description: "The document ID to update" },
+        data: { 
+          type: "object", 
+          description: "The data fields to update" 
+        }
+      },
+      required: ["collection", "id", "data"]
+    }
+  },
+  {
+    name: "create_collection",
+    description: "Creates a new content collection and its physical table.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        slug: { type: "string", description: "Unique URL slug for the collection" },
+        label: { type: "string", description: "Display label" },
+        labelSingular: { type: "string", description: "Singular display label" },
+        description: { type: "string", description: "Optional description" },
+        isPublic: { type: "boolean", description: "Whether it is publicly readable" }
+      },
+      required: ["slug", "label"]
+    }
+  },
+  {
+    name: "update_collection",
+    description: "Updates collection metadata.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        id: { type: "string", description: "The collection ID (ULID)" },
+        data: { type: "object", description: "Metadata fields to update" }
+      },
+      required: ["id", "data"]
+    }
+  },
+  {
+    name: "add_field",
+    description: "Adds a new field to an existing collection.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        collection_id: { type: "string", description: "The collection ID (ULID)" },
+        field: {
+          type: "object",
+          properties: {
+            slug: { type: "string" },
+            label: { type: "string" },
+            type: { type: "string", enum: ["text", "number", "boolean", "date", "richtext"] },
+            required: { type: "boolean" }
+          },
+          required: ["slug", "label", "type"]
+        }
+      },
+      required: ["collection_id", "field"]
+    }
+  }
+];
+
+export async function runMcpBridge(options: McpOptions) {
+  const { url, token } = options;
+  const executeUrl = `${url.replace(/\/$/, '')}/api/mcp/execute`;
+
+  async function callFlareCMS(tool: string, args: any) {
+    if (!token) {
+      throw new Error("No API Token provided. Use --token or FLARE_API_TOKEN environment variable.");
+    }
+
+    const response = await fetch(executeUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify({ tool, arguments: args }),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`FlareCMS API Error (${response.status}): ${errorText}`);
+    }
+
+    return await response.json();
+  }
+
+  async function handleRequest(request: any) {
+    const { method, params } = request;
+
+    switch (method) {
+      case "initialize":
+        return {
+          protocolVersion: "2024-11-05",
+          capabilities: { tools: {} },
+          serverInfo: { name: "@flarecms/cli", version: "0.1.0" }
+        };
+
+      case "notifications/initialized":
+        return null;
+
+      case "tools/list":
+        return { tools: TOOLS };
+
+      case "tools/call":
+        try {
+          return await callFlareCMS(params.name, params.arguments);
+        } catch (error: any) {
+          return {
+            content: [{ type: "text", text: `Error executing tool '${params.name}': ${error.message}` }],
+            isError: true
+          };
+        }
+
+      default:
+        return { error: { code: -32601, message: `Method not found: ${method}` } };
+    }
+  }
+
+  const decoder = new TextDecoder();
+  let buffer = "";
+
+  for await (const chunk of Bun.stdin.stream()) {
+    buffer += decoder.decode(chunk);
+    let lines = buffer.split("\n");
+    buffer = lines.pop() || "";
+
+    for (const line of lines) {
+      if (!line.trim()) continue;
+
+      try {
+        const request = JSON.parse(line);
+        const result: any = await handleRequest(request);
+
+        if (result === null) continue;
+
+        process.stdout.write(JSON.stringify({
+          jsonrpc: "2.0",
+          id: request.id,
+          result: result.error ? undefined : result,
+          error: result.error
+        }) + "\n");
+      } catch (e: any) {
+        process.stdout.write(JSON.stringify({
+          jsonrpc: "2.0",
+          error: { code: -32700, message: "Parse error" }
+        }) + "\n");
+      }
+    }
+  }
+}

package/src/cli/tests/cli.test.ts

@@ -0,0 +1,40 @@
+import { expect, test, describe, beforeAll, afterAll } from "bun:test";
+import { resolve } from "node:path";
+import { rmSync, existsSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+
+function runCLI(args: string[], cwd: string = process.cwd()) {
+  const cliPath = resolve(__dirname, "../src/index.ts");
+  return spawnSync("bun", [cliPath, ...args], { cwd, encoding: "utf-8" });
+}
+
+describe("FlareCMS CLI Scaffolder", () => {
+  const TEST_DIR = resolve(__dirname, "../../.test_output");
+
+  beforeAll(() => {
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+    spawnSync("mkdir", ["-p", TEST_DIR]);
+  });
+
+  afterAll(() => {
+    if (existsSync(TEST_DIR)) {
+      rmSync(TEST_DIR, { recursive: true, force: true });
+    }
+  });
+
+  test("CLI prints unknown command message for invalid command", () => {
+    const result = runCLI(["invalid-command"]);
+    expect(result.status).not.toBe(0); // Should exit with error code 1
+    expect(result.stdout + result.stderr).toContain("Unknown command. Available commands: create");
+  });
+
+  test("CLI renders prompts successfully for create command", () => {
+    const result = runCLI(["create"]);
+    // Since we are mocking execution without a real interactive shell or pipe, it prints the prompt and waits or crashes on EOF.
+    // The test environment doesn't allow interaction so clack will just render the first prompt.
+    expect(result.stdout + result.stderr).toContain("Create a new FlareCMS project");
+    expect(result.stdout + result.stderr).toContain("Project name?");
+  });
+});

package/src/cli/tests/create.test.ts

@@ -0,0 +1,87 @@
+import { describe, it, expect, mock, beforeAll, afterAll } from 'bun:test';
+import { existsSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { createProjectCommand } from '../commands.ts';
+
+// 1. Mock @clack/prompts
+mock.module('@clack/prompts', () => ({
+  intro: () => { },
+  outro: () => { },
+  text: async () => 'test-project',
+  select: async () => 'starter',
+  confirm: async () => true,
+  spinner: () => ({
+    start: () => { },
+    stop: () => { }
+  }),
+  note: () => { },
+  cancel: () => { },
+  isCancel: (val: any) => val === null,
+  log: {
+    info: () => { },
+    warn: () => { },
+    error: () => { },
+  }
+}));
+
+// 2. Mock giget
+mock.module('giget', () => ({
+  downloadTemplate: async (src: string, opts: any) => {
+    // Create the destination folder and a dummy package.json to simulate download
+    if (!existsSync(opts.dir)) {
+      mkdirSync(opts.dir, { recursive: true });
+    }
+    const pkg = { name: 'template', dependencies: {} };
+    const wrangler = { name: 'template', d1_databases: [{ database_name: 'template-db' }] };
+
+    const { writeFileSync } = require('node:fs');
+    const { resolve } = require('node:path');
+
+    writeFileSync(resolve(opts.dir, 'package.json'), JSON.stringify(pkg, null, 2));
+    writeFileSync(resolve(opts.dir, 'wrangler.jsonc'), JSON.stringify(wrangler, null, 2));
+    return { dir: opts.dir };
+  }
+}));
+
+// 3. Mock child_process exec
+mock.module('node:child_process', () => ({
+  exec: (cmd: string, opts: any, cb: any) => {
+    cb(null, { stdout: '', stderr: '' });
+  }
+}));
+
+describe('CLI: createProjectCommand', () => {
+  const testDir = resolve(process.cwd(), 'test-project');
+
+  afterAll(() => {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  });
+
+  it('should create a project and patch manifests correctly', async () => {
+    // Mock process.exit to prevent test from exiting
+    const exitSpy = mock(() => { });
+    const originalExit = process.exit;
+    // @ts-ignore
+    process.exit = exitSpy;
+
+    await createProjectCommand();
+
+    // Verify directory exists
+    expect(existsSync(testDir)).toBe(true);
+
+    // Verify package.json was patched
+    const pkg = JSON.parse(readFileSync(resolve(testDir, 'package.json'), 'utf-8'));
+    expect(pkg.name).toBe('test-project');
+    expect(pkg.dependencies.flarecms).toBe('latest');
+
+    // Verify wrangler.jsonc was patched
+    const wrangler = JSON.parse(readFileSync(resolve(testDir, 'wrangler.jsonc'), 'utf-8'));
+    expect(wrangler.name).toBe('test-project');
+    expect(wrangler.d1_databases[0].database_name).toBe('test-project-db');
+
+    // Restore process.exit
+    process.exit = originalExit;
+  });
+});

package/src/client/FlareAdminRouter.tsx

@@ -0,0 +1,47 @@
+import React, { useEffect } from 'react';
+import App from './app';
+import { setBase, setApiBaseUrl } from './store/config';
+import { initRouter } from './store/router';
+import { TooltipProvider } from './components/ui/tooltip';
+
+export interface FlareAdminProps {
+  /**
+   * The base path where the admin UI is mounted.
+   * @default "/admin"
+   */
+  basePath?: string;
+  
+  /**
+   * The base URL for FlareCMS API calls.
+   * @default "/api"
+   */
+  apiBaseUrl?: string;
+}
+
+/**
+ * FlareAdminRouter is the main entry point for the FlareCMS Admin UI.
+ * It manages the routing and state for the entire administrative dashboard.
+ * 
+ * @example
+ * <FlareAdminRouter basePath="/admin" apiBaseUrl="/api/flarecms" />
+ */
+export function FlareAdminRouter({ 
+  basePath = '/admin', 
+  apiBaseUrl = '/api' 
+}: FlareAdminProps) {
+  
+  // Initialize configuration stores and router
+  useEffect(() => {
+    setBase(basePath);
+    setApiBaseUrl(apiBaseUrl);
+    initRouter(basePath);
+  }, [basePath, apiBaseUrl]);
+
+  return (
+    <div className="flare-admin">
+      <TooltipProvider>
+        <App />
+      </TooltipProvider>
+    </div>
+  );
+}