@agent-native/core 0.128.4 → 0.129.0

package/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/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/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;
+}