flarecms 0.1.0

package/README.md

@@ -0,0 +1,73 @@
+# FlareCMS: The Lean, Edge-Native CMS for the AI Era
+
+FlareCMS is a high-performance, minimalist, and developer-centric Content Management System built for the modern web. Engineered for speed and stability, it leverages the power of Bun, Hono, and Cloudflare D1 to deliver an unparalleled editing experience directly at the edge.
+
+## 🚀 Vision: Design-First & AI-Ready
+
+Unlike traditional bloated CMS architectures, FlareCMS follows two core principles:
+
+1.  **Zen Minimalism**: A purely "Flat Design" interface. No shadows, no entry animations, and no unnecessary transitions. We value instant response times and visual clarity over decorative UI elements.
+2.  **AI-Native Infrastructure**: Built to be managed by human developers and AI agents alike. Every interface is designed to be lean and high-contrast, facilitating seamless navigation for both eyes and algorithms.
+
+## 🛠️ Technology Stack
+
+- **Runtime**: [Bun](https://bun.sh/)
+- **Server Framework**: [Hono](https://hono.dev/)
+- **Database**: [Cloudflare D1](https://developers.cloudflare.com/d1/) (Edge SQL)
+- **Frontend**: React + Vite + Tailwind CSS v4
+- **State Management**: [Nanostores](https://github.com/nanostores/nanostores)
+
+## 📦 Getting Started
+
+### Initialize a New Project
+
+The easiest way to start a new FlareCMS project is by using our interactive CLI:
+
+```bash
+bunx flarecms create
+```
+
+This will guide you through:
+- Choosing a project name
+- Selecting a template (e.g., Unified Starter)
+- Installing dependencies automatically
+
+### Development (Monorepo)
+
+### Prerequisites
+
+- [Bun](https://bun.sh/) installed on your machine.
+- Cloudflare Wrangler CLI (for D1 interactions).
+
+### Installation
+
+```bash
+bun install
+```
+
+### Development
+
+To start the admin dashboard and the API concurrently:
+
+```bash
+bun run dev
+```
+
+## 🗺️ Technical Feature Roadmap
+
+Inspired by modern CMS best practices and enterprise-grade research, FlareCMS is evolving to support:
+
+- **[x] WebAuthn / Passkeys**: Biometric authentication implemented as a stable, passwordless login method.
+- **[x] Automated Deployment Pipeline**: Integrated custom build & deploy orchestration for Cloudflare Workers.
+- **[x] Self-Healing Database**: Automatic runtime migrations and table initialization.
+- **[x] Production Routing**: Native SPA fallback handling for seamless page refreshes at the edge.
+- **[ ] MCP Server Integration**: Full support for the Model Context Protocol to allow AI Agents (Claude, ChatGPT) to manage content, schemas, and mediaLibrary programmatically.
+- **[ ] Portable Text Protocol**: Transitioning from HTML-based storage to structured JSON (Portable Text) for presentation-agnostic content delivery.
+- **[ ] Agentic Developer Skills**: Native skills and instructions to turn FlareCMS into an "autonomous" CMS that can build its own plugins via AI.
+- **[ ] Edge Worker Sandboxing**: A plugin system based on isolated Cloudflare Workers for secure, third-party extensibility.
+
+---
+
+## License
+
+MIT © fhorray

package/dist/auth/index.js

@@ -0,0 +1,40 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/auth/index.ts
+import { encodeHexLowerCase } from "@oslojs/encoding";
+function generateSessionToken() {
+  const bytes = new Uint8Array(20);
+  crypto.getRandomValues(bytes);
+  return encodeHexLowerCase(bytes);
+}
+async function hashPassword(password) {
+  const encoder = new TextEncoder;
+  const data = encoder.encode(password);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function verifyPassword(password, hash) {
+  const newHash = await hashPassword(password);
+  return newHash === hash;
+}
+export {
+  verifyPassword,
+  hashPassword,
+  generateSessionToken
+};

package/dist/cli/commands.js

@@ -0,0 +1,389 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/cli/mcp.ts
+var 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"]
+    }
+  }
+];
+async function runMcpBridge(options) {
+  const { url, token } = options;
+  const executeUrl = `${url.replace(/\/$/, "")}/api/mcp/execute`;
+  async function callFlareCMS(tool, args) {
+    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) {
+    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) {
+          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(`
+`);
+    buffer = lines.pop() || "";
+    for (const line of lines) {
+      if (!line.trim())
+        continue;
+      try {
+        const request = JSON.parse(line);
+        const result = 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
+        }) + `
+`);
+      } catch (e) {
+        process.stdout.write(JSON.stringify({
+          jsonrpc: "2.0",
+          error: { code: -32700, message: "Parse error" }
+        }) + `
+`);
+      }
+    }
+  }
+}
+
+// src/cli/commands.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import { downloadTemplate } from "giget";
+import { existsSync, readFileSync, writeFileSync, cpSync, mkdirSync } from "fs";
+import { resolve } from "path";
+import { fileURLToPath } from "url";
+var execAsync = promisify(exec);
+var PROJECT_NAME_PATTERN = /^[a-z0-9-]+$/;
+var 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"
+  }
+};
+async function createProjectCommand() {
+  console.clear();
+  console.log(`
+  ${pc.bold(pc.yellow("\u2014 F L A R E C M S \u2014"))}
+`);
+  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;
+    }
+  });
+  if (p.isCancel(projectName)) {
+    p.cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  const projectDir = resolve(process.cwd(), projectName);
+  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);
+    }
+  }
+  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...");
+      const nextVersion = "15.1.0";
+      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) {
+        p.log.warn("create-next-app failed or was already present. Continuing with injection...");
+      }
+      s.start("Injecting FlareCMS configuration...");
+    }
+    const template = TEMPLATES[templateKey];
+    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") {
+      const remoteSource = `github:fhorray/flarecms/${template.dir}`;
+      await downloadTemplate(remoteSource, {
+        dir: projectDir,
+        force: true
+      });
+    }
+    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";
+      pkg.dependencies = pkg.dependencies || {};
+      pkg.dependencies["flarecms"] = "latest";
+      pkg.dependencies["hono"] = "latest";
+      writeFileSync(pkgPath, JSON.stringify(pkg, null, 2));
+    }
+    const wranglerPath = resolve(projectDir, "wrangler.jsonc");
+    if (existsSync(wranglerPath)) {
+      let wranglerContent = readFileSync(wranglerPath, "utf-8");
+      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(`
+`), "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);
+  }
+}
+async function mcpCommand(args) {
+  let url = process.env.FLARE_API_URL || "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];
+      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 });
+}
+export {
+  mcpCommand,
+  createProjectCommand
+};