@blinkk/root-cms 3.0.1-alpha.1 → 3.0.1-beta.2

package/dist/chunk-ATPWU3CU.js

@@ -0,0 +1,921 @@
+// core/ai.ts
+import crypto from "crypto";
+import { promises as fs } from "fs";
+import path from "path";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import {
+  convertToModelMessages,
+  generateImage as generateImageSdk,
+  generateText,
+  stepCountIs,
+  streamText
+} from "ai";
+import { Timestamp } from "firebase-admin/firestore";
+
+// core/ai-tools.ts
+import { tool } from "ai";
+import { z } from "zod";
+var READ_ONLY_CMS_TOOL_NAMES = [
+  "collections_list",
+  "docs_list",
+  "docs_search",
+  "doc_get",
+  "doc_getVersion",
+  "doc_listVersions",
+  "schema_get"
+];
+function createReadOnlyCmsTools() {
+  const all = createCmsTools();
+  const out = {};
+  for (const name of READ_ONLY_CMS_TOOL_NAMES) {
+    if (all[name]) {
+      out[name] = all[name];
+    }
+  }
+  return out;
+}
+function createCmsTools() {
+  return {
+    collections_list: tool({
+      description: "List all CMS collections defined in the project. Returns each collection id along with optional name/description metadata.",
+      inputSchema: z.object({})
+    }),
+    docs_list: tool({
+      description: "List documents inside a CMS collection. Returns up to `limit` docs (default 25, max 100). Use this to explore content before reading individual docs.",
+      inputSchema: z.object({
+        collectionId: z.string().describe('Collection id, e.g. "Pages" or "BlogPosts".'),
+        mode: z.enum(["draft", "published"]).default("draft").describe("Whether to read draft or published versions."),
+        limit: z.number().int().min(1).max(100).default(25)
+      })
+    }),
+    docs_search: tool({
+      description: "Run a full-text search across all indexed CMS docs. Returns the top matching doc ids ordered by relevance.",
+      inputSchema: z.object({
+        query: z.string().min(1),
+        limit: z.number().int().min(1).max(50).default(10)
+      })
+    }),
+    doc_get: tool({
+      description: "Read a single CMS document. Returns the doc fields plus system metadata. Use this when you need the full content of a doc.",
+      inputSchema: z.object({
+        docId: z.string().describe(
+          'Full doc id in the form "Collection/slug" (e.g. "Pages/home").'
+        ),
+        mode: z.enum(["draft", "published"]).default("draft")
+      })
+    }),
+    doc_getVersion: tool({
+      description: 'Read a specific version of a CMS document. Use versionId "draft" or "published" for the current draft/published state, or a numeric timestamp for a historical version (from `doc_listVersions`).',
+      inputSchema: z.object({
+        docId: z.string().describe(
+          'Full doc id in the form "Collection/slug" (e.g. "Pages/home").'
+        ),
+        versionId: z.string().describe(
+          'Version identifier: "draft", "published", or a numeric timestamp.'
+        )
+      })
+    }),
+    doc_set: tool({
+      description: "Replace the entire draft fields payload of a CMS document. Pass the full JSON object that should become the new draft contents \u2014 any fields omitted will be removed. The payload is validated against the collection schema and the call is rejected on validation errors. Prefer `doc_updateField` for targeted edits. Only writes the draft version; users must publish separately. Always confirm with the user before calling.",
+      inputSchema: z.object({
+        docId: z.string().describe(
+          'Full doc id in the form "Collection/slug" (e.g. "Pages/home").'
+        ),
+        fields: z.record(z.string(), z.any()).describe(
+          "New fields object. Replaces the existing draft fields entirely."
+        )
+      })
+    }),
+    doc_create: tool({
+      description: "Create a new draft CMS document with the given slug. Fails if the doc already exists. Pass optional initial fields (validated against the collection schema). Always confirm with the user before calling.",
+      inputSchema: z.object({
+        docId: z.string().describe(
+          'Full doc id in the form "Collection/slug" (e.g. "BlogPosts/my-new-post").'
+        ),
+        fields: z.record(z.string(), z.any()).optional().describe("Optional initial fields for the new doc.")
+      })
+    }),
+    doc_updateField: tool({
+      description: 'Update a single field on a draft CMS document by JSON path. Use dotted paths (e.g. "hero.title") and array indices (e.g. "sections.0.heading"). The value is validated against the field schema and the call is rejected if the shape is wrong (e.g. passing a string to a richtext field). Only updates the draft version; users must publish separately. Always confirm with the user before calling.',
+      inputSchema: z.object({
+        docId: z.string(),
+        path: z.string().describe("Dotted JSON path within the fields object."),
+        value: z.any().describe("JSON value to set at the path.")
+      })
+    }),
+    // `doc_publish` and `doc_delete` are intentionally omitted — see the
+    // safety policy comment on `createCmsTools`. Users must run these from
+    // the CMS UI themselves.
+    doc_duplicate: tool({
+      description: "Duplicate an existing CMS document to a new slug. Copies all draft fields to the target doc id. Fails if the target already exists. Always confirm with the user before calling.",
+      inputSchema: z.object({
+        fromDocId: z.string().describe('Source doc id to copy from (e.g. "Pages/home").'),
+        toDocId: z.string().describe('Target doc id for the copy (e.g. "Pages/home-copy").')
+      })
+    }),
+    // `doc_revertDraft` is intentionally omitted — see the safety policy
+    // comment on `createCmsTools`. Discarding draft edits is destructive
+    // and must be triggered by the user from the CMS UI.
+    doc_listVersions: tool({
+      description: "List version history for a CMS document. Returns versions ordered by most recent first. Use the versionId from the results with `doc_getVersion` to read a specific version.",
+      inputSchema: z.object({
+        docId: z.string().describe(
+          'Full doc id in the form "Collection/slug" (e.g. "Pages/home").'
+        ),
+        limit: z.number().int().min(1).max(50).default(10)
+      })
+    }),
+    doc_translateField: tool({
+      description: "Translate a text value into one or more target locales using AI. Returns the translated strings keyed by locale. Use this to help with localization workflows.",
+      inputSchema: z.object({
+        sourceText: z.string().min(1).describe("The source text to translate."),
+        targetLocales: z.array(z.string()).min(1).describe(
+          'Array of locale codes to translate into (e.g. ["es", "fr", "de"]).'
+        ),
+        description: z.string().optional().describe(
+          "Optional context about the text to improve translation quality."
+        )
+      })
+    }),
+    schema_get: tool({
+      description: "Get the field schema for a CMS collection. Returns the full field definitions including types, labels, and validation rules. Use this to understand what fields a collection supports before creating or editing docs.",
+      inputSchema: z.object({
+        collectionId: z.string().describe('Collection id, e.g. "Pages" or "BlogPosts".')
+      })
+    })
+  };
+}
+
+// core/ai.ts
+var ROOT_MD_FILENAME = "ROOT.md";
+function resolveLanguageModel(model) {
+  const modelId = model.modelId || model.id;
+  switch (model.provider) {
+    case "openai": {
+      const provider = createOpenAI({
+        apiKey: model.apiKey,
+        baseURL: model.baseURL,
+        headers: model.headers
+      });
+      return provider(modelId);
+    }
+    case "openai-compatible": {
+      if (!model.baseURL) {
+        throw new Error(
+          `model "${model.id}" requires a baseURL for provider "openai-compatible"`
+        );
+      }
+      const provider = createOpenAICompatible({
+        name: model.id,
+        baseURL: model.baseURL,
+        apiKey: model.apiKey,
+        headers: model.headers
+      });
+      return provider(modelId);
+    }
+    case "anthropic": {
+      const provider = createAnthropic({
+        apiKey: model.apiKey,
+        baseURL: model.baseURL,
+        headers: model.headers
+      });
+      return provider(modelId);
+    }
+    case "google": {
+      const provider = createGoogleGenerativeAI({
+        apiKey: model.apiKey,
+        baseURL: model.baseURL,
+        headers: model.headers
+      });
+      return provider(modelId);
+    }
+    default: {
+      throw new Error(`unknown ai provider: ${model.provider}`);
+    }
+  }
+}
+function resolveImageModel(model) {
+  const modelId = model.modelId || model.id;
+  switch (model.provider) {
+    case "openai": {
+      const provider = createOpenAI({
+        apiKey: model.apiKey,
+        baseURL: model.baseURL,
+        headers: model.headers
+      });
+      return provider.image(modelId);
+    }
+    case "google": {
+      const provider = createGoogleGenerativeAI({
+        apiKey: model.apiKey,
+        baseURL: model.baseURL,
+        headers: model.headers
+      });
+      return provider.image(modelId);
+    }
+    default: {
+      throw new Error(
+        `provider "${model.provider}" does not support image generation`
+      );
+    }
+  }
+}
+function serializeAiConfig(config) {
+  return {
+    defaultModel: config.defaultModel || config.models[0]?.id,
+    models: config.models.map((m) => ({
+      id: m.id,
+      label: m.label || m.id,
+      description: m.description,
+      provider: m.provider,
+      capabilities: {
+        tools: m.capabilities?.tools !== false,
+        reasoning: m.capabilities?.reasoning ?? false,
+        attachments: m.capabilities?.attachments ?? false
+      }
+    })),
+    imageGenerationEnabled: !!config.imageModels?.length
+  };
+}
+function getAiConfig(rootConfig) {
+  const cmsPlugin = rootConfig.plugins?.find((p) => p.name === "root-cms");
+  const ai = cmsPlugin?.getConfig().ai;
+  if (!ai || !Array.isArray(ai.models) || ai.models.length === 0) {
+    return null;
+  }
+  return ai;
+}
+function findModel(config, modelId) {
+  if (modelId) {
+    const match = config.models.find((m) => m.id === modelId);
+    if (match) {
+      return match;
+    }
+  }
+  const defaultId = config.defaultModel || config.models[0]?.id;
+  return config.models.find((m) => m.id === defaultId) || null;
+}
+function findImageModel(config, modelId) {
+  const imageModels = config.imageModels || [];
+  if (imageModels.length === 0) {
+    return null;
+  }
+  if (modelId) {
+    const match = imageModels.find((m) => m.id === modelId);
+    if (match) {
+      return match;
+    }
+  }
+  const defaultId = config.defaultImageModel || imageModels[0]?.id;
+  return imageModels.find((m) => m.id === defaultId) || null;
+}
+function requireDefaultModel(rootConfig) {
+  const config = getAiConfig(rootConfig);
+  if (!config) {
+    throw new Error("AI is not configured. Set `ai` on the cmsPlugin config.");
+  }
+  const model = findModel(config);
+  if (!model) {
+    throw new Error("No AI chat model configured.");
+  }
+  return { config, model };
+}
+var ChatStore = class {
+  constructor(cmsClient, user) {
+    this.cmsClient = cmsClient;
+    this.user = user;
+  }
+  collection() {
+    return this.cmsClient.db.collection(
+      `Projects/${this.cmsClient.projectId}/AiChats`
+    );
+  }
+  async createChat(options) {
+    const id = options?.id || crypto.randomUUID();
+    const now = Timestamp.now();
+    const record = {
+      id,
+      createdBy: this.user,
+      createdAt: now,
+      modifiedAt: now,
+      modelId: options?.modelId,
+      messages: []
+    };
+    await this.collection().doc(id).set(record);
+    return record;
+  }
+  async getChat(id) {
+    const snap = await this.collection().doc(id).get();
+    if (!snap.exists) {
+      return null;
+    }
+    const data = snap.data();
+    if (data.createdBy !== this.user) {
+      return null;
+    }
+    return data;
+  }
+  async listChats(options) {
+    const limit = options?.limit ?? 50;
+    const res = await this.collection().where("createdBy", "==", this.user).get();
+    const records = res.docs.map((d) => d.data());
+    records.sort((a, b) => {
+      const aMs = a.modifiedAt?.toMillis?.() ?? 0;
+      const bMs = b.modifiedAt?.toMillis?.() ?? 0;
+      return bMs - aMs;
+    });
+    return records.slice(0, limit);
+  }
+  async deleteChat(id) {
+    const chat = await this.getChat(id);
+    if (!chat) {
+      return;
+    }
+    await this.collection().doc(id).delete();
+  }
+  async updateMessages(id, messages, options) {
+    const updates = {
+      messages,
+      modifiedAt: Timestamp.now()
+    };
+    if (options?.modelId) {
+      updates.modelId = options.modelId;
+    }
+    if (options?.title) {
+      updates.title = options.title;
+    }
+    await this.collection().doc(id).update(updates);
+  }
+};
+async function readRootMd(rootDir) {
+  const filePath = path.join(rootDir, ROOT_MD_FILENAME);
+  try {
+    const contents = await fs.readFile(filePath, "utf8");
+    const trimmed = contents.trim();
+    return trimmed || null;
+  } catch (err) {
+    if (err && err.code === "ENOENT") {
+      return null;
+    }
+    console.error(`failed to read ${ROOT_MD_FILENAME}:`, err);
+    return null;
+  }
+}
+function buildSystemPrompt(basePrompt, rootMd) {
+  if (!rootMd) {
+    return basePrompt;
+  }
+  return [
+    basePrompt,
+    "",
+    `The project includes a \`${ROOT_MD_FILENAME}\` file with site-specific`,
+    "instructions, conventions and context provided by the developer. Treat",
+    "these instructions as authoritative for this project and follow them",
+    "when responding or calling tools.",
+    "",
+    `<${ROOT_MD_FILENAME}>`,
+    rootMd,
+    `</${ROOT_MD_FILENAME}>`
+  ].join("\n");
+}
+function deriveChatTitle(messages) {
+  const first = messages.find((m) => m.role === "user");
+  if (!first) {
+    return "New chat";
+  }
+  const text = first.parts.filter((p) => p.type === "text").map((p) => p.text).join(" ").trim();
+  if (!text) {
+    return "New chat";
+  }
+  return text.length > 60 ? `${text.slice(0, 57)}\u2026` : text;
+}
+async function generateChatTitle(model, messages) {
+  const fallback = deriveChatTitle(messages);
+  if (fallback === "New chat") {
+    return fallback;
+  }
+  try {
+    const result = await generateText({
+      model,
+      system: "Generate a short title (max 50 characters) summarizing the following conversation. Return only the title text, no quotes or punctuation at the end.",
+      prompt: messages.slice(0, 6).map((m) => {
+        const text = m.parts.filter((p) => p.type === "text").map((p) => p.text).join(" ");
+        return `${m.role}: ${text}`;
+      }).join("\n"),
+      maxOutputTokens: 30
+    });
+    const title = result.text.trim().replace(/["']+$/g, "").replace(/^["']+/g, "");
+    if (title) {
+      return title.length > 80 ? `${title.slice(0, 77)}\u2026` : title;
+    }
+  } catch (err) {
+    console.error("failed to generate chat title:", err);
+  }
+  return fallback;
+}
+async function runChatStream(options) {
+  const { rootConfig, model, config, messages, cmsClient, user, chatId } = options;
+  const languageModel = resolveLanguageModel(model);
+  const tools = model.capabilities?.tools === false ? {} : createCmsTools();
+  const basePrompt = config.systemPrompt || [
+    "You are an assistant embedded in the Root CMS admin UI.",
+    "Help the user explore and edit content, answer questions about",
+    "the project, and use the provided tools to read and write CMS docs.",
+    "Be concise and use markdown for rich responses."
+  ].join(" ");
+  const rootMd = await readRootMd(rootConfig.rootDir);
+  const systemPrompt = buildSystemPrompt(basePrompt, rootMd);
+  const modelMessages = await convertToModelMessages(messages, { tools });
+  const result = streamText({
+    model: languageModel,
+    system: systemPrompt,
+    messages: modelMessages,
+    tools,
+    stopWhen: stepCountIs(config.maxSteps ?? 10)
+  });
+  return result.toUIMessageStreamResponse({
+    sendReasoning: model.capabilities?.reasoning ?? false,
+    originalMessages: messages,
+    onFinish: async ({ messages: finalMessages }) => {
+      const store = new ChatStore(cmsClient, user);
+      const title = await generateChatTitle(languageModel, finalMessages);
+      const updates = {
+        modelId: model.id,
+        title
+      };
+      try {
+        await store.updateMessages(
+          chatId,
+          stripUndefined(finalMessages),
+          updates
+        );
+      } catch (err) {
+        console.error("failed to persist chat history:", err);
+      }
+    }
+  });
+}
+async function runEditObjectStream(options) {
+  const { rootConfig, model, config, messages, editData } = options;
+  const languageModel = resolveLanguageModel(model);
+  const tools = model.capabilities?.tools === false ? {} : createReadOnlyCmsTools();
+  const editPromptText = (await import("./edit-XX3LAGK6.js")).default;
+  const promptParts = [
+    stripLegacyEditOutputSpec(editPromptText),
+    "",
+    "Output format:",
+    "- Begin with a brief 1-2 sentence message describing what you changed.",
+    "- Then emit a single fenced code block tagged ```json containing the",
+    "  COMPLETE proposed new JSON object (including any unmodified fields).",
+    "- The code block must be the LAST content in your response. The CMS UI",
+    "  parses it and shows the result in a diff viewer for the user to",
+    "  approve before saving.",
+    "",
+    "Tool policy:",
+    "- The available tools are READ-ONLY. Use them only when you need extra",
+    "  context (e.g. inspecting the schema or referencing other CMS docs).",
+    "- You MUST NOT attempt to call write tools (e.g. doc_set, doc_create,",
+    "  doc_updateField). The user approves and saves changes manually via",
+    "  the modal's Save button."
+  ];
+  try {
+    const rootCmsDefsPath = path.join(rootConfig.rootDir, "root-cms.d.ts");
+    const rootCmsDefs = await fs.readFile(rootCmsDefsPath, "utf8");
+    if (rootCmsDefs.trim()) {
+      promptParts.push(
+        "",
+        "Here is the `root-cms.d.ts` file for this project:",
+        "```",
+        rootCmsDefs,
+        "```"
+      );
+    }
+  } catch (err) {
+    if (err?.code !== "ENOENT") {
+      console.error("failed to read root-cms.d.ts:", err);
+    }
+  }
+  promptParts.push(
+    "",
+    "The JSON you must edit is:",
+    "```json",
+    JSON.stringify(editData ?? {}, null, 2),
+    "```"
+  );
+  const basePrompt = promptParts.join("\n");
+  const rootMd = await readRootMd(rootConfig.rootDir);
+  const systemPrompt = buildSystemPrompt(basePrompt, rootMd);
+  const modelMessages = await convertToModelMessages(messages, { tools });
+  const result = streamText({
+    model: languageModel,
+    system: systemPrompt,
+    messages: modelMessages,
+    tools,
+    stopWhen: stepCountIs(config.maxSteps ?? 10)
+  });
+  return result.toUIMessageStreamResponse({
+    sendReasoning: model.capabilities?.reasoning ?? false,
+    originalMessages: messages
+  });
+}
+function stripLegacyEditOutputSpec(prompt) {
+  const marker = "Finally, when you provide your response, it MUST be structured";
+  const idx = prompt.indexOf(marker);
+  if (idx === -1) {
+    return prompt;
+  }
+  return prompt.slice(0, idx).trimEnd();
+}
+function stripUndefined(value) {
+  if (Array.isArray(value)) {
+    return value.filter((v) => v !== void 0).map((v) => stripUndefined(v));
+  }
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (v === void 0) {
+        continue;
+      }
+      out[k] = stripUndefined(v);
+    }
+    return out;
+  }
+  return value;
+}
+async function summarizeDiff(rootConfig, options) {
+  const { model } = requireDefaultModel(rootConfig);
+  const languageModel = resolveLanguageModel(model);
+  const beforeJson = JSON.stringify(options.before ?? null, null, 2);
+  const afterJson = JSON.stringify(options.after ?? null, null, 2);
+  const system = [
+    "Summarize CMS document changes in 2-4 bullet points.",
+    "Focus on content changes only. Ignore metadata like timestamps.",
+    'If no meaningful changes, say "No significant changes."'
+  ].join("\n");
+  const prompt = [
+    "Before:",
+    beforeJson,
+    "",
+    "After:",
+    afterJson,
+    "",
+    "What changed?"
+  ].join("\n");
+  const result = await generateText({
+    model: languageModel,
+    system,
+    prompt,
+    // Respond more quickly with less creativity.
+    temperature: 0.3
+  });
+  return result.text?.trim() || "";
+}
+async function generatePublishMessage(rootConfig, options) {
+  const { model } = requireDefaultModel(rootConfig);
+  const languageModel = resolveLanguageModel(model);
+  const beforeJson = JSON.stringify(options.before ?? null, null, 2);
+  const afterJson = JSON.stringify(options.after ?? null, null, 2);
+  const system = [
+    "You are an assistant that generates concise commit-style messages for CMS document changes.",
+    "Generate a single short sentence (maximum 60 characters) describing the most important change.",
+    'Use imperative mood like "Add feature" or "Update content" or "Fix typo".',
+    "Focus on the key content change, ignore structural metadata changes.",
+    "Do not use punctuation at the end.",
+    'Examples: "Add new hero image", "Update pricing details", "Fix typo in headline"'
+  ].join("\n");
+  const prompt = [
+    "Previous version JSON:",
+    "```json",
+    beforeJson,
+    "```",
+    "",
+    "Updated version JSON:",
+    "```json",
+    afterJson,
+    "```",
+    "",
+    "Generate a commit message for these changes."
+  ].join("\n");
+  const result = await generateText({
+    model: languageModel,
+    system,
+    prompt
+  });
+  return result.text?.trim() || "";
+}
+async function translateString(rootConfig, options) {
+  const { model } = requireDefaultModel(rootConfig);
+  const languageModel = resolveLanguageModel(model);
+  const system = [
+    "You are a professional translator assistant.",
+    "Translate the given source text into the requested target languages.",
+    "Maintain the tone, style, and intent of the original text.",
+    "Return ONLY a valid JSON object with locale codes as keys and translations as values.",
+    "Do not include any markdown formatting, code blocks, or explanatory text."
+  ].join("\n");
+  const userPromptParts = [
+    `Source text: "${options.sourceText}"`,
+    ""
+  ];
+  if (options.description) {
+    userPromptParts.push(`Context/Description: ${options.description}`, "");
+  }
+  if (options.existingTranslations && Object.keys(options.existingTranslations).length > 0) {
+    userPromptParts.push("Existing translations for reference:");
+    Object.entries(options.existingTranslations).forEach(
+      ([locale, translation]) => {
+        if (translation) {
+          userPromptParts.push(`- ${locale}: "${translation}"`);
+        }
+      }
+    );
+    userPromptParts.push("");
+  }
+  userPromptParts.push(
+    `Target locales: ${options.targetLocales.join(", ")}`,
+    "",
+    "Provide translations as a JSON object with locale codes as keys."
+  );
+  const result = await generateText({
+    model: languageModel,
+    system,
+    prompt: userPromptParts.join("\n")
+  });
+  const responseText = result.text || "{}";
+  const jsonText = extractJsonFromResponse(responseText);
+  try {
+    return JSON.parse(jsonText);
+  } catch (err) {
+    console.error("failed to parse AI translation response:", responseText);
+    throw new Error("Invalid response format from AI translation");
+  }
+}
+async function generateAltText(rootConfig, options) {
+  const { model } = requireDefaultModel(rootConfig);
+  const languageModel = resolveLanguageModel(model);
+  const system = [
+    "Create a descriptive and concise alt text for the attached image.",
+    "",
+    "- The alt text should be a brief but comprehensive description of the image, including key subjects, the setting, and any relevant details or actions.",
+    "- The alt text should not exceed 125 characters.",
+    "- Only provide one generation, and include only that data in the response. No surrounding text, clarifications, etc. Just the alt text."
+  ].join("\n");
+  const result = await generateText({
+    model: languageModel,
+    system,
+    messages: [
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "Generate alt text for the image above." },
+          { type: "image", image: new URL(options.imageUrl) }
+        ]
+      }
+    ]
+  });
+  return result.text?.trim() || "";
+}
+async function generateImage(rootConfig, options) {
+  const config = getAiConfig(rootConfig);
+  if (!config) {
+    throw new Error("AI is not configured. Set `ai` on the cmsPlugin config.");
+  }
+  const imageModelConfig = findImageModel(config, options.modelId);
+  if (!imageModelConfig) {
+    throw new Error(
+      "No image model configured. Set `ai.imageModels` on the cmsPlugin config."
+    );
+  }
+  const imageModel = resolveImageModel(imageModelConfig);
+  const result = await generateImageSdk({
+    model: imageModel,
+    prompt: options.prompt,
+    aspectRatio: options.aspectRatio
+  });
+  if (!result.image) {
+    throw new Error("No image generated");
+  }
+  const mediaType = result.image.mediaType || "image/png";
+  return { imageUrl: `data:${mediaType};base64,${result.image.base64}` };
+}
+function extractJsonFromResponse(responseText) {
+  let jsonText = responseText.trim();
+  if (jsonText.startsWith("```")) {
+    const lines = jsonText.split("\n");
+    jsonText = lines.slice(1, -1).join("\n");
+    if (jsonText.startsWith("json")) {
+      jsonText = jsonText.substring(4).trim();
+    }
+  }
+  return jsonText;
+}
+
+// package.json
+var package_default = {
+  name: "@blinkk/root-cms",
+  version: "3.0.1-beta.2",
+  author: "s@blinkk.com",
+  license: "MIT",
+  engines: {
+    node: ">=16.0.0"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/blinkk/rootjs.git",
+    directory: "packages/root-cms"
+  },
+  files: [
+    "dist/**/*"
+  ],
+  bin: {
+    "root-cms": "./bin/root-cms.js"
+  },
+  type: "module",
+  module: "./dist/index.js",
+  types: "./dist/index.d.ts",
+  exports: {
+    ".": {
+      types: "./dist/core.d.ts",
+      import: "./dist/core.js"
+    },
+    "./client": {
+      types: "./dist/client.d.ts",
+      import: "./dist/client.js"
+    },
+    "./core": {
+      types: "./dist/core.d.ts",
+      import: "./dist/core.js"
+    },
+    "./functions": {
+      types: "./dist/functions.d.ts",
+      import: "./dist/functions.js"
+    },
+    "./plugin": {
+      types: "./dist/plugin.d.ts",
+      import: "./dist/plugin.js"
+    },
+    "./project": {
+      types: "./dist/project.d.ts",
+      import: "./dist/project.js"
+    },
+    "./richtext": {
+      types: "./dist/richtext.d.ts",
+      import: "./dist/richtext.js"
+    }
+  },
+  scripts: {
+    build: 'rm -rf dist && concurrently -n "core,signin,ui" npm:build:core npm:build:signin npm:build:ui',
+    "build:core": "tsup-node --config=./core/tsup.config.ts",
+    "//": "NOTE: esbuild is used here because tsup doesn't currently support aliases.",
+    "build:ui": "esbuild ui/ui.tsx --bundle --minify --alias:react=@preact/compat --alias:react-dom=@preact/compat --tsconfig=ui/tsconfig.json --outdir=dist/ui --legal-comments=external",
+    "build:signin": "esbuild signin/signin.tsx --bundle --minify --tsconfig=signin/tsconfig.json --outdir=dist/ui --legal-comments=external",
+    dev: 'rm -rf dist && concurrently -k -n "core,ui" npm:dev:core npm:dev:signin npm:dev:ui',
+    "dev:core": "pnpm build:core --watch",
+    "dev:signin": "pnpm build:signin --watch",
+    "dev:ui": "pnpm build:ui --watch",
+    test: "pnpm build && firebase emulators:exec 'vitest run --exclude=**/*.visual.test.tsx'",
+    "test:visual": "vitest run --config=vitest.config.visual.ts",
+    "test:watch": "pnpm build && firebase emulators:exec 'vitest'"
+  },
+  dependencies: {
+    "@ag-grid-community/client-side-row-model": "32.3.9",
+    "@ag-grid-community/core": "32.3.9",
+    "@ag-grid-community/react": "32.3.9",
+    "@ag-grid-community/styles": "32.3.9",
+    "@ai-sdk/anthropic": "3.0.74",
+    "@ai-sdk/google": "3.0.67",
+    "@ai-sdk/openai": "3.0.60",
+    "@ai-sdk/openai-compatible": "2.0.46",
+    "@ai-sdk/react": "3.0.177",
+    ai: "6.0.175",
+    zod: "4.4.3",
+    "@google-cloud/firestore": "7.11.3",
+    "@hello-pangea/dnd": "18.0.1",
+    "@types/cli-progress": "3.11.6",
+    "body-parser": "1.20.2",
+    "cli-progress": "3.12.0",
+    commander: "11.0.0",
+    "csv-parse": "5.5.2",
+    "csv-stringify": "6.4.4",
+    "date-fns": "4.1.0",
+    "date-fns-tz": "3.2.0",
+    diff: "8.0.2",
+    "dts-dom": "3.7.0",
+    "@mantine/spotlight": "4.2.12",
+    "fnv-plus": "1.3.1",
+    jsonwebtoken: "9.0.2",
+    kleur: "4.1.5",
+    minisearch: "7.2.0",
+    sirv: "2.0.3",
+    "tiny-glob": "0.2.9"
+  },
+  "//": "NOTE(stevenle): due to compat issues with mantine and preact, mantine is pinned to v4.2.12",
+  devDependencies: {
+    "@babel/core": "7.17.9",
+    "@blinkk/root": "workspace:*",
+    "@editorjs/editorjs": "2.30.8",
+    "@editorjs/header": "2.8.8",
+    "@editorjs/image": "2.10.2",
+    "@editorjs/list": "2.0.6",
+    "@editorjs/nested-list": "1.4.3",
+    "@editorjs/raw": "2.5.1",
+    "@editorjs/table": "2.4.4",
+    "@editorjs/underline": "1.2.1",
+    "@emotion/react": "11.10.5",
+    "@firebase/app-compat": "0.5.2",
+    "@firebase/app-types": "0.9.3",
+    "@firebase/rules-unit-testing": "5.0.0",
+    "@lexical/code": "0.33.1",
+    "@lexical/html": "0.33.1",
+    "@lexical/link": "0.33.1",
+    "@lexical/list": "0.33.1",
+    "@lexical/markdown": "0.33.1",
+    "@lexical/react": "0.33.1",
+    "@lexical/rich-text": "0.33.1",
+    "@lexical/selection": "0.33.1",
+    "@lexical/table": "0.33.1",
+    "@lexical/utils": "0.33.1",
+    "@mantine/core": "4.2.12",
+    "@mantine/hooks": "4.2.12",
+    "@mantine/modals": "4.2.12",
+    "@mantine/notifications": "4.2.12",
+    "@preact/compat": "18.3.1",
+    "@tabler/icons-preact": "3.35.0",
+    "@testing-library/preact": "3.2.4",
+    "@testing-library/user-event": "14.6.1",
+    "@types/body-parser": "1.19.3",
+    "@types/fnv-plus": "1.3.2",
+    "@types/gapi": "0.0.47",
+    "@types/gapi.client.drive-v3": "0.0.4",
+    "@types/gapi.client.sheets-v4": "0.0.4",
+    "@types/google.accounts": "0.0.14",
+    "@types/jsonwebtoken": "9.0.1",
+    "@types/node": "24.3.1",
+    "@vitest/browser": "4.1.2",
+    "@vitest/browser-playwright": "4.1.2",
+    concurrently: "7.6.0",
+    esbuild: "0.25.9",
+    firebase: "12.2.1",
+    "firebase-admin": "13.5.0",
+    "firebase-functions": "6.4.0",
+    "firebase-tools": "14.15.2",
+    "highlight.js": "11.6.0",
+    jsdom: "27.2.0",
+    "json-diff-kit": "1.0.29",
+    lexical: "0.33.1",
+    marked: "9.1.1",
+    "mdast-util-from-markdown": "2.0.1",
+    "mdast-util-gfm": "3.0.0",
+    "micromark-extension-gfm": "3.0.0",
+    playwright: "1.56.1",
+    preact: "10.27.1",
+    "preact-iso": "2.11.1",
+    "preact-render-to-string": "6.6.7",
+    react: "npm:@preact/compat@18.3.1",
+    "react-dom": "npm:@preact/compat@18.3.1",
+    "react-easy-crop": "5.5.6",
+    "react-json-view-compare": "2.0.2",
+    tsup: "8.5.0",
+    typescript: "5.9.2",
+    vite: "8.0.3",
+    vitest: "4.1.2",
+    yjs: "13.6.27"
+  },
+  peerDependencies: {
+    "@blinkk/root": "3.0.1-beta.2",
+    "firebase-admin": ">=11",
+    "firebase-functions": ">=4"
+  },
+  peerDependenciesMeta: {
+    "firebase-functions": {
+      optional: true
+    }
+  }
+};
+
+// core/server-version.ts
+var SERVER_STARTUP_TS = String(Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3));
+function getServerVersion() {
+  if (process.env.NODE_ENV === "development") {
+    return SERVER_STARTUP_TS;
+  }
+  return package_default?.version || "root-3.0.0";
+}
+
+export {
+  serializeAiConfig,
+  getAiConfig,
+  findModel,
+  ChatStore,
+  runChatStream,
+  runEditObjectStream,
+  summarizeDiff,
+  generatePublishMessage,
+  translateString,
+  generateAltText,
+  generateImage,
+  getServerVersion
+};