@agent-native/core 0.85.7 → 0.86.1

package/corpus/templates/slides/server/handlers/decks.ts

@@ -43,18 +43,46 @@ if (!globalRef[GLOBAL_KEY]) {
 }
 const sseClients: Set<SSEPush> = globalRef[GLOBAL_KEY]!;
 
+/**
+ * Options for a deck-change broadcast. All fields are optional and additive so
+ * existing consumers that only read `{ type, deckId }` keep working.
+ */
+export interface NotifyClientsOptions {
+  /** SSE event type — defaults to "deck-changed". */
+  type?: string;
+  /** The specific slide that changed, when known (agent slide edits). */
+  slideId?: string;
+  /** Who made the change: "agent" for AI writes, "human" otherwise. */
+  actor?: "agent" | "human";
+}
+
 /**
  * Broadcast a deck change to all connected UI clients. Exported so agent
  * actions (add-slide, update-slide, create-deck) can notify the frontend
  * after a direct DB write — otherwise the UI has no way to know the deck
  * was modified until the next 3-second poll, and won't notice content
  * changes to slides inside an existing deck at all.
+ *
+ * The second argument accepts either a legacy `type` string (backwards compat
+ * with callers like `notifyClients(id, "deck-deleted")`) or an options object
+ * carrying `slideId` / `actor` so the client can attribute agent edits to a
+ * specific slide. The wire payload always includes `type` and `deckId`; extra
+ * fields are only present when supplied.
  */
-export function notifyClients(deckId: string, type = "deck-changed") {
-  const message = JSON.stringify({ type, deckId });
+export function notifyClients(
+  deckId: string,
+  typeOrOptions: string | NotifyClientsOptions = "deck-changed",
+) {
+  const options: NotifyClientsOptions =
+    typeof typeOrOptions === "string" ? { type: typeOrOptions } : typeOrOptions;
+  const type = options.type ?? "deck-changed";
+  const payload: Record<string, unknown> = { type, deckId };
+  if (options.slideId) payload.slideId = options.slideId;
+  if (options.actor) payload.actor = options.actor;
+  const message = JSON.stringify(payload);
   if (process.env.DEBUG_SLIDES_SSE) {
     console.log(
-      `[slides-sse] notifyClients deck=${deckId} type=${type} clients=${sseClients.size}`,
+      `[slides-sse] notifyClients deck=${deckId} type=${type} slide=${options.slideId ?? "-"} actor=${options.actor ?? "-"} clients=${sseClients.size}`,
     );
   }
   for (const push of sseClients) {

package/corpus/templates/slides/server/lib/builder-design-system-proxy.ts

@@ -1,91 +1,13 @@
+import {
+  createBuilderDesignSystemProxyFields,
+  localBuilderDesignSystemId,
+  type BuilderDesignSystemIndexResult,
+} from "@agent-native/core/server";
 import { eq } from "drizzle-orm";
 import { nanoid } from "nanoid";
 
 import { getDb, schema } from "../db/index.js";
 
-type BuilderDesignSystemIndexResult = {
-  designSystemId: string;
-  jobId: string;
-  builderUrl: string;
-};
-
-function localBuilderDesignSystemId(builderDesignSystemId: string): string {
-  const slug = builderDesignSystemId
-    .replace(/[^a-zA-Z0-9_-]+/g, "-")
-    .replace(/^-+|-+$/g, "")
-    .slice(0, 96);
-  return `builder-${slug || "design-system"}`;
-}
-
-function builderProxyData({
-  builderDesignSystemId,
-  jobId,
-  builderUrl,
-  projectName,
-  description,
-}: {
-  builderDesignSystemId: string;
-  jobId: string;
-  builderUrl: string;
-  projectName?: string;
-  description?: string;
-}) {
-  return JSON.stringify({
-    source: "builder",
-    builderDesignSystemId,
-    builderJobId: jobId,
-    builderUrl,
-    colors: {
-      primary: "var(--primary)",
-      secondary: "var(--secondary)",
-      accent: "var(--accent)",
-      background: "var(--background)",
-      surface: "var(--card)",
-      text: "var(--foreground)",
-      textMuted: "var(--muted-foreground)",
-    },
-    typography: {
-      headingFont: "inherit",
-      bodyFont: "inherit",
-      headingWeight: "700",
-      bodyWeight: "400",
-      headingSizes: { h1: "48px", h2: "32px", h3: "24px" },
-    },
-    spacing: { elementGap: "24px", slidePadding: "48px" },
-    borders: { radius: "12px", accentWidth: "1px" },
-    logos: [],
-    notes: [
-      "This is a local proxy for a Builder-indexed design system.",
-      `Builder design system id: ${builderDesignSystemId}`,
-      `Builder indexing job id: ${jobId}`,
-      `Builder URL: ${builderUrl}`,
-      projectName ? `Requested name: ${projectName}` : "",
-      description ? `Context: ${description}` : "",
-      "Use Builder as the source of truth for extracted tokens and guidance.",
-    ]
-      .filter(Boolean)
-      .join("\n"),
-  });
-}
-
-function builderProxyInstructions({
-  builderDesignSystemId,
-  jobId,
-  builderUrl,
-}: {
-  builderDesignSystemId: string;
-  jobId: string;
-  builderUrl: string;
-}) {
-  return [
-    "This design system is indexed and owned by Builder.",
-    `Builder design system id: ${builderDesignSystemId}`,
-    `Builder job id: ${jobId}`,
-    `Builder URL: ${builderUrl}`,
-    "When generating slides, treat Builder as the source of truth for the final extracted tokens, assets, and guidance.",
-  ].join("\n");
-}
-
 export async function upsertBuilderProxyDesignSystem({
   result,
   ownerEmail,
@@ -104,18 +26,11 @@ export async function upsertBuilderProxyDesignSystem({
   const baseLocalDesignSystemId = localBuilderDesignSystemId(
     result.designSystemId,
   );
-  const title = projectName?.trim() || "Builder indexed design system";
-  const localData = builderProxyData({
-    builderDesignSystemId: result.designSystemId,
-    jobId: result.jobId,
-    builderUrl: result.builderUrl,
+  const proxyFields = createBuilderDesignSystemProxyFields({
+    result,
     projectName,
     description,
-  });
-  const customInstructions = builderProxyInstructions({
-    builderDesignSystemId: result.designSystemId,
-    jobId: result.jobId,
-    builderUrl: result.builderUrl,
+    surface: "slides",
   });
   const [existing] = await db
     .select({
@@ -133,13 +48,11 @@ export async function upsertBuilderProxyDesignSystem({
     await db
       .update(schema.designSystems)
       .set({
-        title,
-        description:
-          description ??
-          `Builder indexed design system ${result.designSystemId}`,
-        data: localData,
+        title: proxyFields.title,
+        description: proxyFields.description,
+        data: proxyFields.data,
         assets: "[]",
-        customInstructions,
+        customInstructions: proxyFields.customInstructions,
         updatedAt: now,
       })
       .where(eq(schema.designSystems.id, existing.id));
@@ -151,12 +64,11 @@ export async function upsertBuilderProxyDesignSystem({
       .limit(1);
     await db.insert(schema.designSystems).values({
       id: localDesignSystemId,
-      title,
-      description:
-        description ?? `Builder indexed design system ${result.designSystemId}`,
-      data: localData,
+      title: proxyFields.title,
+      description: proxyFields.description,
+      data: proxyFields.data,
       assets: "[]",
-      customInstructions,
+      customInstructions: proxyFields.customInstructions,
       isDefault: !ownedSystem,
       ownerEmail,
       orgId: orgId ?? null,

package/corpus/templates/slides/server/plugins/db.ts

@@ -1,6 +1,37 @@
-import { runMigrations } from "@agent-native/core/db";
+import {
+  ensureAdditiveColumns,
+  getDbExec,
+  runMigrations,
+} from "@agent-native/core/db";
 
-export default runMigrations(
+// Side-effect import: ensures registerShareableResource runs on server
+// startup so the deck / design-system share actions know where to dispatch.
+import "../db/index.js";
+import * as schema from "../db/schema.js";
+
+/**
+ * Every Drizzle table exported from schema.ts. Filters out type-only and
+ * helper exports the same way db.spec.ts's `isDrizzleTable` regression guard
+ * does: a real table carries a Symbol-keyed drizzle metadata bag, plain
+ * exports don't.
+ */
+function isDrizzleTable(value: unknown): value is object {
+  return (
+    !!value &&
+    typeof value === "object" &&
+    Object.getOwnPropertySymbols(value).some((s) =>
+      s.toString().includes("drizzle"),
+    )
+  );
+}
+
+const schemaTables = Object.values(schema).filter(isDrizzleTable);
+
+// Convention: every new migration below MUST set a unique `name:` slug (see
+// packages/core/src/db/migrations.ts for the full rationale). Version numbers
+// alone are not a safe identity across parallel branches that each extend
+// this list independently.
+const runSlidesMigrations = runMigrations(
   [
     {
       version: 1,
@@ -180,3 +211,35 @@ export default runMigrations(
   ],
   { table: "slides_migrations" },
 );
+
+/**
+ * The migration list above is the authoritative source for tables, indexes,
+ * and data transforms. `ensureAdditiveColumns` runs after it as a
+ * belt-and-braces safety net for the failure mode where a column is added to
+ * schema.ts without a matching hand-written ALTER migration, which silently
+ * 500s every query touching a pre-existing production table. It only ever
+ * adds missing columns — never drops, renames, or retypes anything — and any
+ * failure here is logged and swallowed so it can never fail boot.
+ */
+export default async (nitroApp: any): Promise<void> => {
+  await runSlidesMigrations(nitroApp);
+  try {
+    const summary = await ensureAdditiveColumns({
+      db: getDbExec(),
+      tables: schemaTables,
+    });
+    if (summary.errors.length > 0) {
+      console.warn(
+        "[db] ensureAdditiveColumns completed with errors:",
+        summary.errors,
+      );
+    }
+  } catch (err) {
+    // Never fail boot over the safety net itself — the authoritative
+    // migrations above already ran.
+    console.warn(
+      "[db] ensureAdditiveColumns failed (non-fatal):",
+      err instanceof Error ? err.message : err,
+    );
+  }
+};

package/corpus/templates/videos/netlify.toml

@@ -1,17 +1,6 @@
 [build]
-ignore = "node ./scripts/netlify-ignore-build.mjs videos"
-command = "export DATABASE_URL=${NETLIFY_DATABASE_URL:-$DATABASE_URL} && pnpm install && NITRO_PRESET=netlify pnpm --filter videos build"
+command = "pnpm install && pnpm exec tsx scripts/build-retired-netlify-site.ts videos"
 publish = "templates/videos/dist"
-functions = "templates/videos/.netlify/functions-internal"
 
 [build.environment]
-GA_MEASUREMENT_ID = "G-ESF7FYXGN9"
-NITRO_PRESET = "netlify"
 NPM_CONFIG_PRODUCTION = "false"
-
-# A2A delegation calls run a full agent loop (LLM + tool calls + DB queries).
-# The framework does not impose a default agent-run timeout; if a template sets
-# AGENT_RUN_SOFT_TIMEOUT_MS, keep it below this function timeout so the hidden
-# auto-continuation path can hand off before Netlify kills the function.
-[functions."*"]
-timeout = 75

package/dist/agent/run-store.js

@@ -381,7 +381,7 @@ export async function insertRun(id, threadId, turnId, options) {
     const client = getDbExec();
     const now = Date.now();
     await client.execute({
-        sql: `INSERT INTO agent_runs (id, thread_id, status, started_at, heartbeat_at, last_progress_at, turn_id, dispatch_mode, dispatch_payload) VALUES (?, ?, 'running', ?, ?, ?, ?, ?, ?)`,
+        sql: `INSERT INTO agent_runs (id, thread_id, status, started_at, heartbeat_at, last_progress_at, turn_id, dispatch_mode, dispatch_payload) VALUES (?, ?, 'running', ?, ?, ?, ?, ?, ?) ON CONFLICT (id) DO NOTHING`,
         args: [
             id,
             threadId,