@treeseed/core 0.4.9 → 0.4.11

package/dist/templates.d.ts

@@ -0,0 +1,98 @@
+import type { CatalogItem, CatalogItemOfferMode } from '@treeseed/sdk/types';
+export interface TemplateContentEntry {
+    id: string;
+    data: {
+        slug: string;
+        title: string;
+        summary: string;
+        description: string;
+        status: string;
+        category: string;
+        featured?: boolean;
+        publisher: {
+            name: string;
+        };
+        templateVersion: string;
+        templateApiVersion: number;
+        minCliVersion: string;
+        minCoreVersion: string;
+        offer?: {
+            priceModel?: CatalogItemOfferMode | string;
+        };
+        fulfillment: {
+            mode?: string;
+            source: {
+                kind: 'git';
+                repoUrl: string;
+                directory: string;
+                ref: string;
+            } | {
+                kind: 'r2';
+                objectKey: string;
+                version: string;
+                publicUrl?: string;
+            };
+            hooksPolicy?: string;
+            supportsReconcile?: boolean;
+        };
+    };
+    [key: string]: unknown;
+}
+export interface TemplateCatalogProviderContext {
+    locals?: object | null | undefined;
+}
+export interface TemplateCatalogProvider {
+    listItems?(context: TemplateCatalogProviderContext): Promise<CatalogItem[]>;
+    getItemBySlug?(slug: string, context: TemplateCatalogProviderContext): Promise<CatalogItem | null>;
+}
+export interface TemplateSiteCard {
+    slug: string;
+    title: string;
+    summary: string;
+    category: string;
+    featured: boolean;
+    publisherName: string;
+    templateVersion?: string;
+    priceModel?: CatalogItemOfferMode | string;
+    source: 'catalog' | 'content';
+}
+export interface TemplateSiteDetail extends TemplateSiteCard {
+    description: string;
+    compatibility: {
+        templateVersion?: string;
+        templateApiVersion?: number | string;
+        minCliVersion?: string;
+        minCoreVersion?: string;
+    };
+    fulfillment: {
+        mode: string;
+        sourceLabel: string;
+        artifactKey?: string | null;
+        manifestKey?: string | null;
+        repoUrl?: string;
+        directory?: string;
+        ref?: string;
+        objectKey?: string;
+        version?: string;
+        publicUrl?: string;
+        hooksPolicy?: string | null;
+        supportsReconcile?: boolean | null;
+    };
+    contentEntry: TemplateContentEntry | null;
+    catalogItem: CatalogItem | null;
+}
+type TemplateSourceOptions = TemplateCatalogProviderContext & {
+    catalogProvider?: TemplateCatalogProvider | null;
+    listLocalEntries?: (() => Promise<TemplateContentEntry[]>) | null;
+};
+export interface TemplateSiteListingResult {
+    rendered: boolean;
+    items: TemplateSiteCard[];
+}
+export interface ResolvedSiteTemplateResult {
+    rendered: boolean;
+    item: TemplateSiteDetail | null;
+}
+export declare function listSiteTemplates(context?: TemplateSourceOptions): Promise<TemplateSiteListingResult>;
+export declare function resolveSiteTemplate(slug: string, context?: TemplateSourceOptions): Promise<ResolvedSiteTemplateResult>;
+export {};

package/dist/templates.js

@@ -0,0 +1,170 @@
+import { getCollection } from "astro:content";
+import { RUNTIME_TENANT } from "./tenant/runtime-config.js";
+import { siteModelRendered } from "./utils/site-models.js";
+function sortTemplateCards(entries) {
+  return [...entries].sort((left, right) => {
+    const featuredDelta = Number(Boolean(right.featured)) - Number(Boolean(left.featured));
+    if (featuredDelta !== 0) {
+      return featuredDelta;
+    }
+    return String(left.title ?? "").localeCompare(String(right.title ?? ""), void 0, { sensitivity: "base" });
+  });
+}
+async function listLocalTemplateEntries(listLocalEntries) {
+  if (typeof listLocalEntries === "function") {
+    return listLocalEntries();
+  }
+  if (!RUNTIME_TENANT.content.templates) {
+    return [];
+  }
+  return getCollection("templates");
+}
+function catalogString(metadata, key) {
+  const value = metadata?.[key];
+  return typeof value === "string" && value.trim() ? value : void 0;
+}
+function catalogNumber(metadata, key) {
+  const value = metadata?.[key];
+  return typeof value === "number" ? value : void 0;
+}
+function contentCardFromEntry(entry) {
+  if (entry.data.status !== "live") {
+    return null;
+  }
+  return {
+    slug: entry.data.slug,
+    title: entry.data.title,
+    summary: entry.data.summary,
+    category: entry.data.category,
+    featured: entry.data.featured === true,
+    publisherName: entry.data.publisher.name,
+    templateVersion: entry.data.templateVersion,
+    priceModel: entry.data.offer?.priceModel,
+    source: "content"
+  };
+}
+function detailFromContentEntry(entry) {
+  const source = entry.data.fulfillment.source;
+  return {
+    ...contentCardFromEntry(entry),
+    description: entry.data.description,
+    compatibility: {
+      templateVersion: entry.data.templateVersion,
+      templateApiVersion: entry.data.templateApiVersion,
+      minCliVersion: entry.data.minCliVersion,
+      minCoreVersion: entry.data.minCoreVersion
+    },
+    fulfillment: source.kind === "r2" ? {
+      mode: entry.data.fulfillment.mode ?? "r2",
+      sourceLabel: "R2 artifact",
+      objectKey: source.objectKey,
+      version: source.version,
+      publicUrl: source.publicUrl,
+      hooksPolicy: entry.data.fulfillment.hooksPolicy,
+      supportsReconcile: entry.data.fulfillment.supportsReconcile
+    } : {
+      mode: entry.data.fulfillment.mode ?? "git",
+      sourceLabel: "Git",
+      repoUrl: source.repoUrl,
+      directory: source.directory,
+      ref: source.ref,
+      hooksPolicy: entry.data.fulfillment.hooksPolicy,
+      supportsReconcile: entry.data.fulfillment.supportsReconcile
+    },
+    contentEntry: entry,
+    catalogItem: null
+  };
+}
+function cardFromCatalogItem(item) {
+  return {
+    slug: item.slug,
+    title: item.title,
+    summary: item.summary ?? "",
+    category: catalogString(item.metadata, "category") ?? "Template",
+    featured: item.metadata?.featured === true,
+    publisherName: catalogString(item.metadata, "publisherName") ?? item.teamId,
+    templateVersion: catalogString(item.metadata, "templateVersion"),
+    priceModel: item.offerMode,
+    source: "catalog"
+  };
+}
+function detailFromCatalogItem(item) {
+  return {
+    ...cardFromCatalogItem(item),
+    description: item.summary ?? "This template is managed through the central market catalog.",
+    compatibility: {
+      templateVersion: catalogString(item.metadata, "templateVersion"),
+      templateApiVersion: catalogNumber(item.metadata, "templateApiVersion"),
+      minCliVersion: catalogString(item.metadata, "minCliVersion"),
+      minCoreVersion: catalogString(item.metadata, "minCoreVersion")
+    },
+    fulfillment: {
+      mode: catalogString(item.metadata, "fulfillmentMode") ?? "r2",
+      sourceLabel: item.artifactKey ? "R2 artifact" : "Catalog metadata",
+      artifactKey: item.artifactKey,
+      manifestKey: item.manifestKey
+    },
+    contentEntry: null,
+    catalogItem: item
+  };
+}
+async function selectCatalogItemBySlug(slug, context) {
+  if (!context.catalogProvider) {
+    return null;
+  }
+  if (typeof context.catalogProvider.getItemBySlug === "function") {
+    return context.catalogProvider.getItemBySlug(slug, { locals: context.locals });
+  }
+  if (typeof context.catalogProvider.listItems === "function") {
+    const items = await context.catalogProvider.listItems({ locals: context.locals });
+    return items.find((item) => item.slug === slug) ?? null;
+  }
+  return null;
+}
+async function listSiteTemplates(context = {}) {
+  if (!siteModelRendered("templates")) {
+    return {
+      rendered: false,
+      items: []
+    };
+  }
+  const catalogItems = context.catalogProvider && typeof context.catalogProvider.listItems === "function" ? await context.catalogProvider.listItems({ locals: context.locals }) : [];
+  if (catalogItems.length > 0) {
+    return {
+      rendered: true,
+      items: sortTemplateCards(catalogItems.map(cardFromCatalogItem))
+    };
+  }
+  const entries = await listLocalTemplateEntries(context.listLocalEntries);
+  return {
+    rendered: true,
+    items: sortTemplateCards(
+      entries.map(contentCardFromEntry).filter((entry) => Boolean(entry))
+    )
+  };
+}
+async function resolveSiteTemplate(slug, context = {}) {
+  if (!siteModelRendered("templates")) {
+    return {
+      rendered: false,
+      item: null
+    };
+  }
+  const catalogItem = await selectCatalogItemBySlug(slug, context);
+  if (catalogItem) {
+    return {
+      rendered: true,
+      item: detailFromCatalogItem(catalogItem)
+    };
+  }
+  const entries = await listLocalTemplateEntries(context.listLocalEntries);
+  const entry = entries.find((candidate) => candidate.data.slug === slug && candidate.data.status === "live") ?? null;
+  return {
+    rendered: true,
+    item: entry ? detailFromContentEntry(entry) : null
+  };
+}
+export {
+  listSiteTemplates,
+  resolveSiteTemplate
+};

package/dist/tenant/runtime-config.d.ts

@@ -0,0 +1,4 @@
+import type { TreeseedTenantConfig } from '@treeseed/sdk/platform/contracts';
+export declare const RUNTIME_PROJECT_ROOT: string;
+export declare const RUNTIME_TENANT: TreeseedTenantConfig;
+export declare const RUNTIME_SITE_CONFIG: any;

package/dist/tenant/runtime-config.js

@@ -1,11 +1,44 @@
 import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
 import { loadTreeseedManifest } from "@treeseed/sdk/platform/tenant-config";
 import { parseSiteConfig } from "../utils/site-config-schema.js";
 const injectedTenantConfig = typeof __TREESEED_TENANT_CONFIG__ !== "undefined" ? __TREESEED_TENANT_CONFIG__ : null;
 const injectedProjectRoot = typeof __TREESEED_PROJECT_ROOT__ !== "undefined" ? __TREESEED_PROJECT_ROOT__ : null;
 const injectedSiteConfig = typeof __TREESEED_SITE_CONFIG__ !== "undefined" ? __TREESEED_SITE_CONFIG__ : null;
-const RUNTIME_TENANT = injectedTenantConfig ?? loadTreeseedManifest();
 const RUNTIME_PROJECT_ROOT = injectedProjectRoot ?? process.cwd();
+function fallbackTenantConfig(projectRoot) {
+  return {
+    id: "treeseed-runtime",
+    siteConfigPath: resolve(projectRoot, "treeseed.site.yaml"),
+    content: {
+      pages: resolve(projectRoot, "src/content/pages"),
+      notes: resolve(projectRoot, "src/content/notes"),
+      questions: resolve(projectRoot, "src/content/questions"),
+      objectives: resolve(projectRoot, "src/content/objectives"),
+      people: resolve(projectRoot, "src/content/people"),
+      agents: resolve(projectRoot, "src/content/agents"),
+      books: resolve(projectRoot, "src/content/books"),
+      docs: resolve(projectRoot, "src/content/knowledge"),
+      templates: resolve(projectRoot, "src/content/templates"),
+      knowledge_packs: resolve(projectRoot, "src/content/knowledge-packs"),
+      workdays: resolve(projectRoot, "src/content/workdays")
+    },
+    features: {
+      docs: true,
+      books: true
+    }
+  };
+}
+const RUNTIME_TENANT = (() => {
+  if (injectedTenantConfig) {
+    return injectedTenantConfig;
+  }
+  try {
+    return loadTreeseedManifest();
+  } catch {
+    return fallbackTenantConfig(RUNTIME_PROJECT_ROOT);
+  }
+})();
 const RUNTIME_SITE_CONFIG = injectedSiteConfig ?? (() => {
   try {
     return parseSiteConfig(readFileSync(RUNTIME_TENANT.siteConfigPath, "utf8"));

package/dist/utils/hub-content.js

@@ -1,4 +1,5 @@
 import { getCollection, getEntries, getEntry } from "astro:content";
+import { siteModelRendered } from "./site-models.js";
 function sortEntriesByDateDescending(entries) {
   return [...entries].sort((left, right) => right.data.date.valueOf() - left.data.date.valueOf());
 }
@@ -13,13 +14,47 @@ async function resolveReferences(references) {
   return getEntries(references);
 }
 async function getPublishedQuestions() {
+  if (!siteModelRendered("questions")) {
+    return [];
+  }
   return sortEntriesByDateDescending(await getCollection("questions", ({ data }) => !data.draft));
 }
 async function getPublishedObjectives() {
+  if (!siteModelRendered("objectives")) {
+    return [];
+  }
   return sortEntriesByDateDescending(await getCollection("objectives", ({ data }) => !data.draft));
 }
+async function getPublishedNotes() {
+  if (!siteModelRendered("notes")) {
+    return [];
+  }
+  return sortEntriesByDateDescending(await getCollection("notes", ({ data }) => !data.draft));
+}
+async function getPublishedPeople() {
+  if (!siteModelRendered("people")) {
+    return [];
+  }
+  return getCollection("people");
+}
+async function getPublishedAgents() {
+  if (!siteModelRendered("agents")) {
+    return [];
+  }
+  return getCollection("agents");
+}
+async function getPublishedBooks() {
+  if (!siteModelRendered("books")) {
+    return [];
+  }
+  return (await getCollection("books")).sort((a, b) => a.data.order - b.data.order);
+}
 export {
+  getPublishedAgents,
+  getPublishedBooks,
+  getPublishedNotes,
   getPublishedObjectives,
+  getPublishedPeople,
   getPublishedQuestions,
   resolveContributor,
   resolveContributorsForEntries,

package/dist/utils/published-content.js

@@ -0,0 +1,60 @@
+import { getTreeseedDeployConfig } from "@treeseed/sdk/platform/plugins";
+import {
+  createTeamScopedR2OverlayContentRuntimeProvider,
+  isTeamScopedR2ContentEnabled,
+  resolveCloudflareR2Bucket,
+  resolvePublishedContentBucketBinding,
+  resolveTeamScopedContentLocator
+} from "@treeseed/sdk/platform/published-content";
+function runtimeFromLocals(locals) {
+  return locals?.runtime ?? null;
+}
+function previewFromLocals(locals) {
+  return locals?.contentPreview ?? null;
+}
+function defaultTeamIdForRuntime(locals) {
+  const runtime = runtimeFromLocals(locals);
+  const configured = typeof runtime?.env?.TREESEED_CONTENT_DEFAULT_TEAM_ID === "string" ? runtime.env.TREESEED_CONTENT_DEFAULT_TEAM_ID.trim() : "";
+  if (configured) {
+    return configured;
+  }
+  return getTreeseedDeployConfig().slug;
+}
+function resolveHostedContentRuntimeProvider(locals) {
+  const deployConfig = getTreeseedDeployConfig();
+  if (!isTeamScopedR2ContentEnabled(deployConfig)) {
+    return null;
+  }
+  const runtime = runtimeFromLocals(locals);
+  const bucket = resolveCloudflareR2Bucket(runtime, resolvePublishedContentBucketBinding(deployConfig));
+  if (!bucket) {
+    return null;
+  }
+  const defaultTeamId = defaultTeamIdForRuntime(locals);
+  const preview = previewFromLocals(locals);
+  const locator = resolveTeamScopedContentLocator(
+    deployConfig,
+    defaultTeamId,
+    preview?.teamId === defaultTeamId ? preview.previewId : void 0
+  );
+  return createTeamScopedR2OverlayContentRuntimeProvider({
+    bucket,
+    locator
+  });
+}
+async function loadHostedBookRuntime(locals) {
+  const provider = resolveHostedContentRuntimeProvider(locals);
+  if (!provider) {
+    return null;
+  }
+  const manifest = await provider.getManifest();
+  const pointer = manifest.runtime?.booksRuntime;
+  if (!pointer) {
+    return null;
+  }
+  return provider.getObject(pointer);
+}
+export {
+  loadHostedBookRuntime,
+  resolveHostedContentRuntimeProvider
+};

package/dist/utils/site-models.d.ts

@@ -0,0 +1,6 @@
+import type { TreeseedContentCollection, TreeseedTenantConfig } from '@treeseed/sdk/platform/contracts';
+export declare function isSiteRenderedModel(tenantConfig: Pick<TreeseedTenantConfig, 'features' | 'site'>, modelName: TreeseedContentCollection): boolean;
+export declare function filterSiteRenderedModels<T extends {
+    model: TreeseedContentCollection;
+}>(tenantConfig: Pick<TreeseedTenantConfig, 'features' | 'site'>, entries: T[]): T[];
+export declare function siteModelRendered(modelName: TreeseedContentCollection): boolean;

package/dist/utils/site-models.js

@@ -0,0 +1,16 @@
+import { tenantModelRendered } from "@treeseed/sdk/platform/tenant-config";
+import { RUNTIME_TENANT } from "../tenant/runtime-config.js";
+function isSiteRenderedModel(tenantConfig, modelName) {
+  return tenantModelRendered(tenantConfig, modelName);
+}
+function filterSiteRenderedModels(tenantConfig, entries) {
+  return entries.filter((entry) => isSiteRenderedModel(tenantConfig, entry.model));
+}
+function siteModelRendered(modelName) {
+  return isSiteRenderedModel(RUNTIME_TENANT, modelName);
+}
+export {
+  filterSiteRenderedModels,
+  isSiteRenderedModel,
+  siteModelRendered
+};

package/dist/utils/starlight-nav.js

@@ -5,6 +5,39 @@ import {
   TREESEED_LINKS
 } from "@treeseed/sdk/platform/books-data";
 const normalizeHref = (href) => href.endsWith("/") ? href : `${href}/`;
+function buildSidebarLink(href, label, currentPath) {
+  return {
+    type: "link",
+    label,
+    href,
+    isCurrent: normalizeHref(href) === normalizeHref(currentPath),
+    badge: void 0,
+    attrs: {}
+  };
+}
+function buildSidebarEntries(items, currentPath) {
+  return items.map((item) => {
+    if (item.items?.length) {
+      return {
+        type: "group",
+        label: item.label,
+        entries: buildSidebarEntries(item.items, currentPath),
+        collapsed: false,
+        badge: void 0
+      };
+    }
+    if (item.link) {
+      return buildSidebarLink(item.link, item.label, currentPath);
+    }
+    return {
+      type: "group",
+      label: item.label,
+      entries: [],
+      collapsed: false,
+      badge: void 0
+    };
+  });
+}
 function buildBookSidebarFromRuntime(runtime2, bookSlug) {
   const book = runtime2.BOOKS.find((candidate) => candidate.slug === bookSlug);
   if (!book) {
@@ -18,6 +51,18 @@ function buildBookSidebarFromRuntime(runtime2, bookSlug) {
 function getStarlightSidebarConfigFromRuntime(runtime2) {
   return [runtime2.BOOKS_LINK, ...runtime2.BOOKS.map((book) => buildBookSidebarFromRuntime(runtime2, book.slug))];
 }
+function buildStarlightSidebarEntriesFromRuntime(runtime2, currentPath = runtime2.TREESEED_LINKS.home) {
+  return [
+    buildSidebarLink(String(runtime2.BOOKS_LINK.link ?? runtime2.TREESEED_LINKS.home), String(runtime2.BOOKS_LINK.label ?? "Books"), currentPath),
+    ...runtime2.BOOKS.map((book) => ({
+      type: "group",
+      label: book.sectionLabel,
+      entries: buildSidebarEntries(book.sidebarItems, currentPath),
+      collapsed: false,
+      badge: void 0
+    }))
+  ];
+}
 function getBookForPathFromRuntime(runtime2, pathname) {
   const normalizedPath = normalizeHref(pathname);
   return runtime2.BOOKS.find((book) => normalizedPath.startsWith(normalizeHref(book.basePath)));
@@ -44,6 +89,9 @@ function buildBookSidebar(bookSlug) {
 function getStarlightSidebarConfig() {
   return getStarlightSidebarConfigFromRuntime(runtime);
 }
+function getStarlightSidebarEntries(currentPath) {
+  return buildStarlightSidebarEntriesFromRuntime(runtime, currentPath);
+}
 function getBookForPath(pathname) {
   return getBookForPathFromRuntime(runtime, pathname);
 }
@@ -57,11 +105,13 @@ export {
   TREESEED_LINKS,
   buildBookSidebar,
   buildBookSidebarFromRuntime,
+  buildStarlightSidebarEntriesFromRuntime,
   getBookForPath,
   getBookForPathFromRuntime,
   getDocsDownloadForPath,
   getDocsDownloadForPathFromRuntime,
   getStarlightSidebarConfig,
   getStarlightSidebarConfigFromRuntime,
+  getStarlightSidebarEntries,
   normalizeHref
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/core",
-  "version": "0.4.9",
+  "version": "0.4.11",
   "description": "Treeseed integrated platform starter for Astro/Starlight web runtimes and Hono API runtimes.",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -42,6 +42,8 @@
     "dev:api": "node ./scripts/run-ts.mjs ./scripts/dev-platform.ts --surface api",
     "dev:manager": "node ./scripts/run-ts.mjs ./src/services/manager.ts",
     "dev:worker": "node ./scripts/run-ts.mjs ./src/services/worker.ts",
+    "dev:agents": "node ./scripts/run-ts.mjs ./src/services/agents.ts",
+    "dev:remote-runner": "node ./scripts/run-ts.mjs ./src/services/remote-runner.ts",
     "dev:workday-start": "node ./scripts/run-ts.mjs ./src/services/workday-start.ts",
     "dev:workday-report": "node ./scripts/run-ts.mjs ./src/services/workday-report.ts",
     "dev:watch": "node ./scripts/run-ts.mjs ./scripts/dev-platform.ts --watch",
@@ -67,7 +69,7 @@
     "release:publish": "node ./scripts/run-ts.mjs ./scripts/publish-package.ts"
   },
   "dependencies": {
-    "@treeseed/sdk": "^0.4.8",
+    "@treeseed/sdk": "^0.4.11",
     "@astrojs/check": "^0.9.8",
     "@astrojs/cloudflare": "^12.6.13",
     "@astrojs/sitemap": "3.7.0",
@@ -156,16 +158,32 @@
       "types": "./dist/content-config.d.ts",
       "default": "./dist/content-config.js"
     },
+    "./templates": {
+      "types": "./dist/templates.d.ts",
+      "default": "./dist/templates.js"
+    },
+    "./middleware/editorial-preview": {
+      "types": "./dist/middleware/editorial-preview.d.ts",
+      "default": "./dist/middleware/editorial-preview.js"
+    },
     "./tenant": "./dist/tenant/bridge.js",
     "./scripts/dev-platform": "./dist/scripts/dev-platform.js",
     "./scripts/workspace-bootstrap": "./dist/scripts/workspace-bootstrap.js",
+    "./services/worker": {
+      "types": "./dist/services/worker.d.ts",
+      "default": "./dist/services/worker.js"
+    },
     "./services/manager": {
       "types": "./dist/services/manager.d.ts",
       "default": "./dist/services/manager.js"
     },
-    "./services/worker": {
-      "types": "./dist/services/worker.d.ts",
-      "default": "./dist/services/worker.js"
+    "./services/agents": {
+      "types": "./dist/services/agents.d.ts",
+      "default": "./dist/services/agents.js"
+    },
+    "./services/remote-runner": {
+      "types": "./dist/services/remote-runner.d.ts",
+      "default": "./dist/services/remote-runner.js"
     },
     "./services/workday-start": {
       "types": "./dist/services/workday-start.d.ts",
@@ -179,10 +197,6 @@
       "types": "./dist/api/app.d.ts",
       "default": "./dist/api/app.js"
     },
-    "./api/gateway": {
-      "types": "./dist/api/gateway.d.ts",
-      "default": "./dist/api/gateway.js"
-    },
     "./site-resources": {
       "types": "./dist/site-resources.d.ts",
       "default": "./dist/site-resources.js"