@agent-native/core 0.128.3 → 0.129.0

package/corpus/core/src/db/client.ts

@@ -638,6 +638,27 @@ function sqlAndArgs(sql: DbExecStatement): {
     : { rawSql: sql.sql, args: sql.args || [] };
 }
 
+const POSTGRES_STATEMENT_TIMEOUT_HEADROOM_MS = 250;
+const POSTGRES_MAX_INT = 2_147_483_647;
+
+function hasExplicitDbTimeout(statement: DbExecStatement): boolean {
+  if (typeof statement === "string") return false;
+  const timeoutMs = Number(statement.timeoutMs);
+  return Number.isFinite(timeoutMs) && timeoutMs > 0;
+}
+
+function postgresStatementTimeoutMs(clientTimeoutMs: number): number {
+  const safeTimeoutMs = Math.max(
+    1,
+    Math.min(POSTGRES_MAX_INT, Math.floor(clientTimeoutMs)),
+  );
+  const headroomMs = Math.min(
+    POSTGRES_STATEMENT_TIMEOUT_HEADROOM_MS,
+    Math.max(1, Math.floor(safeTimeoutMs * 0.1)),
+  );
+  return Math.max(1, safeTimeoutMs - headroomMs);
+}
+
 export function dbExecQueryBudget(statement: DbExecStatement): {
   timeoutMs: number;
   maxAttempts: number;
@@ -1229,6 +1250,36 @@ async function createDbExecInternal(
           rowsAffected: result.rowCount ?? 0,
         };
       }
+      async function queryNeonClientWithStatementTimeout(
+        client: any,
+        sql: Parameters<DbExec["execute"]>[0],
+        remainingMs: () => number,
+        markClientForDiscard: () => void,
+      ) {
+        const statementTimeoutMs = postgresStatementTimeoutMs(remainingMs());
+        await queryNeonClient(
+          client,
+          `SET statement_timeout = ${statementTimeoutMs}`,
+          remainingMs(),
+        );
+        try {
+          return await queryNeonClient(client, sql, remainingMs());
+        } finally {
+          try {
+            await queryNeonClient(
+              client,
+              "RESET statement_timeout",
+              remainingMs(),
+            );
+          } catch (err) {
+            markClientForDiscard();
+            console.warn(
+              "[db/neon] statement timeout reset failed; discarding connection:",
+              err instanceof Error ? err.message : err,
+            );
+          }
+        }
+      }
       return {
         async execute(sql) {
           const { timeoutMs, maxAttempts } = dbExecQueryBudget(sql);
@@ -1276,17 +1327,25 @@ async function createDbExecInternal(
               released = true;
               client.release(err);
             };
+            let discardClient = false;
 
             try {
-              const result = await queryNeonClient(
-                client,
-                sql,
-                remainingAttemptMs(),
-              );
-              releaseClient();
+              const result = hasExplicitDbTimeout(sql)
+                ? await queryNeonClientWithStatementTimeout(
+                    client,
+                    sql,
+                    remainingAttemptMs,
+                    () => {
+                      discardClient = true;
+                    },
+                  )
+                : await queryNeonClient(client, sql, remainingAttemptMs());
+              releaseClient(discardClient ? true : undefined);
               return result;
             } catch (err) {
-              releaseClient(isConnectionError(err) ? true : undefined);
+              releaseClient(
+                discardClient || isConnectionError(err) ? true : undefined,
+              );
               throw err;
             }
           }, maxAttempts);
@@ -1317,7 +1376,23 @@ async function createDbExecInternal(
               client.release(err);
             };
             const tx: DbExec = {
-              execute: (sql) => queryNeonClient(client, sql),
+              execute: async (sql) => {
+                if (!hasExplicitDbTimeout(sql)) {
+                  return queryNeonClient(client, sql);
+                }
+                const { timeoutMs } = dbExecQueryBudget(sql);
+                const startedAt = Date.now();
+                const remainingMs = () =>
+                  Math.max(1, timeoutMs - (Date.now() - startedAt));
+                const statementTimeoutMs =
+                  postgresStatementTimeoutMs(remainingMs());
+                await queryNeonClient(
+                  client,
+                  `SET LOCAL statement_timeout = ${statementTimeoutMs}`,
+                  remainingMs(),
+                );
+                return queryNeonClient(client, sql, remainingMs());
+              },
             };
             try {
               await queryNeonClient(client, "BEGIN");

package/corpus/core/src/db/ensure-additive-columns.ts

@@ -154,24 +154,23 @@ async function introspectPostgresColumns(
     args.push(schema, table);
     return `(table_schema = ? AND table_name = ?)`;
   });
-  try {
-    const { rows } = await db.execute({
-      sql: `SELECT table_schema, table_name, column_name
-            FROM information_schema.columns
-            WHERE ${predicates.join(" OR ")}`,
-      args,
-    });
-    const columns = new Map<string, Set<string>>();
-    for (const row of rows) {
-      const key = `${String(row.table_schema)}.${String(row.table_name)}`;
-      const tableColumns = columns.get(key) ?? new Set<string>();
-      tableColumns.add(String(row.column_name));
-      columns.set(key, tableColumns);
-    }
-    return columns;
-  } catch {
-    return null;
+  // Deliberately not caught: this one query now covers every table, so
+  // swallowing a failure here would skip the entire safety net while
+  // reporting a clean result. The caller records it as an error instead.
+  const { rows } = await db.execute({
+    sql: `SELECT table_schema, table_name, column_name
+          FROM information_schema.columns
+          WHERE ${predicates.join(" OR ")}`,
+    args,
+  });
+  const columns = new Map<string, Set<string>>();
+  for (const row of rows) {
+    const key = `${String(row.table_schema)}.${String(row.table_name)}`;
+    const tableColumns = columns.get(key) ?? new Set<string>();
+    tableColumns.add(String(row.column_name));
+    columns.set(key, tableColumns);
   }
+  return columns;
 }
 
 /**
@@ -343,9 +342,21 @@ export async function ensureAdditiveColumns(
     }
   }
 
-  const postgresColumns = isPostgres()
-    ? await introspectPostgresColumns(db, declaredTables)
-    : null;
+  let postgresColumns: Map<string, Set<string>> | null = null;
+  if (isPostgres()) {
+    try {
+      postgresColumns = await introspectPostgresColumns(db, declaredTables);
+    } catch (err) {
+      // One batch probe now covers every table, so its failure means nothing
+      // was checked. Returning an empty-but-clean result here would be
+      // indistinguishable from "schema already correct".
+      result.errors.push({
+        column: "*",
+        error: describeSchemaDriftError(err),
+      });
+      return result;
+    }
+  }
 
   for (const config of declaredTables) {
     const tableName = config.name;

package/corpus/core/src/db/migrations.ts

@@ -230,6 +230,15 @@ export interface MigrationEntry {
    * throws at startup (programmer error, not a runtime data problem).
    */
   name?: string;
+  /**
+   * JS step for a backfill SQL cannot express — e.g. a repair whose value comes
+   * from application-level parsing of a stored blob. Runs BEFORE this entry's
+   * SQL and before the bookkeeping row is written, so a throw leaves the
+   * migration unrecorded and it retries on the next boot. Pass `sql: {}` for a
+   * run-only entry. Give run-only entries a `name`: the legacy version gate
+   * would otherwise mark them applied via any later migration's MAX advance.
+   */
+  run?: () => Promise<void>;
 }
 
 function resolveMigrationSql(sql: MigrationSql, pg: boolean): string | null {
@@ -368,6 +377,7 @@ export function runMigrations(
           try {
             // D1 is SQLite-compatible
             const raw = resolveMigrationSql(m.sql, false);
+            if (m.run) await m.run();
             const recordStatements = [
               m.name
                 ? d1
@@ -385,8 +395,13 @@ export function runMigrations(
 
             if (raw == null) {
               // Dialect-gated migration with no SQL for this dialect; still
-              // record it so we don't retry forever.
-              for (const stmt of recordStatements) await stmt.run();
+              // record it so we don't retry forever. Keep the name + legacy
+              // version rows atomic: if an isolate is interrupted between
+              // separate writes, the name row would suppress every retry even
+              // though the legacy bookkeeping row never landed.
+              if (recordStatements.length > 0) {
+                await d1.batch(recordStatements);
+              }
               continue;
             }
             const originalStatements = splitSqlStatements(raw);
@@ -595,6 +610,11 @@ export function runMigrations(
             recordSql.push({ sql: insertVersionSql, args: [m.version] });
           }
 
+          // A throw here escapes to the outer handler with nothing recorded,
+          // so the entry is retried on the next boot rather than being marked
+          // applied against work that never happened.
+          if (m.run) await m.run();
+
           if (raw == null) {
             // Dialect-gated migration with no SQL for this dialect; still mark
             // as applied so we don't retry forever.

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

@@ -623,7 +623,7 @@ export function createExtensionActionEntries(): Record<string, ActionEntry> {
     "update-extension": {
       tool: {
         description:
-          'Update an existing sandboxed Alpine.js mini-app extension. Pass exactly three fields: `id`, `operation`, and `payloadJson`. `payloadJson` is a JSON object encoded as a string so model gateways cannot fill its optional members with invalid empty placeholders. For operation="edit", pass {"edits":[...]} or {"patches":[...]} and optional format=true. For operation="replace", pass exactly one of content, contentFromAttachment, or contentFromWorkspaceFile; use this operation only for a user-requested broad visual rewrite or complete replacement body. For operation="metadata", pass name, description, or icon. Change sharing through set-resource-visibility instead. If the user is viewing the extension, use the extensionId from <current-screen> or <current-url> directly.',
+          'Update an existing sandboxed Alpine.js mini-app extension. Pass exactly three fields: `id`, `operation`, and `payloadJson`. `payloadJson` is a JSON object encoded as a string so model gateways cannot fill its optional members with invalid empty placeholders. For operation="edit", pass {"edits":[...]} or {"patches":[...]} and optional format=true — prefer several small, targeted edits over one large one; a single edit/replace body over roughly 8KB risks the model truncating its own payloadJson mid-generation, which arrives here as an empty or malformed call that must be retried from scratch. For operation="replace", pass exactly one of content, contentFromAttachment, or contentFromWorkspaceFile; use this operation only for a user-requested broad visual rewrite or complete replacement body. Do not inline large static datasets (full metric histories, big arrays) into the HTML/JS body — store them with extension-data-set and fetch them at runtime via extensionData.list()/get() instead, so edits stay small regardless of dataset size. For operation="metadata", pass name, description, or icon. Change sharing through set-resource-visibility instead. If the user is viewing the extension, use the extensionId from <current-screen> or <current-url> directly.',
         parameters: {
           type: "object",
           properties: {

package/corpus/core/src/mcp/approval-store.ts

@@ -0,0 +1,99 @@
+import { getDbExec, intType, isPostgres } from "../db/client.js";
+import { ensureTableExists } from "../db/ddl-guard.js";
+
+let initPromise: Promise<void> | undefined;
+
+async function ensureApprovalTable(): Promise<void> {
+  if (!initPromise) {
+    initPromise = (async () => {
+      const createSql = `
+        CREATE TABLE IF NOT EXISTS mcp_action_approvals (
+          nonce TEXT PRIMARY KEY,
+          caller_key TEXT NOT NULL,
+          action_name TEXT NOT NULL,
+          arguments_hash TEXT NOT NULL,
+          expires_at ${intType()} NOT NULL,
+          consumed_at ${intType()}
+        )
+      `;
+      if (isPostgres()) {
+        await ensureTableExists("mcp_action_approvals", createSql);
+      } else {
+        await getDbExec().execute(createSql);
+      }
+    })().catch((error) => {
+      initPromise = undefined;
+      throw error;
+    });
+  }
+  return initPromise;
+}
+
+export interface McpApprovalGrant {
+  nonce: string;
+  callerKey: string;
+  actionName: string;
+  argumentsHash: string;
+  expiresAt: number;
+}
+
+export async function createMcpApprovalGrant(
+  grant: McpApprovalGrant,
+): Promise<void> {
+  await ensureApprovalTable();
+  const client = getDbExec();
+  await client.execute({
+    sql: `INSERT INTO mcp_action_approvals (nonce, caller_key, action_name, arguments_hash, expires_at, consumed_at) VALUES (?, ?, ?, ?, ?, NULL)`,
+    args: [
+      grant.nonce,
+      grant.callerKey,
+      grant.actionName,
+      grant.argumentsHash,
+      grant.expiresAt,
+    ],
+  });
+
+  // This is storage hygiene only. A failed cleanup must never turn a failed
+  // grant insert/consume into success, and expired rows remain unusable because
+  // consumeMcpApprovalGrant checks expires_at in the atomic update below.
+  try {
+    await client.execute({
+      sql: `DELETE FROM mcp_action_approvals WHERE expires_at < ?`,
+      args: [Date.now() - 24 * 60 * 60_000],
+    });
+  } catch (error) {
+    console.warn("[mcp] Could not clean expired action approval grants", error);
+  }
+}
+
+/**
+ * Atomically consume an exact grant. The UPDATE predicate is the security
+ * boundary: only one hosted instance can move a matching, unexpired row from
+ * pending to consumed, so an accepted response is at-most-once even when the
+ * same signed requestState is replayed concurrently.
+ */
+export async function consumeMcpApprovalGrant(
+  grant: McpApprovalGrant,
+): Promise<boolean> {
+  await ensureApprovalTable();
+  const now = Date.now();
+  const result = await getDbExec().execute({
+    sql: `UPDATE mcp_action_approvals
+      SET consumed_at = ?
+      WHERE nonce = ?
+        AND caller_key = ?
+        AND action_name = ?
+        AND arguments_hash = ?
+        AND consumed_at IS NULL
+        AND expires_at >= ?`,
+    args: [
+      now,
+      grant.nonce,
+      grant.callerKey,
+      grant.actionName,
+      grant.argumentsHash,
+      now,
+    ],
+  });
+  return result.rowsAffected === 1;
+}