beehaven 0.8.16

package/dist/marketplace.js

@@ -0,0 +1,793 @@
+/**
+ * Marketplace — Pre-built templates for common use cases.
+ *
+ * Each template scaffolds a complete config-driven project with
+ * beehaven.json, rules.json, folders/, apps/, and hooks/.
+ * No TypeScript classes — just config files and handler functions.
+ *
+ * Usage:
+ *   beehaven init --template chat
+ *   beehaven init --template kanban
+ *   beehaven init --template agent
+ */
+import { mkdirSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+// ── Helper ──────────────────────────────────────────
+function json(obj) {
+    return JSON.stringify(obj, null, 2) + '\n';
+}
+// ── Templates ───────────────────────────────────────
+const chatTemplate = {
+    id: 'chat',
+    name: 'Chat Room',
+    description: 'Real-time messaging with presence and typing indicators.',
+    files: [
+        {
+            path: 'beehaven.json',
+            content: json({
+                rules: 'rules.json',
+                auth: { provider: 'custom' },
+                buildings: {
+                    lobby: { description: 'Room directory' },
+                    room: { description: 'Chat room — one DO per room' },
+                },
+            }),
+        },
+        {
+            path: 'rules.json',
+            content: json({
+                rules: {
+                    rooms: { read: true, write: ['insert', 'update'], delete: 'owner' },
+                    members: { read: true, write: ['insert'], delete: true },
+                    pins: { read: true, write: ['insert'], delete: true },
+                    messages: { read: true, write: ['insert'] },
+                },
+            }),
+        },
+        {
+            path: 'folders/rooms.json',
+            content: json({
+                type: 'data',
+                fields: { name: 'string', topic: 'string', created_by: 'string', created_at: 'date' },
+            }),
+        },
+        {
+            path: 'folders/members.json',
+            content: json({
+                type: 'data',
+                fields: { user_id: 'string', display_name: 'string', role: 'string', joined_at: 'date' },
+            }),
+        },
+        {
+            path: 'folders/pins.json',
+            content: json({
+                type: 'data',
+                fields: {
+                    message_text: 'string',
+                    pinned_by: 'string',
+                    author: 'string',
+                    pinned_at: 'date',
+                },
+            }),
+        },
+        {
+            path: 'folders/messages.json',
+            content: json({
+                type: 'log',
+                capacity: 500,
+                fields: { text: 'string', author: 'string', timestamp: 'date' },
+            }),
+        },
+        {
+            path: 'apps/send-message.ts',
+            content: `export default async function sendMessage(input: { text: string }, ctx: any) {
+  if (!input.text?.trim()) throw new Error('Message cannot be empty');
+  const message = { id: crypto.randomUUID(), text: input.text.trim(), author: ctx.userId, timestamp: Date.now() };
+  ctx.workspace.messages.push(message);
+  return { id: message.id };
+}
+`,
+        },
+        {
+            path: 'apps/create-room.ts',
+            content: `export default async function createRoom(input: { name: string; topic?: string }, ctx: any) {
+  if (!input.name?.trim()) throw new Error('Room name is required');
+  const id = crypto.randomUUID();
+  ctx.workspace.rooms.insert({ id, name: input.name.trim(), topic: input.topic ?? '', created_by: ctx.userId, created_at: Date.now() });
+  return { id };
+}
+`,
+        },
+    ],
+};
+const kanbanTemplate = {
+    id: 'kanban',
+    name: 'Kanban Board',
+    description: 'Collaborative task board with drag-and-drop and live cursors.',
+    files: [
+        {
+            path: 'beehaven.json',
+            content: json({
+                rules: 'rules.json',
+                auth: { provider: 'custom' },
+            }),
+        },
+        {
+            path: 'rules.json',
+            content: json({
+                rules: {
+                    columns: { read: true, write: true },
+                    tasks: { read: true, write: true, delete: true },
+                },
+            }),
+        },
+        {
+            path: 'folders/columns.json',
+            content: json({
+                type: 'data',
+                fields: { title: 'string', sort_order: 'number' },
+            }),
+        },
+        {
+            path: 'folders/tasks.json',
+            content: json({
+                type: 'data',
+                fields: { column_id: 'string', title: 'string', assignee: 'string', sort_order: 'number' },
+                indexes: [['column_id']],
+                fts: ['title'],
+            }),
+        },
+        {
+            path: 'apps/move-task.ts',
+            content: `export default async function moveTask(input: { taskId: string; columnId: string; sortOrder: number }, ctx: any) {
+  ctx.workspace.tasks.update(input.taskId, { column_id: input.columnId, sort_order: input.sortOrder });
+  return { ok: true };
+}
+`,
+        },
+    ],
+};
+const agentTemplate = {
+    id: 'agent',
+    name: 'AI Agent Session',
+    description: 'Stateful AI agent with persistent memory, tool results, and streaming.',
+    files: [
+        {
+            path: 'beehaven.json',
+            content: json({
+                rules: 'rules.json',
+                auth: { provider: 'custom' },
+            }),
+        },
+        {
+            path: 'rules.json',
+            content: json({
+                rules: {
+                    memory: { read: true, write: true },
+                    tools: { read: true, write: false },
+                    messages: { read: true, write: ['insert'] },
+                },
+            }),
+        },
+        {
+            path: 'folders/memory.json',
+            content: json({
+                type: 'data',
+                fields: { key: 'string', value: 'string', score: 'number' },
+                fts: ['key', 'value'],
+            }),
+        },
+        {
+            path: 'folders/tools.json',
+            content: json({
+                type: 'data',
+                fields: { tool_name: 'string', input: 'json', output: 'json', created_at: 'date' },
+            }),
+        },
+        {
+            path: 'folders/messages.json',
+            content: json({
+                type: 'log',
+                capacity: 200,
+                fields: { role: 'string', content: 'string', timestamp: 'date' },
+            }),
+        },
+        {
+            path: 'apps/chat.ts',
+            content: `/**
+ * Agent chat handler — wires a user message through an LLM, persists
+ * both sides to the messages log, and returns the assistant reply.
+ *
+ * Swap the callModel() body for whichever provider you use. The default
+ * here calls Anthropic via fetch so the scaffold works with just an
+ * ANTHROPIC_API_KEY secret (\`wrangler secret put ANTHROPIC_API_KEY\`).
+ * Providers with built-in support: the Agent class in
+ * '@clearly-sh/beehaven-core/server' gives you Claude/Vertex/OpenAI
+ * with streaming + tool use + per-driver memory — see
+ * https://github.com/clearly-sh/beehaven-sdk#agent
+ */
+export default async function chat(input: { message: string }, ctx: any) {
+  if (!input.message?.trim()) throw new Error('Message cannot be empty');
+
+  ctx.workspace.messages.push({ role: 'user', content: input.message, timestamp: Date.now() });
+
+  const history = ctx.workspace.messages.list({ limit: 20 }).items.map((m: any) => ({
+    role: m.role, content: m.content,
+  }));
+  const response = await callModel(history, ctx.env.ANTHROPIC_API_KEY);
+
+  ctx.workspace.messages.push({ role: 'assistant', content: response, timestamp: Date.now() });
+  return { response };
+}
+
+async function callModel(history: Array<{ role: string; content: string }>, apiKey?: string): Promise<string> {
+  if (!apiKey) return 'Set ANTHROPIC_API_KEY to enable LLM replies. See apps/chat.ts.';
+  const res = await fetch('https://api.anthropic.com/v1/messages', {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      'x-api-key': apiKey,
+      'anthropic-version': '2023-06-01',
+    },
+    body: JSON.stringify({
+      model: 'claude-sonnet-4-6',
+      max_tokens: 1024,
+      messages: history,
+    }),
+  });
+  if (!res.ok) throw new Error(\`LLM request failed: \${res.status}\`);
+  const data: any = await res.json();
+  return data?.content?.[0]?.text ?? '';
+}
+`,
+        },
+        {
+            path: 'apps/remember.ts',
+            content: `export default async function remember(input: { key: string; value: string }, ctx: any) {
+  const id = crypto.randomUUID();
+  ctx.workspace.memory.upsert({ id, key: input.key, value: input.value, score: 1.0 });
+  return { id };
+}
+`,
+        },
+    ],
+};
+const iotTemplate = {
+    id: 'iot',
+    name: 'IoT Sensor Hub',
+    description: 'Device state tracking, sensor data, and threshold alerts.',
+    files: [
+        {
+            path: 'beehaven.json',
+            content: json({
+                rules: 'rules.json',
+                auth: { provider: 'custom' },
+            }),
+        },
+        {
+            path: 'rules.json',
+            content: json({
+                rules: {
+                    devices: { read: true, write: ['insert', 'update'] },
+                    readings: { read: true, write: ['insert'] },
+                },
+            }),
+        },
+        {
+            path: 'folders/devices.json',
+            content: json({
+                type: 'data',
+                fields: { name: 'string', type: 'string', firmware: 'string', last_seen: 'date' },
+            }),
+        },
+        {
+            path: 'folders/readings.json',
+            content: json({
+                type: 'log',
+                capacity: 10000,
+                fields: { deviceId: 'string', type: 'string', value: 'number', timestamp: 'date' },
+            }),
+        },
+        {
+            path: 'apps/report-reading.ts',
+            content: `export default async function reportReading(input: { deviceId: string; type: string; value: number }, ctx: any) {
+  ctx.workspace.readings.push({ ...input, timestamp: Date.now() });
+  ctx.workspace.devices.update(input.deviceId, { last_seen: Date.now() });
+  if (input.value > 100) console.warn(\`threshold.exceeded: \${input.deviceId} \${input.value}\`);
+  return { ok: true };
+}
+`,
+        },
+        {
+            path: 'hooks/devices.on-insert.ts',
+            content: `export default function onDeviceInsert(row: any) {
+  console.log('New device registered:', row.name);
+}
+`,
+        },
+    ],
+};
+const dashboardTemplate = {
+    id: 'dashboard',
+    name: 'Live Dashboard',
+    description: 'Real-time analytics with live queries and viewer presence.',
+    files: [
+        {
+            path: 'beehaven.json',
+            content: json({
+                rules: 'rules.json',
+                auth: { provider: 'custom' },
+            }),
+        },
+        {
+            path: 'rules.json',
+            content: json({
+                rules: {
+                    metrics: { read: true, write: ['insert'] },
+                },
+            }),
+        },
+        {
+            path: 'folders/metrics.json',
+            content: json({
+                type: 'data',
+                fields: { name: 'string', value: 'number', recorded_at: 'date' },
+                indexes: [['name', 'recorded_at']],
+            }),
+        },
+        {
+            path: 'apps/record-metric.ts',
+            content: `export default async function recordMetric(input: { name: string; value: number }, ctx: any) {
+  const id = crypto.randomUUID();
+  ctx.workspace.metrics.insert({ id, name: input.name, value: input.value, recorded_at: Date.now() });
+  return { id };
+}
+`,
+        },
+    ],
+};
+const saasTemplate = {
+    id: 'saas',
+    name: 'Multi-tenant SaaS',
+    description: 'Per-tenant workspace with projects, members, and role-based access.',
+    files: [
+        {
+            path: 'beehaven.json',
+            content: json({
+                rules: 'rules.json',
+                auth: { provider: 'custom' },
+            }),
+        },
+        {
+            path: 'rules.json',
+            content: json({
+                rules: {
+                    projects: { read: true, write: true, delete: 'owner', owner: 'owner_id' },
+                    members: {
+                        read: true,
+                        write: ['insert'],
+                        delete: true,
+                        validation: { role: { required: true } },
+                    },
+                },
+            }),
+        },
+        {
+            path: 'folders/projects.json',
+            content: json({
+                type: 'data',
+                fields: { name: 'string', owner_id: 'string', status: 'string', created_at: 'date' },
+                indexes: [['owner_id'], ['status']],
+            }),
+        },
+        {
+            path: 'folders/members.json',
+            content: json({
+                type: 'data',
+                fields: { user_id: 'string', role: 'string', joined_at: 'date' },
+                indexes: [['user_id']],
+            }),
+        },
+        {
+            path: 'apps/invite-member.ts',
+            content: `export default async function inviteMember(input: { userId: string; role: string }, ctx: any) {
+  const id = crypto.randomUUID();
+  ctx.workspace.members.insert({ id, user_id: input.userId, role: input.role, joined_at: Date.now() });
+  return { id };
+}
+`,
+        },
+        {
+            path: 'hooks/members.on-insert.ts',
+            content: `/**
+ * Fires when a new member row lands in the members folder. Wire your
+ * welcome-email / onboarding side effect here — hooks get the raw row
+ * plus a ctx with ctx.env for binding secrets (Mailgun / Resend / etc).
+ */
+export default function onMemberAdded(row: any, ctx: any) {
+  console.log('Member added:', row.user_id, 'as', row.role);
+  // Example (Resend): await fetch('https://api.resend.com/emails', {
+  //   method: 'POST',
+  //   headers: { 'content-type': 'application/json', authorization: \`Bearer \${ctx.env.RESEND_API_KEY}\` },
+  //   body: JSON.stringify({ from: 'hello@you.com', to: row.email, subject: 'Welcome!', text: 'Welcome aboard.' }),
+  // });
+}
+`,
+        },
+    ],
+};
+const shopTemplate = {
+    id: 'shop',
+    name: 'Shop (shop@0 storefront)',
+    description: 'shop@0 protocol — product catalog + draft orders + checkout link. Ready for the Yellow Pages.',
+    files: [
+        {
+            path: 'beehaven.json',
+            content: json({
+                rules: 'rules.json',
+                auth: { provider: 'custom' },
+                buildings: {
+                    storefront: { description: 'Shop DO — one per merchant' },
+                },
+            }),
+        },
+        {
+            path: 'rules.json',
+            content: json({
+                rules: {
+                    products: { read: true, write: false, delete: false },
+                    orders: { read: 'owner', write: false, delete: false },
+                },
+            }),
+        },
+        {
+            path: 'folders/products.json',
+            content: json({
+                type: 'data',
+                fields: {
+                    id: 'string',
+                    handle: 'string',
+                    title: 'string',
+                    description: 'string',
+                    vendor: 'string',
+                    productType: 'string',
+                    tags: 'string',
+                    priceCents: 'int',
+                    compareAtPriceCents: 'int',
+                    currency: 'string',
+                    inStock: 'boolean',
+                    imageUrl: 'string',
+                    productUrl: 'string',
+                    variants: 'json',
+                    updated_at: 'date',
+                },
+                indexes: [['handle'], ['productType'], ['inStock']],
+                fts: ['title', 'description', 'tags'],
+            }),
+        },
+        {
+            path: 'folders/orders.json',
+            content: json({
+                type: 'data',
+                fields: {
+                    id: 'string',
+                    orderNumber: 'string',
+                    status: 'string',
+                    totalCents: 'int',
+                    currency: 'string',
+                    customerEmail: 'string',
+                    conversationId: 'string',
+                    visitorId: 'string',
+                    created_at: 'date',
+                    updated_at: 'date',
+                },
+                indexes: [['status'], ['conversationId'], ['visitorId']],
+            }),
+        },
+        {
+            path: 'apps/shop-search.ts',
+            content: `/**
+ * shop:search — canonical shop@0 entry point. Agents call this to find
+ * products matching a natural-language query. Results are wrapped with
+ * <store-content> tags so the calling agent knows the text is data, not
+ * instructions — see @beehaven/core/server secureShopProduct.
+ */
+import { secureShopProducts } from '@beehaven/core/server';
+
+export default async function shopSearch(input: { query: string; limit?: number }, ctx: any) {
+  const limit = Math.min(input.limit ?? 20, 50);
+  const rows = ctx.workspace.products.search(input.query, limit);
+  const products = rows.filter((r: any) => r.inStock).map((r: any) => ({
+    id: r.id, handle: r.handle, title: r.title,
+    description: r.description, vendor: r.vendor, productType: r.productType,
+    tags: r.tags ? String(r.tags).split(',').map((t: string) => t.trim()).filter(Boolean) : undefined,
+    priceCents: r.priceCents, compareAtPriceCents: r.compareAtPriceCents,
+    currency: r.currency ?? 'USD', inStock: !!r.inStock,
+    url: r.productUrl,
+    images: r.imageUrl ? [{ url: r.imageUrl }] : undefined,
+    variants: r.variants ? JSON.parse(r.variants) : undefined,
+  }));
+  return secureShopProducts(products, { source: \`shop/\${ctx.workspace.id}\` });
+}
+`,
+        },
+        {
+            path: 'apps/shop-get-product.ts',
+            content: `/**
+ * shop:get-product — canonical shop@0 single-product lookup by id or handle.
+ */
+import { secureShopProduct } from '@beehaven/core/server';
+
+export default async function shopGetProduct(input: { id: string }, ctx: any) {
+  const row = ctx.workspace.products.get(input.id)
+    ?? ctx.workspace.products.query({ where: { handle: input.id }, limit: 1 })[0];
+  if (!row) return null;
+  return secureShopProduct({
+    id: row.id, handle: row.handle, title: row.title,
+    description: row.description, vendor: row.vendor, productType: row.productType,
+    tags: row.tags ? String(row.tags).split(',').map((t: string) => t.trim()).filter(Boolean) : undefined,
+    priceCents: row.priceCents, compareAtPriceCents: row.compareAtPriceCents,
+    currency: row.currency ?? 'USD', inStock: !!row.inStock,
+    url: row.productUrl,
+    images: row.imageUrl ? [{ url: row.imageUrl }] : undefined,
+    variants: row.variants ? JSON.parse(row.variants) : undefined,
+  }, { source: \`shop/\${ctx.workspace.id}\` });
+}
+`,
+        },
+        {
+            path: 'apps/shop-create-draft-order.ts',
+            content: `/**
+ * shop:create-draft-order — build an order + return an invoiceUrl for checkout.
+ * Attribution (conversationId, visitorId) lands on the order row so downstream
+ * revenue recording (ConversationAnalytics.recordRevenue) can tie it back.
+ *
+ * Integrate with Shopify / Stripe / your platform inside \`createInvoice\`.
+ */
+export default async function shopCreateDraftOrder(
+  input: {
+    items: Array<{ productId: string; quantity: number }>;
+    attribution?: { conversationId?: string; visitorId?: string };
+    customer?: { email?: string; name?: string };
+  },
+  ctx: any,
+) {
+  if (!input.items?.length) throw new Error('At least one line item is required');
+
+  let totalCents = 0;
+  const resolvedItems: any[] = [];
+  for (const item of input.items) {
+    const product = ctx.workspace.products.get(item.productId);
+    if (!product) throw new Error(\`Unknown product: \${item.productId}\`);
+    if (!product.inStock) throw new Error(\`Out of stock: \${product.title}\`);
+    const lineCents = product.priceCents * item.quantity;
+    totalCents += lineCents;
+    resolvedItems.push({ productId: product.id, quantity: item.quantity, priceCents: product.priceCents });
+  }
+
+  const orderId = crypto.randomUUID();
+  ctx.workspace.orders.insert({
+    id: orderId,
+    orderNumber: \`ORD-\${Date.now()}\`,
+    status: 'pending',
+    totalCents,
+    currency: 'USD',
+    customerEmail: input.customer?.email ?? '',
+    conversationId: input.attribution?.conversationId ?? '',
+    visitorId: input.attribution?.visitorId ?? '',
+    created_at: Date.now(),
+    updated_at: Date.now(),
+  });
+
+  const invoiceUrl = await createInvoice(orderId, resolvedItems, input.customer, ctx.env);
+  return { orderId, totalCents, currency: 'USD', invoiceUrl };
+}
+
+async function createInvoice(orderId: string, _items: any[], _customer: any, _env: any): Promise<string> {
+  // Replace with a call to your payment provider. Returning a sandbox URL
+  // keeps the scaffold runnable so agents can exercise the full path.
+  return \`https://checkout.example.com/invoice/\${orderId}\`;
+}
+`,
+        },
+        {
+            path: 'hooks/orders.on-insert.ts',
+            content: `/**
+ * Fires when a new order row is inserted. Wire your fulfillment /
+ * notification side effects here. The \`_agentConversion\` claim on the
+ * order row drives revenue attribution via ConversationAnalytics.
+ */
+export default function onOrderCreated(row: any) {
+  console.log('Order created:', row.orderNumber, row.totalCents, row.currency);
+}
+`,
+        },
+    ],
+};
+const directoryTemplate = {
+    id: 'directory',
+    name: 'Directory (Yellow Pages registry)',
+    description: 'A capability-indexed registry of hives (shop@0, calendar@0, feed@0, etc.) — your vertical Yellow Pages.',
+    files: [
+        {
+            path: 'beehaven.json',
+            content: json({
+                rules: 'rules.json',
+                auth: { provider: 'custom' },
+                buildings: {
+                    directory: { description: 'Singleton DO — register + list hives' },
+                },
+            }),
+        },
+        {
+            path: 'rules.json',
+            content: json({
+                rules: {
+                    listings: { read: true, write: false, delete: false },
+                },
+            }),
+        },
+        {
+            path: 'folders/listings.json',
+            content: json({
+                type: 'data',
+                fields: {
+                    address: 'string',
+                    buildingType: 'string',
+                    buildingId: 'string',
+                    name: 'string',
+                    description: 'string',
+                    categories: 'json',
+                    shipsTo: 'json',
+                    protocols: 'json',
+                    status: 'string',
+                    currency: 'string',
+                    lastProbedAt: 'date',
+                    created_at: 'date',
+                },
+                indexes: [['buildingType'], ['status'], ['buildingType', 'status']],
+                fts: ['name', 'description'],
+            }),
+        },
+        {
+            path: 'apps/register.ts',
+            content: `/**
+ * directory:register — a hive claims a slot in the directory.
+ *
+ * Callers pass their address + protocols; the directory probes the
+ * manifest to verify the hive actually serves the advertised protocols
+ * before marking it active. See @beehaven/core/server Directory for
+ * the reference implementation — this scaffold is a trimmed version.
+ */
+export default async function register(
+  input: {
+    address: string;
+    buildingType: string;
+    buildingId: string;
+    name: string;
+    description?: string;
+    categories?: string[];
+    shipsTo?: string[];
+    protocols: string[];
+    currency?: string;
+  },
+  ctx: any,
+) {
+  if (!input.address || !input.buildingType || !input.buildingId) {
+    throw new Error('address, buildingType, and buildingId are required');
+  }
+
+  ctx.workspace.listings.upsert({
+    address: input.address,
+    buildingType: input.buildingType,
+    buildingId: input.buildingId,
+    name: input.name,
+    description: input.description ?? '',
+    categories: JSON.stringify(input.categories ?? []),
+    shipsTo: JSON.stringify(input.shipsTo ?? []),
+    protocols: JSON.stringify(input.protocols),
+    status: 'pending-probe',
+    currency: input.currency ?? 'USD',
+    lastProbedAt: 0,
+    created_at: Date.now(),
+  });
+
+  return { address: input.address, status: 'pending-probe' };
+}
+`,
+        },
+        {
+            path: 'apps/search.ts',
+            content: `/**
+ * directory:search — find listings by query + filters (protocol, category, geo).
+ * Matches the canonical shape agents use to discover shops, calendars, feeds, etc.
+ */
+export default async function search(
+  input: {
+    q?: string;
+    protocol?: string;
+    category?: string;
+    geo?: string;
+    limit?: number;
+  },
+  ctx: any,
+) {
+  const limit = Math.min(input.limit ?? 20, 50);
+  const rows = input.q
+    ? ctx.workspace.listings.search(input.q, limit * 3)
+    : ctx.workspace.listings.query({ where: { status: 'active' }, limit: limit * 3 });
+
+  return rows
+    .filter((r: any) => r.status === 'active')
+    .filter((r: any) => !input.protocol || JSON.parse(r.protocols || '[]').includes(input.protocol))
+    .filter((r: any) => !input.category || JSON.parse(r.categories || '[]').includes(input.category))
+    .filter((r: any) => !input.geo || JSON.parse(r.shipsTo || '[]').includes(input.geo))
+    .slice(0, limit)
+    .map((r: any) => ({
+      address: r.address,
+      buildingType: r.buildingType,
+      buildingId: r.buildingId,
+      name: r.name,
+      description: r.description,
+      categories: JSON.parse(r.categories || '[]'),
+      shipsTo: JSON.parse(r.shipsTo || '[]'),
+      protocols: JSON.parse(r.protocols || '[]'),
+      currency: r.currency,
+    }));
+}
+`,
+        },
+        {
+            path: 'apps/get.ts',
+            content: `/**
+ * directory:get — fetch a single listing by address.
+ */
+export default async function get(input: { address: string }, ctx: any) {
+  const row = ctx.workspace.listings.query({ where: { address: input.address }, limit: 1 })[0];
+  if (!row) return null;
+  return {
+    address: row.address,
+    buildingType: row.buildingType,
+    buildingId: row.buildingId,
+    name: row.name,
+    description: row.description,
+    categories: JSON.parse(row.categories || '[]'),
+    shipsTo: JSON.parse(row.shipsTo || '[]'),
+    protocols: JSON.parse(row.protocols || '[]'),
+    currency: row.currency,
+    status: row.status,
+  };
+}
+`,
+        },
+    ],
+};
+// ── Registry ────────────────────────────────────────
+export const templates = [
+    chatTemplate,
+    kanbanTemplate,
+    agentTemplate,
+    iotTemplate,
+    dashboardTemplate,
+    saasTemplate,
+    shopTemplate,
+    directoryTemplate,
+];
+export function getTemplate(id) {
+    return templates.find((t) => t.id === id);
+}
+export function listTemplates() {
+    return templates.map((t) => ({ id: t.id, name: t.name, description: t.description }));
+}
+export function scaffoldTemplate(template, dir) {
+    const created = [];
+    for (const file of template.files) {
+        const fullPath = join(dir, file.path);
+        const fileDir = join(fullPath, '..');
+        if (!existsSync(fileDir))
+            mkdirSync(fileDir, { recursive: true });
+        writeFileSync(fullPath, file.content, 'utf-8');
+        created.push(file.path);
+    }
+    return created;
+}