@blinkk/root-cms 3.1.3 → 3.1.4

package/dist/{chunk-4VZTYUQ7.js → chunk-NC3CRIFA.js}

@@ -1,7 +1,11 @@
 import {
+  RootCMSClient,
   getCmsPlugin
 } from "./chunk-AFBSITEO.js";
 
+// core/cron.ts
+import { Timestamp as Timestamp3 } from "firebase-admin/firestore";
+
 // core/search-index.ts
 import fs from "node:fs";
 import path from "node:path";
@@ -673,8 +677,8 @@ var SearchIndexService = class {
   async listAllDocs(collectionIds) {
     const all = [];
     for (const collectionId of collectionIds) {
-      const path2 = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
-      const snap = await this.db.collection(path2).get();
+      const path3 = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
+      const snap = await this.db.collection(path3).get();
       snap.forEach((d) => {
         const docId = `${collectionId}/${d.id}`;
         if (!this.isDocIndexable(docId)) {
@@ -696,8 +700,8 @@ var SearchIndexService = class {
   async listChangedDocs(collectionIds, lastRun) {
     const all = [];
     for (const collectionId of collectionIds) {
-      const path2 = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
-      const q = this.db.collection(path2).where("sys.modifiedAt", ">=", lastRun);
+      const path3 = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
+      const q = this.db.collection(path3).where("sys.modifiedAt", ">=", lastRun);
       const snap = await q.get();
       snap.forEach((d) => {
         const docId = `${collectionId}/${d.id}`;
@@ -721,8 +725,8 @@ var SearchIndexService = class {
   async hasChangesSince(lastRun, docMap = null) {
     const collectionIds = await this.listCollectionIds();
     for (const collectionId of collectionIds) {
-      const path2 = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
-      const q = this.db.collection(path2).where("sys.modifiedAt", ">=", lastRun).limit(1);
+      const path3 = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
+      const q = this.db.collection(path3).where("sys.modifiedAt", ">=", lastRun).limit(1);
       const snap = await q.get();
       if (!snap.empty) {
         return true;
@@ -735,8 +739,8 @@ var SearchIndexService = class {
     }
     const liveIds = /* @__PURE__ */ new Set();
     for (const collectionId of collectionIds) {
-      const path2 = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
-      const snap = await this.db.collection(path2).select().get();
+      const path3 = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
+      const snap = await this.db.collection(path3).select().get();
       snap.forEach((d) => {
         const docId = `${collectionId}/${d.id}`;
         if (this.isDocIndexable(docId)) {
@@ -803,8 +807,8 @@ var SearchIndexService = class {
         );
         continue;
       }
-      const path2 = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
-      const snap = await this.db.collection(path2).get();
+      const path3 = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
+      const snap = await this.db.collection(path3).get();
       snap.forEach((d) => {
         const data = d.data() || {};
         const slug = data.slug || d.id;
@@ -880,8 +884,8 @@ var SearchIndexService = class {
     }
     const liveIds = /* @__PURE__ */ new Set();
     for (const collectionId of collectionIds) {
-      const path2 = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
-      const snap = await this.db.collection(path2).select().get();
+      const path3 = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
+      const snap = await this.db.collection(path3).select().get();
       snap.forEach((d) => {
         const docId = `${collectionId}/${d.id}`;
         if (this.isDocIndexable(docId)) {
@@ -997,6 +1001,180 @@ var SearchIndexService = class {
   }
 };
 
+// core/versions.ts
+import fs2 from "node:fs";
+import path2 from "node:path";
+import { Timestamp as Timestamp2 } from "firebase-admin/firestore";
+import glob2 from "tiny-glob";
+var DOCUMENT_SAVE_OFFSET = 5 * 60 * 1e3;
+var VersionsService = class {
+  constructor(rootConfig) {
+    this.rootConfig = rootConfig;
+    const cmsPlugin = getCmsPlugin(rootConfig);
+    const cmsPluginOptions = cmsPlugin.getConfig();
+    const projectId = cmsPluginOptions.id || "default";
+    this.projectId = projectId;
+    this.db = cmsPlugin.getFirestore();
+  }
+  /**
+   * Saves a version of all documents that have been edited since the last run.
+   */
+  async saveVersions() {
+    const lastRun = await this.getLastRun();
+    const lastRunWithOffset = lastRun === 0 ? lastRun : lastRun - DOCUMENT_SAVE_OFFSET;
+    const changedDocs = await this.getDocsModifiedAfter(lastRunWithOffset);
+    const now = Timestamp2.now().toMillis();
+    const versions = changedDocs.filter((doc) => {
+      const modifiedAt = doc.sys.modifiedAt.toMillis();
+      if (modifiedAt > now - DOCUMENT_SAVE_OFFSET) {
+        return false;
+      }
+      const publishedAt = doc.sys.publishedAt?.toMillis?.();
+      if (publishedAt && Math.abs(publishedAt - modifiedAt) < 5e3) {
+        return false;
+      }
+      return true;
+    });
+    if (versions.length > 0) {
+      this.saveVersionsToFirestore(versions);
+    }
+    this.saveLastRun(now);
+  }
+  async saveVersionsToFirestore(versions) {
+    const batch = this.db.batch();
+    versions.forEach((version) => {
+      if (!version.collection || !version.slug || !version.sys?.modifiedAt) {
+        return;
+      }
+      const modifiedAtMillis = version.sys.modifiedAt.toMillis();
+      const versionPath = `Projects/${this.projectId}/Collections/${version.collection}/Drafts/${version.slug}/Versions/${modifiedAtMillis}`;
+      console.log(versionPath);
+      const versionRef = this.db.doc(versionPath);
+      batch.set(versionRef, version);
+    });
+    await batch.commit();
+    console.log(`versions: saved ${versions.length} versions`);
+  }
+  /**
+   * Returns the last time (in millis) saveVersions() was run, or 0 if has
+   * never been run.
+   */
+  async getLastRun() {
+    const projectDocRef = this.db.collection("Projects").doc(this.projectId);
+    const projectDoc = await projectDocRef.get();
+    if (projectDoc.exists) {
+      const data = projectDoc.data() || {};
+      const ts = data.versionsLastRun;
+      if (ts) {
+        return ts.toMillis();
+      }
+    }
+    return 0;
+  }
+  /**
+   * Saves {versionLastRun: <timestamp>} to the Projects/<projectId> doc.
+   */
+  async saveLastRun(millis) {
+    const ts = Timestamp2.fromMillis(millis);
+    const projectDocRef = this.db.collection("Projects").doc(this.projectId);
+    await projectDocRef.set({ versionsLastRun: ts }, { merge: true });
+  }
+  /**
+   * Returns a list of all docs that were edited after a certain time.
+   */
+  async getDocsModifiedAfter(millis) {
+    const ts = Timestamp2.fromMillis(millis);
+    const results = [];
+    const collectionIds = await this.listCollections();
+    for (const collectionId of collectionIds) {
+      const collectionPath = `Projects/${this.projectId}/Collections/${collectionId}/Drafts`;
+      const query = this.db.collection(collectionPath).where("sys.modifiedAt", ">=", ts);
+      const querySnapshot = await query.get();
+      querySnapshot.forEach((doc) => {
+        results.push(doc.data());
+      });
+    }
+    return results;
+  }
+  /**
+   * Returns a list of collection ids for the Root project.
+   */
+  async listCollections() {
+    const collectionsDir = path2.join(this.rootConfig.rootDir, "collections");
+    if (!fs2.existsSync(collectionsDir)) {
+      return [];
+    }
+    const collectionIds = [];
+    const collectionFileNames = await glob2("*.schema.ts", {
+      cwd: collectionsDir
+    });
+    collectionFileNames.forEach((filename) => {
+      collectionIds.push(filename.slice(0, -10));
+    });
+    return collectionIds;
+  }
+};
+
+// core/cron.ts
+var SEARCH_INDEX_MIN_INTERVAL_MS = 5 * 60 * 1e3;
+async function runCronJobs(rootConfig, options = {}) {
+  await Promise.all([
+    runCronJob("publishScheduledDocs", runPublishScheduledDocs, rootConfig),
+    runCronJob(
+      "syncScheduledDataSources",
+      runSyncScheduledDataSources,
+      rootConfig
+    ),
+    runCronJob("saveVersions", runSaveVersions, rootConfig),
+    runCronJob(
+      "incrementalSearchIndex",
+      runIncrementalSearchIndex,
+      rootConfig,
+      options.loadSchema
+    )
+  ]);
+}
+async function runCronJob(name, fn, ...args) {
+  try {
+    await fn(...args);
+  } catch (err) {
+    console.log(`cron failed: ${name}`);
+    console.error(String(err.stack || err));
+    throw err;
+  }
+}
+async function runPublishScheduledDocs(rootConfig) {
+  const cmsClient = new RootCMSClient(rootConfig);
+  await cmsClient.publishScheduledDocs();
+  await cmsClient.publishScheduledReleases();
+}
+async function runSyncScheduledDataSources(rootConfig) {
+  const cmsClient = new RootCMSClient(rootConfig);
+  await cmsClient.syncScheduledDataSources();
+}
+async function runSaveVersions(rootConfig) {
+  const service = new VersionsService(rootConfig);
+  await service.saveVersions();
+}
+async function runIncrementalSearchIndex(rootConfig, loadSchema) {
+  const service = new SearchIndexService(rootConfig, loadSchema);
+  const status = await service.getStatus();
+  if (status.lastRun !== null) {
+    const elapsed = Date.now() - status.lastRun;
+    if (elapsed < SEARCH_INDEX_MIN_INTERVAL_MS) {
+      return;
+    }
+    const hasChanges = await service.hasChangesSince(
+      Timestamp3.fromMillis(status.lastRun)
+    );
+    if (!hasChanges) {
+      return;
+    }
+  }
+  await service.rebuildIndex({ force: false });
+}
+
 export {
-  SearchIndexService
+  SearchIndexService,
+  runCronJobs
 };

package/dist/core/ai-tools.d.ts

@@ -1,11 +1,11 @@
 /**
  * Built-in CMS tools exposed to the chat model on the `/cms/ai` page.
  *
- * Read tools (`doc_get`, `docs_list`, etc.) execute server-side via the
- * Firebase Admin SDK when a `CmsToolContext` is passed to the factory. This
- * keeps potentially-large doc payloads off the wire: results stay in the
- * model's server-side context instead of round-tripping through the browser
- * on every chat turn.
+ * Read tools (`doc_get`, `docs_list`, etc.) run their `execute` against a
+ * pluggable `CmsToolReadBackend`. The `/cms/ai` chat now streams directly from
+ * the browser, so the client supplies a Firebase-web-SDK backend (see
+ * `ui/components/RootAIChat/clientCmsTools.ts`). The factory itself is
+ * data-source agnostic.
  *
  * Write tools (`doc_set`, `doc_create`, `doc_updateField`, `doc_duplicate`)
  * stay schema-only here — the browser executes them via `onToolCall` so the
@@ -15,16 +15,12 @@
  * Validation helpers (`validateFields`, `validateValueAtPath`) live here
  * too so both browser and server can share the same checks.
  *
- * Browser-import safety: this module is dynamically imported by the browser
- * bundle (cmsToolHandlers.ts) to reuse the validators, so it must not pull
- * server-only modules into runtime imports. `RootCMSClient` and `RootConfig`
- * are referenced as types only; the actual instance is passed in at call
- * time via `CmsToolContext`.
+ * Browser-import safety: this module is imported by the browser bundle, so it
+ * must not pull server-only modules (`firebase-admin`, `node:*`) into runtime
+ * imports. The backend implementation is injected at call time.
  */
-import type { RootConfig } from '@blinkk/root';
 import { ToolSet } from 'ai';
-import type { RootCMSClient } from './client.js';
-import { Collection } from './schema.js';
+import { Collection, Field } from './schema.js';
 import { validateFields } from './validation.js';
 /** Tool ids handled client-side. Kept in sync with the schemas below. */
 export declare const CMS_TOOL_NAMES: readonly ["collections_list", "docs_list", "doc_get", "doc_getVersion", "doc_set", "doc_create", "doc_updateField", "doc_edit", "doc_duplicate", "doc_listVersions", "doc_translateField", "schema_get"];
@@ -35,48 +31,83 @@ export type CmsToolName = (typeof CMS_TOOL_NAMES)[number];
  * and the model must not write to Firestore directly.
  */
 export declare const READ_ONLY_CMS_TOOL_NAMES: readonly CmsToolName[];
-/**
- * Result of a server-side search invocation. Loosely-typed — the result is
- * serialized to JSON and handed to the model, so extra fields are fine.
- * `hits` is an array of objects each carrying at least a `docId`.
- */
-export interface CmsSearchResult {
-    hits: Array<Record<string, unknown> | {
-        docId: string;
-    }>;
+/** A CMS document shaped for the model (fields/sys already unmarshalled). */
+export interface CmsToolDoc {
+    id: string;
+    collection: string;
+    slug: string;
+    sys: Record<string, unknown>;
+    fields: Record<string, unknown>;
+}
+/** Lightweight doc summary returned by `docs_list`. */
+export interface CmsToolDocSummary {
+    id: string;
+    slug: string;
+    sys: Record<string, unknown>;
+}
+/** Version summary returned by `doc_listVersions`. */
+export interface CmsToolVersionSummary {
+    versionId: string;
+    sys: Record<string, unknown>;
+    tags: string[];
+    publishMessage?: string;
+}
+/** Collection summary returned by `collections_list`. */
+export interface CmsToolCollectionSummary {
+    id: string;
+    name?: string;
+    description?: string;
 }
 /**
- * Context passed into the tool factory to enable server-side execution of
- * the read tools. The caller (typically `runChatStream` in `core/ai.ts`)
- * owns the Firebase Admin client and the schema/search lookups.
+ * Data-source backing the read tools. Implemented server-side (Firebase Admin)
+ * or in the browser (Firebase web SDK — see `clientCmsTools.ts`). The factory
+ * is agnostic to where the reads run.
+ *
+ * Implementations own docId parsing and unmarshalling so the tool `execute`
+ * blocks stay thin and the returned shapes are model-ready.
  */
-export interface CmsToolContext {
-    cmsClient: RootCMSClient;
-    user: string;
-    rootConfig: RootConfig;
-    loadCollection: (collectionId: string) => Promise<Collection | null>;
-    loadAllCollections: () => Promise<Record<string, Collection>>;
-    search: (query: string, options: {
+export interface CmsToolReadBackend {
+    /** Lists all collections with optional name/description metadata. */
+    listCollections(): Promise<CmsToolCollectionSummary[]>;
+    /** Lists docs in a collection (draft or published). */
+    listDocs(collectionId: string, options: {
+        mode: 'draft' | 'published';
+        limit: number;
+    }): Promise<CmsToolDocSummary[]>;
+    /** Reads a single doc, or `null` if it does not exist. */
+    getDoc(docId: string, options: {
+        mode: 'draft' | 'published';
+    }): Promise<CmsToolDoc | null>;
+    /**
+     * Reads a specific version of a doc. `versionId` is "draft", "published" or
+     * a numeric timestamp. Returns `null` if it does not exist.
+     */
+    getDocVersion(docId: string, versionId: string): Promise<CmsToolDoc | null>;
+    /** Lists a doc's version history, most recent first. */
+    listVersions(docId: string, options: {
         limit: number;
-    }) => Promise<CmsSearchResult>;
+    }): Promise<CmsToolVersionSummary[]>;
+    /**
+     * Returns the simplified field definitions for a collection (see
+     * `simplifyFields`), or `null` if the collection is unknown.
+     */
+    getSchemaFields(collectionId: string): Promise<unknown[] | null>;
 }
 /**
  * Returns a `ToolSet` filtered to only the read-only CMS tools. Use this in
  * flows where the AI assists with proposing changes that the user reviews
  * and saves manually (so the model can read context but cannot mutate data).
  */
-export declare function createReadOnlyCmsTools(ctx: CmsToolContext): ToolSet;
+export declare function createReadOnlyCmsTools(backend: CmsToolReadBackend): ToolSet;
 /**
  * Builds the full tool set advertised to the model.
  *
  * Read tools (`collections_list`, `docs_list`, `docs_search`, `doc_get`,
- * `doc_getVersion`, `doc_listVersions`, `schema_get`) carry a server-side
- * `execute` so the Vercel AI SDK runs them in-process; their results stay
- * in the model's server-side context and never round-trip through the
- * browser. Write tools (`doc_set`, `doc_create`, `doc_updateField`,
- * `doc_duplicate`, `doc_translateField`) remain schema-only — the browser
- * executes them via `onToolCall` so the user can approve diffs before
- * persistence.
+ * `doc_getVersion`, `doc_listVersions`, `schema_get`) carry an `execute` that
+ * delegates to the supplied `CmsToolReadBackend`. Write tools (`doc_set`,
+ * `doc_create`, `doc_updateField`, `doc_duplicate`, `doc_translateField`)
+ * remain schema-only — the browser executes them via `onToolCall` so the user
+ * can approve diffs before persistence.
  *
  * Safety policy: this tool set is intentionally read + draft-write only.
  * The following operations are deliberately NOT exposed to the model
@@ -97,7 +128,16 @@ export declare function createReadOnlyCmsTools(ctx: CmsToolContext): ToolSet;
  * If you add new write tools here, keep them limited to draft-mode edits
  * the user can easily review before publishing.
  */
-export declare function createCmsTools(ctx: CmsToolContext): ToolSet;
+export declare function createCmsTools(backend: CmsToolReadBackend): ToolSet;
+/**
+ * Reduces a collection's field definitions down to the bits the model needs
+ * (id, type, label, options, nested shape). Drops Root-internal metadata
+ * (preview, conditional visibility, default UI widget hints, etc.) since
+ * those would bloat the model context without adding decision-useful info.
+ *
+ * Exported so the browser backend can shape `schema_get` results the same way.
+ */
+export declare function simplifyFields(fields: Field[]): unknown[];
 /**
  * Validates `value` against the field schema located at `path` within
  * `collection`. Returns validation errors if the field can be resolved and