flarecms 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,403 @@
+#!/usr/bin/env bun
+// @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 });
+}
+
+// src/cli/index.ts
+async function main() {
+  const args = process.argv.slice(2);
+  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/dist/cli/mcp.js

@@ -0,0 +1,209 @@
+// @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" }
+        }) + `
+`);
+      }
+    }
+  }
+}
+export {
+  runMcpBridge
+};