@agent-native/core 0.123.2 → 0.124.1

package/corpus/README.md

@@ -30,4 +30,4 @@ rg -n "defineAction|useActionQuery" node_modules/@agent-native/core/corpus
 
 - core files: 1735
 - toolkit files: 160
-- template files: 6778
+- template files: 6787

package/corpus/core/CHANGELOG.md

@@ -1,5 +1,33 @@
 # @agent-native/core
 
+## 0.124.1
+
+### Patch Changes
+
+- 661ee71: Register the CRM template in the CLI template catalog.
+
+  `crm` is added to `TEMPLATES` as a **hidden** entry (dev port 8107,
+  `defaultMode: "dev"`), so `agent-native new` can scaffold it by name while it
+  stays out of the public catalog until it is explicitly unhidden. The mirrored
+  list in `@agent-native/shared-app-config` is updated to match.
+
+  Two cross-template specs are widened to cover it: the UI-primitives sync check
+  now includes `crm`, and the page-chat handoff check reads CRM's layout from
+  `app/components/layout/CrmLayout.tsx` and expects `requireActiveHandoff: false`,
+  since CRM's full-page chat lives on its own `/ask` route.
+
+## 0.124.0
+
+### Minor Changes
+
+- e9dd025: `agent-native dev --inspect` (and `--inspect-brk`, optionally `=<port>`) now
+  attaches the Node inspector to **only** the Nitro API-server process, on a
+  single known port (default 9229). It selects Nitro's `node-process` dev runner
+  so the server is a real, attachable process, and injects `NODE_OPTIONS` through
+  a Vite preload that runs before Vite's own startup — so Vite, pnpm, and the CLI
+  are never inspected and there is exactly one debugger target. Set
+  `NITRO_DEV_RUNNER` yourself to override the runner.
+
 ## 0.123.2
 
 ### Patch Changes

package/corpus/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-native/core",
-  "version": "0.123.2",
+  "version": "0.124.1",
   "description": "Framework for agent-native application development — where AI agents and UI share SQL state, actions, and context",
   "homepage": "https://github.com/BuilderIO/agent-native#readme",
   "bugs": {

package/corpus/templates/analytics/server/lib/dashboard-report-render.ts

@@ -931,14 +931,17 @@ async function renderChartBlock(args: {
   }
   const subtitle = subtitleParts.join(" · ");
 
-  const alt = `${panel.title}: ${chartType} chart of ${input.series
+  // The card heading directly above already names the panel; repeating it here
+  // would read twice in a client that blocks images.
+  const alt = `${chartType} chart of ${input.series
     .map((series) => series.label)
     .join(", ")}`;
 
   try {
+    // Title and description stay in the surrounding HTML card: text there is
+    // selectable, wraps instead of truncating, and cannot be duplicated by the
+    // image beneath it.
     const svg = renderReportChartSvg({
-      title: panel.title,
-      ...(subtitle ? { subtitle } : {}),
       labels: input.labels,
       series: input.series,
       type: chartType,

package/corpus/templates/analytics/server/lib/report-chart-svg.ts

@@ -218,17 +218,26 @@ function renderChartHeader({
       ? wrapToWidth(subtitle, 13, maxWidth, 2)
       : [subtitle];
 
+  // Email cards already render the title and description as HTML, so the report
+  // path passes neither and the header collapses to nothing. Legacy callers
+  // always supply a title, so their output is unchanged.
+  const collapsed = fit && !titleText && subtitleLines.length === 0;
+
   return {
-    titleMarkup: `<text x="${HEADER_INSET}" y="${TITLE_BASELINE}" font-family="${fontFamily}" font-size="22" font-weight="700" fill="${theme.titleColor}">${escapeXml(titleText)}</text>`,
+    titleMarkup: collapsed
+      ? ""
+      : `<text x="${HEADER_INSET}" y="${TITLE_BASELINE}" font-family="${fontFamily}" font-size="22" font-weight="700" fill="${theme.titleColor}">${escapeXml(titleText)}</text>`,
     subtitleMarkup: subtitleLines
       .map(
         (line, index) =>
           `<text x="${HEADER_INSET}" y="${SUBTITLE_BASELINE + index * SUBTITLE_LINE_HEIGHT}" font-family="${fontFamily}" font-size="13" fill="${theme.tickColor}">${escapeXml(line)}</text>`,
       )
       .join(""),
-    headerBottom: subtitleLines.length
-      ? SUBTITLE_BASELINE + (subtitleLines.length - 1) * SUBTITLE_LINE_HEIGHT
-      : TITLE_BASELINE,
+    headerBottom: collapsed
+      ? 0
+      : subtitleLines.length
+        ? SUBTITLE_BASELINE + (subtitleLines.length - 1) * SUBTITLE_LINE_HEIGHT
+        : TITLE_BASELINE,
   };
 }
 
@@ -428,7 +437,11 @@ function renderCartesianChartSvg({
     fontFamily,
     fit,
   });
-  const legendTop = subtitle ? header.headerBottom + 4 : 42;
+  const legendTop = !header.headerBottom
+    ? 18
+    : subtitle
+      ? header.headerBottom + 4
+      : 42;
   // A static image has no tooltip to reveal which scale a series belongs to.
   const legendSeries = dualAxis
     ? series.map((entry) =>

package/corpus/templates/crm/actions/_crm-list-utils.ts

@@ -48,6 +48,7 @@ import {
   ATTRIBUTE_TYPE_SPECS,
   storageColumnFor,
   type CrmAttributeStorageColumn,
+  type CrmAttributeType,
 } from "../shared/crm-attributes.js";
 import type {
   CrmActorType,
@@ -335,6 +336,183 @@ export function indexAttributes(
   return new Map(attributes.map((attribute) => [attribute.apiSlug, attribute]));
 }
 
+// ---------------------------------------------------------------------------
+// Seeding a list from its parent object, and the one-time copy that gives a
+// new entry its first values.
+//
+// A list attribute is the list's OWN field: it is seeded from a record
+// attribute and each entry's first value is copied from the record once, at
+// insert. Nothing re-reads the record afterwards and nothing writes back — that
+// separation is what lets a pipeline run over a HubSpot or Salesforce mirror
+// without a provider write.
+// ---------------------------------------------------------------------------
+
+/** A parent-object attribute a list can seed from. Single-valued only: a
+ * list's stage, amount, and date are single by construction, and a multi
+ * source would not fit the seeded attribute's storage column. */
+export interface CrmObjectAttribute {
+  id: string;
+  apiSlug: string;
+  label: string;
+  attributeType: CrmAttributeType;
+  /** Raw `config_json`, copied verbatim so a currency keeps its code. */
+  configJson: string;
+  position: number;
+}
+
+export async function loadCrmObjectAttributes(
+  db: CrmDb,
+  connectionId: string,
+  objectType: string,
+): Promise<CrmObjectAttribute[]> {
+  const rows = await db
+    .select({
+      id: schema.crmFieldPolicies.id,
+      apiSlug: schema.crmFieldPolicies.apiSlug,
+      fieldName: schema.crmFieldPolicies.fieldName,
+      label: schema.crmFieldPolicies.label,
+      attributeType: schema.crmFieldPolicies.attributeType,
+      configJson: schema.crmFieldPolicies.configJson,
+      position: schema.crmFieldPolicies.position,
+    })
+    .from(schema.crmFieldPolicies)
+    .where(
+      and(
+        eq(schema.crmFieldPolicies.target, "object"),
+        eq(schema.crmFieldPolicies.objectType, objectType),
+        eq(schema.crmFieldPolicies.connectionId, connectionId),
+        eq(schema.crmFieldPolicies.archived, false),
+        eq(schema.crmFieldPolicies.multi, false),
+        accessFilter(schema.crmFieldPolicies, schema.crmFieldPolicyShares),
+      ),
+    )
+    .limit(MAX_LIST_ATTRIBUTES);
+
+  return rows
+    .map((row) => ({
+      id: row.id,
+      // `api_slug` is null on rows written by the adapters, which predate the
+      // typed surface; `field_name` is what their values are keyed by.
+      apiSlug: row.apiSlug ?? row.fieldName,
+      label: row.label,
+      attributeType: row.attributeType,
+      configJson: row.configJson,
+      position: row.position,
+    }))
+    .sort(
+      (a, b) => a.position - b.position || a.apiSlug.localeCompare(b.apiSlug),
+    );
+}
+
+/** What one attribute's initial value did, per entry. `applied: false` is
+ * reported rather than dropped: "the record had no value" and "the record's
+ * value does not fit this list" are different facts about an empty card. */
+export interface CrmEntryInitialValue {
+  attribute: string;
+  /** The record attribute the value was read from. */
+  from: string;
+  applied: boolean;
+  reason?: string;
+}
+
+/**
+ * The values a BRAND-NEW entry starts with, copied once from the record's own
+ * attributes that share the list attribute's slug and type.
+ *
+ * This is a snapshot at insert, not a binding. Nothing reads the record again,
+ * and `update-crm-list-entry` never writes it back, so an entry and its record
+ * diverge from here on — deliberately, because the record may be provider-owned
+ * and a pipeline must never need a provider write.
+ */
+export async function initialCrmEntryValues(input: {
+  db: CrmDb;
+  connectionId: string;
+  record: { id: string; objectType: string };
+  attributes: Map<string, CrmListAttribute>;
+  /** Slugs the caller set explicitly. Neither copied nor reported: a value the
+   * caller chose was not initialized from anything. */
+  supplied?: ReadonlySet<string>;
+}): Promise<{
+  values: Record<string, CrmValue>;
+  initialValues: CrmEntryInitialValue[];
+}> {
+  if (input.attributes.size === 0) return { values: {}, initialValues: [] };
+
+  const sources = (
+    await loadCrmObjectAttributes(
+      input.db,
+      input.connectionId,
+      input.record.objectType,
+    )
+  ).filter((source) => {
+    if (input.supplied?.has(source.apiSlug)) return false;
+    const attribute = input.attributes.get(source.apiSlug);
+    // Same slug is not enough: a text `amount` on the object must not be copied
+    // into a currency `amount` on the list.
+    return (
+      !!attribute &&
+      !attribute.multi &&
+      attribute.attributeType === source.attributeType
+    );
+  });
+  if (sources.length === 0) return { values: {}, initialValues: [] };
+
+  const rows = await input.db
+    .select({
+      fieldName: schema.crmRecordFields.fieldName,
+      stringValue: schema.crmRecordFields.stringValue,
+      numberValue: schema.crmRecordFields.numberValue,
+      booleanValue: schema.crmRecordFields.booleanValue,
+      jsonValue: schema.crmRecordFields.jsonValue,
+    })
+    .from(schema.crmRecordFields)
+    .where(
+      and(
+        eq(schema.crmRecordFields.recordId, input.record.id),
+        // `entry_id IS NULL` is the record-vs-entry discriminator: another
+        // entry's value must never seed this one.
+        isNull(schema.crmRecordFields.entryId),
+        isNull(schema.crmRecordFields.activeUntil),
+        inArray(
+          schema.crmRecordFields.fieldName,
+          sources.map((source) => source.apiSlug),
+        ),
+        accessFilter(schema.crmRecordFields, schema.crmRecordFieldShares),
+      ),
+    );
+
+  const values: Record<string, CrmValue> = {};
+  const initialValues: CrmEntryInitialValue[] = [];
+  for (const row of rows) {
+    const attribute = input.attributes.get(row.fieldName);
+    if (!attribute) continue;
+    const value = decodeCrmAttributeValue(attribute, row);
+    // Nothing to copy is not a failure and is not reported as one.
+    if (value === null) continue;
+    if (ATTRIBUTE_TYPE_SPECS[attribute.attributeType].usesOptions) {
+      const enterable = attribute.options.some(
+        (option) => !option.archived && option.value === value,
+      );
+      if (!enterable) {
+        initialValues.push({
+          attribute: attribute.apiSlug,
+          from: row.fieldName,
+          applied: false,
+          reason: `The record's "${String(value)}" is not a live option of this list's "${attribute.label}". Add the option, or set the entry's value explicitly.`,
+        });
+        continue;
+      }
+    }
+    values[attribute.apiSlug] = value;
+    initialValues.push({
+      attribute: attribute.apiSlug,
+      from: row.fieldName,
+      applied: true,
+    });
+  }
+  return { values, initialValues };
+}
+
 // ---------------------------------------------------------------------------
 // Entry attribute values
 // ---------------------------------------------------------------------------

package/corpus/templates/crm/actions/add-crm-record-to-list.ts

@@ -13,6 +13,7 @@ import {
   CrmListError,
   crmActorFrom,
   indexAttributes,
+  initialCrmEntryValues,
   loadCrmListAttributes,
   requireCrmList,
   writeCrmListEntryValues,
@@ -31,7 +32,7 @@ export const listEntryValuesSchema = z
 
 export default defineAction({
   description:
-    "Add a record to a CRM list as a new entry, with optional starting values for the list's own entry attributes. A record may hold more than one entry in the same list — two open deals for one company are two entries — so this never de-duplicates; it returns existingEntryIds for the caller to decide. The record's objectType must match the list's parentObjectType. The entry is local-authoritative even when the record mirrors HubSpot or Salesforce.",
+    "Add a record to a CRM list as a new entry, with optional starting values for the list's own entry attributes. Any list attribute you do not supply is INITIALIZED from the record's own attribute of the same slug and type — a one-time copy at insert, reported in initialValues, so a new board is populated. It is a copy and not a link: the entry never re-reads the record and editing the entry never writes the record. A record may hold more than one entry in the same list — two open deals for one company are two entries — so this never de-duplicates; it returns existingEntryIds for the caller to decide. The record's objectType must match the list's parentObjectType. The entry is local-authoritative even when the record mirrors HubSpot or Salesforce.",
   schema: z.object({
     listId: z.string().trim().min(1).max(128),
     recordId: z.string().trim().min(1).max(128),
@@ -68,6 +69,7 @@ export default defineAction({
         id: schema.crmRecords.id,
         objectType: schema.crmRecords.objectType,
         displayName: schema.crmRecords.displayName,
+        connectionId: schema.crmRecords.connectionId,
       })
       .from(schema.crmRecords)
       .where(
@@ -118,6 +120,18 @@ export default defineAction({
       .orderBy(desc(schema.crmListEntries.position))
       .limit(1);
 
+    // The entry's first values, copied once from the record. A value the caller
+    // supplied is left alone — including an explicit null, which is the caller
+    // saying "start this one empty".
+    const initial = await initialCrmEntryValues({
+      db,
+      connectionId: record.connectionId,
+      record,
+      attributes,
+      supplied: new Set(Object.keys(args.values ?? {})),
+    });
+    const values = { ...initial.values, ...(args.values ?? {}) };
+
     const entryId = crypto.randomUUID();
     const actor = crmActorFrom(ctx);
     const now = new Date().toISOString();
@@ -141,7 +155,7 @@ export default defineAction({
         recordId: record.id,
         entryId,
         attributes,
-        values: args.values ?? {},
+        values,
         actor,
         ownership,
         now,
@@ -152,6 +166,13 @@ export default defineAction({
       entryId,
       listId: list.id,
       recordId: record.id,
+      /**
+       * What the entry's values were initialized from. An `applied: false` row
+       * is a value the record held that this list cannot represent — reported,
+       * never dropped silently, because an unexplained empty card is exactly
+       * how a board looks broken.
+       */
+      initialValues: initial.initialValues,
       /**
        * Entries this record already had in this list. Non-empty is normal, not
        * an error — the caller decides whether a second entry was intended.