@agent-native/core 0.114.15 → 0.115.1

package/corpus/core/src/dashboard-storage/schema.ts

@@ -0,0 +1,62 @@
+import {
+  createSharesTable,
+  index,
+  now,
+  ownableColumns,
+  table,
+  text,
+} from "../db/schema.js";
+
+export interface DashboardStorageSchemaOptions {
+  dashboardsTable?: string;
+  revisionsTable?: string;
+  sharesTable?: string;
+}
+
+export function createDashboardStorageSchema(
+  options: DashboardStorageSchemaOptions = {},
+) {
+  const dashboardsTable = options.dashboardsTable ?? "dashboards";
+  const revisionsTable = options.revisionsTable ?? "dashboard_revisions";
+  const sharesTable = options.sharesTable ?? "dashboard_shares";
+
+  const dashboards = table(dashboardsTable, {
+    id: text("id").primaryKey(),
+    kind: text("kind").notNull(),
+    title: text("title").notNull().default("Untitled"),
+    config: text("config").notNull(),
+    createdAt: text("created_at").notNull().default(now()),
+    updatedAt: text("updated_at").notNull().default(now()),
+    updatedBy: text("updated_by"),
+    archivedAt: text("archived_at"),
+    ...ownableColumns(),
+  });
+
+  const dashboardShares = createSharesTable(sharesTable);
+
+  const dashboardRevisions = table(
+    revisionsTable,
+    {
+      id: text("id").primaryKey(),
+      dashboardId: text("dashboard_id").notNull(),
+      kind: text("kind").notNull(),
+      title: text("title").notNull(),
+      config: text("config").notNull(),
+      createdAt: text("created_at").notNull().default(now()),
+      createdBy: text("created_by"),
+      ...ownableColumns(),
+    },
+    (revision) => ({
+      dashboardCreatedIdx: index(`${revisionsTable}_dashboard_created_idx`).on(
+        revision.dashboardId,
+        revision.createdAt,
+      ),
+    }),
+  );
+
+  return { dashboards, dashboardRevisions, dashboardShares };
+}
+
+export type DashboardStorageSchema = ReturnType<
+  typeof createDashboardStorageSchema
+>;

package/corpus/core/src/dashboard-storage/store.ts

@@ -0,0 +1,333 @@
+import { randomUUID } from "node:crypto";
+
+import { and, desc, eq, inArray, isNotNull, isNull } from "drizzle-orm";
+
+import type { AccessContext } from "../sharing/access.js";
+import { accessFilter, assertAccess } from "../sharing/access.js";
+import { registerShareableResource } from "../sharing/registry.js";
+import type { DashboardStorageSchema } from "./schema.js";
+
+export interface DashboardRecord<
+  TKind extends string = string,
+  TConfig = Record<string, unknown>,
+> {
+  id: string;
+  kind: TKind;
+  title: string;
+  config: TConfig;
+  ownerEmail: string;
+  orgId: string | null;
+  visibility: "private" | "org" | "public";
+  createdAt: string;
+  updatedAt: string;
+  updatedBy: string | null;
+  archivedAt: string | null;
+}
+
+export interface DashboardRevisionRecord<
+  TKind extends string = string,
+  TConfig = Record<string, unknown>,
+> {
+  id: string;
+  dashboardId: string;
+  kind: TKind;
+  title: string;
+  config: TConfig;
+  createdAt: string;
+  createdBy: string | null;
+}
+
+export interface DashboardWriteInput<
+  TKind extends string = string,
+  TConfig = Record<string, unknown>,
+> {
+  id: string;
+  kind: TKind;
+  title: string;
+  config: TConfig;
+  expectedUpdatedAt?: string;
+}
+
+export class DashboardStorageConflictError extends Error {
+  constructor(id: string) {
+    super(`Dashboard "${id}" changed between read and write.`);
+    this.name = "DashboardStorageConflictError";
+  }
+}
+
+export interface DashboardStorageOptions<TKind extends string, TConfig> {
+  schema: DashboardStorageSchema;
+  getDb: () => any;
+  resourceType: string;
+  displayName?: string;
+  maxRevisions?: number;
+  validateKind?: (kind: string) => kind is TKind;
+  parseConfig?: (raw: string) => TConfig;
+  serializeConfig?: (config: TConfig) => string;
+  getResourcePath?: (dashboard: { id: string }) => string;
+  allowPublic?: boolean;
+  requireOrgMemberForUserShares?: boolean;
+  onChange?: (event: {
+    type: "change" | "delete";
+    dashboard: DashboardRecord<TKind, TConfig>;
+  }) => void;
+}
+
+function affectedRowCount(result: unknown): number | undefined {
+  if (!result || typeof result !== "object") return undefined;
+  const candidate = result as Record<string, unknown>;
+  for (const key of ["rowCount", "rowsAffected", "changes"]) {
+    const value = candidate[key];
+    if (typeof value === "number") return value;
+  }
+  return undefined;
+}
+
+function requireWriter(ctx: AccessContext): string {
+  const email = ctx.userEmail?.trim().toLowerCase();
+  if (!email)
+    throw new Error("Dashboard writes require an authenticated user.");
+  return email;
+}
+
+export function createDashboardStorage<
+  TKind extends string = string,
+  TConfig = Record<string, unknown>,
+>(options: DashboardStorageOptions<TKind, TConfig>) {
+  const parseConfig =
+    options.parseConfig ?? ((raw: string) => JSON.parse(raw) as TConfig);
+  const serializeConfig = options.serializeConfig ?? JSON.stringify;
+  const maxRevisions = Math.max(1, options.maxRevisions ?? 50);
+  const { dashboards, dashboardRevisions, dashboardShares } = options.schema;
+
+  function recordFromRow(row: any): DashboardRecord<TKind, TConfig> {
+    if (options.validateKind && !options.validateKind(row.kind)) {
+      throw new Error(`Unsupported dashboard kind: ${String(row.kind)}`);
+    }
+    return {
+      id: row.id,
+      kind: row.kind as TKind,
+      title: row.title,
+      config: parseConfig(row.config),
+      ownerEmail: row.ownerEmail,
+      orgId: row.orgId ?? null,
+      visibility: row.visibility,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+      updatedBy: row.updatedBy ?? null,
+      archivedAt: row.archivedAt ?? null,
+    };
+  }
+
+  function revisionFromRow(row: any): DashboardRevisionRecord<TKind, TConfig> {
+    return {
+      id: row.id,
+      dashboardId: row.dashboardId,
+      kind: row.kind as TKind,
+      title: row.title,
+      config: parseConfig(row.config),
+      createdAt: row.createdAt,
+      createdBy: row.createdBy ?? null,
+    };
+  }
+
+  async function get(id: string, ctx: AccessContext) {
+    const [row] = await options
+      .getDb()
+      .select()
+      .from(dashboards)
+      .where(
+        and(
+          eq(dashboards.id, id),
+          accessFilter(dashboards, dashboardShares, ctx),
+        ),
+      )
+      .limit(1);
+    return row ? recordFromRow(row) : null;
+  }
+
+  async function list(
+    ctx: AccessContext,
+    archive: "active" | "archived" | "all" = "active",
+  ) {
+    const archiveClause =
+      archive === "active"
+        ? isNull(dashboards.archivedAt)
+        : archive === "archived"
+          ? and(
+              accessFilter(dashboards, dashboardShares, ctx),
+              isNotNull(dashboards.archivedAt),
+            )
+          : undefined;
+    const scope = accessFilter(dashboards, dashboardShares, ctx);
+    const where = archiveClause
+      ? archive === "archived"
+        ? archiveClause
+        : and(scope, archiveClause)
+      : scope;
+    const rows = await options
+      .getDb()
+      .select()
+      .from(dashboards)
+      .where(where)
+      .orderBy(desc(dashboards.updatedAt));
+    return rows.map(recordFromRow);
+  }
+
+  async function pruneRevisions(db: any, dashboardId: string) {
+    const rows = await db
+      .select({ id: dashboardRevisions.id })
+      .from(dashboardRevisions)
+      .where(eq(dashboardRevisions.dashboardId, dashboardId))
+      .orderBy(desc(dashboardRevisions.createdAt));
+    const staleIds = rows
+      .slice(maxRevisions)
+      .map((row: { id: string }) => row.id);
+    if (staleIds.length > 0) {
+      await db
+        .delete(dashboardRevisions)
+        .where(inArray(dashboardRevisions.id, staleIds));
+    }
+  }
+
+  async function snapshot(
+    db: any,
+    dashboard: DashboardRecord<TKind, TConfig>,
+    writer: string,
+  ) {
+    await db.insert(dashboardRevisions).values({
+      id: `dashboard-revision-${randomUUID()}`,
+      dashboardId: dashboard.id,
+      kind: dashboard.kind,
+      title: dashboard.title,
+      config: serializeConfig(dashboard.config),
+      createdBy: writer,
+      ownerEmail: dashboard.ownerEmail,
+      orgId: dashboard.orgId,
+      visibility: dashboard.visibility,
+    });
+    await pruneRevisions(db, dashboard.id);
+  }
+
+  async function write(
+    input: DashboardWriteInput<TKind, TConfig>,
+    ctx: AccessContext,
+  ) {
+    const writer = requireWriter(ctx);
+    const existing = await get(input.id, ctx);
+    const db = options.getDb();
+    if (!existing) {
+      if (input.expectedUpdatedAt !== undefined) {
+        throw new DashboardStorageConflictError(input.id);
+      }
+      await db.insert(dashboards).values({
+        id: input.id,
+        kind: input.kind,
+        title: input.title,
+        config: serializeConfig(input.config),
+        ownerEmail: writer,
+        orgId: ctx.orgId ?? null,
+        visibility: "private",
+        updatedBy: writer,
+      });
+    } else {
+      await assertAccess(options.resourceType, input.id, "editor", ctx);
+      const values = {
+        kind: input.kind,
+        title: input.title,
+        config: serializeConfig(input.config),
+        updatedAt: new Date().toISOString(),
+        updatedBy: writer,
+      };
+      await db.transaction(async (tx: any) => {
+        if (input.expectedUpdatedAt !== undefined) {
+          const result = await tx
+            .update(dashboards)
+            .set(values)
+            .where(
+              and(
+                eq(dashboards.id, input.id),
+                eq(dashboards.updatedAt, input.expectedUpdatedAt),
+              ),
+            );
+          const affected = affectedRowCount(result);
+          if (affected === undefined) {
+            throw new Error(
+              "Dashboard storage requires affected-row counts for conditional writes.",
+            );
+          }
+          if (affected === 0) throw new DashboardStorageConflictError(input.id);
+        } else {
+          await tx
+            .update(dashboards)
+            .set(values)
+            .where(eq(dashboards.id, input.id));
+        }
+        await snapshot(tx, existing, writer);
+      });
+    }
+    const stored = await get(input.id, ctx);
+    if (!stored) throw new Error(`Dashboard "${input.id}" was not persisted.`);
+    options.onChange?.({ type: "change", dashboard: stored });
+    return stored;
+  }
+
+  async function listRevisions(id: string, ctx: AccessContext) {
+    const dashboard = await get(id, ctx);
+    if (!dashboard) return [];
+    await assertAccess(options.resourceType, id, "viewer", ctx);
+    const rows = await options
+      .getDb()
+      .select()
+      .from(dashboardRevisions)
+      .where(eq(dashboardRevisions.dashboardId, id))
+      .orderBy(desc(dashboardRevisions.createdAt))
+      .limit(maxRevisions);
+    return rows.map(revisionFromRow);
+  }
+
+  async function restore(id: string, revisionId: string, ctx: AccessContext) {
+    const existing = await get(id, ctx);
+    if (!existing) return null;
+    await assertAccess(options.resourceType, id, "editor", ctx);
+    const [row] = await options
+      .getDb()
+      .select()
+      .from(dashboardRevisions)
+      .where(
+        and(
+          eq(dashboardRevisions.id, revisionId),
+          eq(dashboardRevisions.dashboardId, id),
+        ),
+      )
+      .limit(1);
+    if (!row) return null;
+    const revision = revisionFromRow(row);
+    return write(
+      {
+        id,
+        kind: revision.kind,
+        title: revision.title,
+        config: revision.config,
+        expectedUpdatedAt: existing.updatedAt,
+      },
+      ctx,
+    );
+  }
+
+  function registerShareable() {
+    registerShareableResource({
+      type: options.resourceType,
+      resourceTable: dashboards,
+      sharesTable: dashboardShares,
+      displayName: options.displayName ?? "Dashboard",
+      titleColumn: "title",
+      getResourcePath: options.getResourcePath,
+      allowPublic: options.allowPublic,
+      requireOrgMemberForUserShares: options.requireOrgMemberForUserShares,
+      getDb: options.getDb,
+    });
+  }
+
+  return { get, list, write, listRevisions, restore, registerShareable };
+}

package/corpus/core/src/deploy/build.ts

@@ -2345,6 +2345,83 @@ export function isDurableBackgroundDeployEnabled(): boolean {
   return v === "1" || v === "true" || v === "yes" || v === "on";
 }
 
+const NETLIFY_KEEP_WARM_FUNCTION_NAME = "agent-native-keep-warm";
+
+/**
+ * Emit a site-local Netlify Scheduled Function that wakes the public server
+ * function and its database every minute. GitHub Actions schedules can be
+ * delayed by tens of minutes, which is longer than a scale-to-zero database's
+ * autosuspend window and leaves the next visitor to pay the cold-start cost.
+ */
+export function emitSingleTemplateNetlifyKeepWarmFunction(
+  projectCwd: string,
+): void {
+  const internalDir = path.join(projectCwd, ".netlify", "functions-internal");
+  const serverBundle = path.join(internalDir, "server", "main.mjs");
+  if (!fs.existsSync(serverBundle)) {
+    console.warn(
+      "[build] Keep-warm emit skipped: expected Nitro Netlify function at " +
+        ".netlify/functions-internal/server/main.mjs was not found.",
+    );
+    return;
+  }
+
+  const dest = path.join(internalDir, NETLIFY_KEEP_WARM_FUNCTION_NAME);
+  fs.rmSync(dest, { recursive: true, force: true });
+  fs.mkdirSync(dest, { recursive: true });
+
+  const entry = `const HEALTH_PATH = "/_agent-native/health";
+const REQUEST_TIMEOUT_MS = 25_000;
+
+function siteOrigin(request) {
+  const configured = process.env.URL || process.env.DEPLOY_URL;
+  if (configured) return configured;
+  return new URL(request.url).origin;
+}
+
+export default async function handler(request) {
+  const url = new URL(HEALTH_PATH, siteOrigin(request));
+  let response;
+  try {
+    response = await fetch(url, {
+      headers: { "user-agent": "agent-native-netlify-keep-warm" },
+      signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+    });
+  } catch (error) {
+    console.error("[agent-native-keep-warm] Health request failed:", url.toString(), error);
+    throw error;
+  }
+
+  if (!response.ok) {
+    const body = await response.text().catch(() => "");
+    throw new Error(
+      "[agent-native-keep-warm] Health request failed with " +
+        response.status +
+        ": " +
+        body.slice(0, 500),
+    );
+  }
+
+  console.log("[agent-native-keep-warm] Warmed", url.toString());
+  return new Response(null, { status: 204 });
+}
+
+export const config = {
+  name: "agent-native server keep warm",
+  generator: "agent-native build",
+  schedule: "* * * * *",
+};
+`;
+
+  fs.writeFileSync(
+    path.join(dest, `${NETLIFY_KEEP_WARM_FUNCTION_NAME}.mjs`),
+    entry,
+  );
+  console.log(
+    `[build] Emitted Netlify scheduled keep-warm function "${NETLIFY_KEEP_WARM_FUNCTION_NAME}".`,
+  );
+}
+
 /**
  * Single-template Netlify build: emit an async (background) function INSIDE the
  * scanned functions dir so the chat `_process-run` worker runs on Netlify's
@@ -3528,24 +3605,26 @@ export default bundle;
     bundleYjsRuntimeForServerlessOutput(nitro.options.output.serverDir, cwd);
   }
 
-  // Durable background agent runs (default-OFF / opt-in; enable with a truthy
-  // AGENT_CHAT_DURABLE_BACKGROUND). Additive ONLY: emits a SECOND Netlify
-  // function whose name ends in `-background` re-exporting the same handler
-  // bundle, so the chat `_process-run` POST lands on Netlify's async (15-min)
-  // function. When not opted in this is a no-op and the single-function
-  // deploy is byte-for-byte unchanged.
-  if (preset === "netlify" && isDurableBackgroundDeployEnabled()) {
-    try {
-      emitSingleTemplateNetlifyBackgroundFunction(cwd);
-    } catch (err) {
-      console.warn(
-        "[build] Failed to emit durable-background Netlify function (non-fatal):",
-        err instanceof Error ? err.message : err,
-      );
+  if (preset === "netlify") {
+    emitSingleTemplateNetlifyKeepWarmFunction(cwd);
+
+    // Durable background agent runs (default-OFF / opt-in; enable with a truthy
+    // AGENT_CHAT_DURABLE_BACKGROUND). Additive ONLY: emits a SECOND Netlify
+    // function whose name ends in `-background` re-exporting the same handler
+    // bundle, so the chat `_process-run` POST lands on Netlify's async (15-min)
+    // function. When not opted in this is a no-op and the single-function
+    // deploy is byte-for-byte unchanged.
+    if (isDurableBackgroundDeployEnabled()) {
+      try {
+        emitSingleTemplateNetlifyBackgroundFunction(cwd);
+      } catch (err) {
+        console.warn(
+          "[build] Failed to emit durable-background Netlify function (non-fatal):",
+          err instanceof Error ? err.message : err,
+        );
+      }
     }
-  }
 
-  if (preset === "netlify") {
     writeSingleTemplateNetlifyRedirects(cwd);
     assertSingleTemplateNetlifyBuildOutput(cwd);
   }

package/corpus/core/src/eject/provider-api-definitions.ts

@@ -44,6 +44,7 @@ export const providerApiOverrides: ProviderApiConfig[] = [
   provider("granola"),
   provider("grafana"),
   provider("hubspot"),
+  provider("salesforce"),
   provider("jira"),
   provider("mixpanel"),
   provider("notion"),

package/corpus/core/src/eject/workspace-connections.ts

@@ -19,6 +19,7 @@ export const WORKSPACE_CONNECTION_PROVIDERS: WorkspaceConnectionProvider[] = [
   "gmail",
   "google_drive",
   "hubspot",
+  "salesforce",
   "jira",
   "sentry",
   "granola",