@agent-native/core 0.92.0 → 0.92.1

package/corpus/core/src/db-admin/operations.ts

@@ -40,6 +40,9 @@ import type {
 // ---------------------------------------------------------------------------
 
 const IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+const LARGE_CELL_PREVIEW_CHARS = 16 * 1024;
+const LARGE_CELL_SUFFIX =
+  "\n...[db-admin truncated large cell; request includeLargeCells=true for the full value]";
 
 export interface DbAdminRuntime {
   db?: DbExec;
@@ -72,6 +75,103 @@ function isPostgresRuntime(runtime?: DbAdminRuntime): boolean {
   return dialect(runtime) === "postgres";
 }
 
+function isPreviewableLargeColumn(column: DbAdminColumn): boolean {
+  const type = column.type.toLowerCase();
+  return /\b(text|char|varchar|character|jsonb?|xml|clob)\b/.test(type);
+}
+
+function markLargeValuePreviewColumns(
+  columns: DbAdminColumn[],
+  includeLargeCells: boolean,
+): DbAdminColumn[] {
+  if (includeLargeCells) return columns;
+  return columns.map((column) =>
+    isPreviewableLargeColumn(column)
+      ? { ...column, largeValuePreview: true }
+      : column,
+  );
+}
+
+function buildRowsSelectList(
+  columns: DbAdminColumn[],
+  includeLargeCells: boolean,
+): string {
+  if (includeLargeCells) {
+    return columns.map((column) => quoteIdent(column.name)).join(", ");
+  }
+
+  return columns
+    .map((column) => {
+      const quoted = quoteIdent(column.name);
+      if (!isPreviewableLargeColumn(column)) return quoted;
+      const textValue = `CAST(${quoted} AS TEXT)`;
+      return `CASE WHEN length(${textValue}) > ${LARGE_CELL_PREVIEW_CHARS} THEN substr(${textValue}, 1, ${LARGE_CELL_PREVIEW_CHARS}) || '${LARGE_CELL_SUFFIX.replace(/'/g, "''")}' ELSE ${textValue} END AS ${quoted}`;
+    })
+    .join(", ");
+}
+
+function truncateLargeResultCells(rows: Record<string, unknown>[]): {
+  rows: Record<string, unknown>[];
+  truncatedCells: number;
+} {
+  let truncatedCells = 0;
+  const mapped = rows.map((row) => {
+    let changed = false;
+    const next: Record<string, unknown> = {};
+    for (const [key, value] of Object.entries(row)) {
+      if (
+        typeof value === "string" &&
+        value.length > LARGE_CELL_PREVIEW_CHARS
+      ) {
+        next[key] =
+          `${value.slice(0, LARGE_CELL_PREVIEW_CHARS)}${LARGE_CELL_SUFFIX}`;
+        truncatedCells += 1;
+        changed = true;
+      } else {
+        next[key] = value;
+      }
+    }
+    return changed ? next : row;
+  });
+  return { rows: mapped, truncatedCells };
+}
+
+function countTruncatedResultCells(rows: Record<string, unknown>[]): number {
+  let truncatedCells = 0;
+  for (const row of rows) {
+    for (const value of Object.values(row)) {
+      if (typeof value === "string" && value.endsWith(LARGE_CELL_SUFFIX)) {
+        truncatedCells += 1;
+      }
+    }
+  }
+  return truncatedCells;
+}
+
+function containsLargeCellPreview(value: unknown): boolean {
+  if (typeof value === "string") return value.endsWith(LARGE_CELL_SUFFIX);
+  if (Array.isArray(value)) return value.some(containsLargeCellPreview);
+  if (value && typeof value === "object") {
+    return Object.values(value as Record<string, unknown>).some(
+      containsLargeCellPreview,
+    );
+  }
+  return false;
+}
+
+function assertNoLargeCellPreviewMutation(
+  row: Record<string, unknown>,
+  context: string,
+): void {
+  for (const [column, value] of Object.entries(row)) {
+    if (containsLargeCellPreview(value)) {
+      throw new Error(
+        `Refusing to ${context} with previewed large-cell value in column "${column}". Reload the row with includeLargeCells=true before saving.`,
+      );
+    }
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Notify the UI after a real mutation so polling refetches.
 // ---------------------------------------------------------------------------
@@ -469,6 +569,8 @@ export async function getRows(
   const where = buildWhere(req.filters, runtime);
   const orderBy = buildOrderBy(req.sort);
   const quoted = quoteIdent(table);
+  const includeLargeCells = req.includeLargeCells === true;
+  const selectList = buildRowsSelectList(schema.columns, includeLargeCells);
 
   const countRes = await client.execute({
     sql: `SELECT COUNT(*) AS c FROM ${quoted}${where.clause}`,
@@ -477,16 +579,18 @@ export async function getRows(
   const total = Number((countRes.rows[0] as any)?.c ?? 0) || 0;
 
   const rowsRes = await client.execute({
-    sql: `SELECT * FROM ${quoted}${where.clause}${orderBy} LIMIT ? OFFSET ?`,
+    sql: `SELECT ${selectList} FROM ${quoted}${where.clause}${orderBy} LIMIT ? OFFSET ?`,
     args: [...where.args, pageSize, offset],
   });
+  const rows = rowsRes.rows as Record<string, unknown>[];
 
   return {
-    columns: schema.columns,
-    rows: rowsRes.rows as Record<string, unknown>[],
+    columns: markLargeValuePreviewColumns(schema.columns, includeLargeCells),
+    rows,
     total,
     page,
     pageSize,
+    truncatedCells: includeLargeCells ? 0 : countTruncatedResultCells(rows),
   };
 }
 
@@ -502,6 +606,7 @@ function buildInsert(
   if (cols.length === 0) {
     throw new Error("Cannot insert an empty row");
   }
+  assertNoLargeCellPreviewMutation(row, "insert");
   cols.forEach((c) => assertIdent(c, "column name"));
   const sql = `INSERT INTO ${quoteIdent(table)} (${cols
     .map(quoteIdent)
@@ -520,6 +625,8 @@ function buildUpdate(
   if (whereCols.length === 0) {
     throw new Error("Update requires a non-empty where clause");
   }
+  assertNoLargeCellPreviewMutation(set, "update");
+  assertNoLargeCellPreviewMutation(where, "match rows");
   setCols.forEach((c) => assertIdent(c, "column name"));
   whereCols.forEach((c) => assertIdent(c, "column name"));
   const setSql = setCols.map((c) => `${quoteIdent(c)} = ?`).join(", ");
@@ -539,6 +646,7 @@ function buildDelete(
   if (whereCols.length === 0) {
     throw new Error("Delete requires a non-empty where clause");
   }
+  assertNoLargeCellPreviewMutation(where, "delete");
   whereCols.forEach((c) => assertIdent(c, "column name"));
   const whereSql = whereCols.map((c) => `${quoteIdent(c)} = ?`).join(" AND ");
   const sql = `DELETE FROM ${quoteIdent(table)} WHERE ${whereSql}`;
@@ -674,7 +782,10 @@ export async function runSql(
   );
   const durationMs = Date.now() - started;
 
-  const rows = (res.rows ?? []) as Record<string, unknown>[];
+  const truncation = truncateLargeResultCells(
+    (res.rows ?? []) as Record<string, unknown>[],
+  );
+  const rows = truncation.rows;
   const columns =
     rows.length > 0 && rows[0] && typeof rows[0] === "object"
       ? Object.keys(rows[0])
@@ -687,5 +798,6 @@ export async function runSql(
     rows,
     rowsAffected: res.rowsAffected ?? 0,
     durationMs,
+    truncatedCells: truncation.truncatedCells,
   };
 }

package/corpus/core/src/db-admin/routes.ts

@@ -106,6 +106,7 @@ export function mountDbAdminRoutes(
               pageSize: Number(body.pageSize) || 50,
               sort: body.sort,
               filters: body.filters,
+              includeLargeCells: body.includeLargeCells === true,
             });
             return { ok: true, ...result };
           }

package/corpus/core/src/db-admin/types.ts

@@ -15,6 +15,7 @@ export interface DbAdminColumn {
   pk: boolean;
   defaultValue: string | null;
   autoIncrement?: boolean;
+  largeValuePreview?: boolean;
 }
 
 export interface DbAdminForeignKey {
@@ -74,6 +75,7 @@ export interface DbAdminRowsRequest {
   pageSize: number;
   sort?: DbAdminSort[];
   filters?: DbAdminFilter[];
+  includeLargeCells?: boolean;
 }
 
 export interface DbAdminRowsResult {
@@ -82,6 +84,7 @@ export interface DbAdminRowsResult {
   total: number;
   page: number;
   pageSize: number;
+  truncatedCells?: number;
 }
 
 export interface DbAdminMutation {
@@ -103,4 +106,5 @@ export interface DbAdminQueryResult {
   rows: Record<string, unknown>[];
   rowsAffected: number;
   durationMs: number;
+  truncatedCells?: number;
 }

package/corpus/core/src/extensions/html-shell.ts

@@ -24,10 +24,11 @@ export const EXTENSION_IFRAME_META_CSP = EXTENSION_IFRAME_CSP_BASE;
  *
  *   1. The iframe MUST be rendered with a `sandbox` attribute that does NOT
  *      include `allow-same-origin`. The viewer (`ExtensionViewer.tsx`,
- *      `EmbeddedExtension.tsx`) sets `sandbox="allow-scripts allow-forms"` —
- *      and that is the only acceptable shape. Adding `allow-same-origin`
- *      would give the extension full DOM access to the parent window via
- *      cross-frame script.
+ *      `EmbeddedExtension.tsx`) normalizes the sandbox through
+ *      `normalizeAgentNativeExtensionSandbox()`, which permits scripts, forms,
+ *      popups, and downloads but strips `allow-same-origin`. Adding
+ *      `allow-same-origin` would give the extension full DOM access to the
+ *      parent window via cross-frame script.
  *
  *   2. Every reachable parent action must treat the postMessage payload as
  *      hostile. The bridge in `iframe-bridge.ts` enforces a path allowlist,

package/corpus/core/src/extensions/routes.ts

@@ -107,6 +107,8 @@ export function createExtensionsHandler() {
   });
 }
 
+const MAX_EXTENSION_DATA_BYTES = 1024 * 1024;
+
 function normalizeExtensionUserEmail(email: string): string {
   return email.trim().toLowerCase();
 }
@@ -544,6 +546,14 @@ async function handleExtensionDataUpsert(
   const itemId = String(body.id || randomUUID());
   const data =
     typeof body.data === "string" ? body.data : JSON.stringify(body.data);
+  if (Buffer.byteLength(data, "utf8") > MAX_EXTENSION_DATA_BYTES) {
+    setResponseStatus(event, 413);
+    return {
+      error:
+        "Extension data is too large for SQL storage. Store large files, base64, or blobs in file storage and save only a URL or handle.",
+      maxBytes: MAX_EXTENSION_DATA_BYTES,
+    };
+  }
   const now = new Date().toISOString();
   const scope = body.scope === "org" ? "org" : "user";
   const orgId = getRequestOrgId();

package/corpus/core/src/navigation/index.ts

@@ -15,7 +15,7 @@ export const STANDARD_SETTINGS_TABS = {
   providers: "providers",
   connections: "connections",
   secrets: "secrets",
-  team: "team",
+  team: "organization",
   usage: "usage",
   language: "language",
   whatsNew: "whats-new",

package/corpus/core/src/resources/handlers.ts

@@ -607,10 +607,9 @@ export async function handleUploadResource(event: any) {
   }
   const owner = await resolveOwner(event, shared);
 
-  // Prefer a registered file upload provider (e.g. Builder.io) for binary
-  // assets so we get a real CDN URL instead of a base64 blob in SQL.
-  // Text resources still live in SQL — they're edited inline and benefit
-  // from the resource store's metadata/search features.
+  // Binary assets must live in file storage so resource rows do not become
+  // base64 blobs in SQL. Text resources still live in SQL because they are
+  // edited inline and benefit from the resource store's metadata/search.
   const isText =
     mimeType.startsWith("text/") || mimeType === "application/json";
 
@@ -638,12 +637,15 @@ export async function handleUploadResource(event: any) {
       setResponseStatus(event, 201);
       return { ...resource, url: uploaded.url, provider: uploaded.provider };
     }
+    setResponseStatus(event, 503);
+    return {
+      error:
+        "File storage is not configured. Connect Builder.io or register an S3/R2/GCS file upload provider before uploading binary resources.",
+      storageSetupRequired: true,
+    };
   }
 
-  // Fallback: store contents in SQL (base64 for binary, text as-is).
-  const content = isText
-    ? Buffer.from(filePart.data).toString("utf-8")
-    : Buffer.from(filePart.data).toString("base64");
+  const content = Buffer.from(filePart.data).toString("utf-8");
 
   const resource = await resourcePut(owner, path, content, mimeType);