flowdular 0.3.0 → 0.3.1

package/dist/distribution.js

@@ -3115,7 +3115,7 @@ var moduleCatalogSchema = module_catalog_schema_default;
 var moduleArtifactSchema = module_artifact_schema_default;
 
 // ../contracts/src/index.ts
-var PLATFORM_API_VERSION = "0.1.6";
+var PLATFORM_API_VERSION = "0.1.8";
 
 // ../kernel/src/module-compatibility.ts
 function satisfiesModuleVersion(version, range) {
@@ -3796,7 +3796,7 @@ import { dirname as dirname6, join as join6, relative as relative5 } from "node:
 import { createRequire } from "node:module";
 import { readFile as readFile5 } from "node:fs/promises";
 import { dirname as dirname4, join as join3 } from "node:path";
-var SDK_VERSION = "0.3.0";
+var SDK_VERSION = "0.3.1";
 function npmPackage(specifier) {
   return specifier.startsWith("@") ? specifier.split("/").slice(0, 2).join("/") : specifier.split("/")[0];
 }

package/dist/index.js

@@ -2022,6 +2022,10 @@ function stringFlag(arguments_, name) {
   const value = arguments_.flags.get(name);
   return typeof value === "string" ? value : void 0;
 }
+function grantFlag(arguments_) {
+  const value = stringFlag(arguments_, "grant");
+  return value === void 0 || value.length === 0 ? void 0 : value;
+}
 
 // src/output.ts
 import { styleText } from "node:util";
@@ -3283,7 +3287,7 @@ var moduleCatalogSchema = module_catalog_schema_default;
 var moduleArtifactSchema = module_artifact_schema_default;
 
 // ../contracts/src/index.ts
-var PLATFORM_API_VERSION = "0.1.6";
+var PLATFORM_API_VERSION = "0.1.8";
 
 // src/module-templates.ts
 function packageSuffix(id) {
@@ -5386,6 +5390,178 @@ var RegistryError = class extends Error {
 var ALLOWED = Object.freeze({ allowed: true });
 var NO_POLICIES = Object.freeze([]);
 
+// ../kernel/src/approval-grant.ts
+import { createHash as createHash2, createHmac, timingSafeEqual } from "node:crypto";
+
+// ../kernel/src/keyring.ts
+import {
+  createCipheriv,
+  createDecipheriv,
+  createHash,
+  randomBytes
+} from "node:crypto";
+var KEYRING_KEY_BYTES = 32;
+var KEYRING_MAX_PREVIOUS_KEYS = 8;
+function keyFingerprint(key) {
+  return createHash("sha256").update(key).digest("hex").slice(0, 16);
+}
+function parsePreviousKeys(value, decode) {
+  if (!value) return [];
+  return value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0).map(decode);
+}
+
+// ../kernel/src/approval-grant.ts
+var APPROVAL_GRANT_KEY_VARIABLE = "FD_APPROVAL_GRANT_KEY";
+var APPROVAL_GRANT_PREVIOUS_KEY_VARIABLE = "FD_APPROVAL_GRANT_KEY_PREVIOUS";
+var APPROVAL_GRANT_MAX_TOKEN_LENGTH = 2048;
+var APPROVAL_GRANT_INPUT_DIGEST_LENGTH = 64;
+var TOKEN_PREFIX = "ag1";
+var MAX_CLAIM_LENGTH = 128;
+function createApprovalGrantKeyring(options) {
+  const previous = options.previous ?? [];
+  if (previous.length > KEYRING_MAX_PREVIOUS_KEYS) {
+    throw new Error(
+      `An approval grant keyring accepts at most ${KEYRING_MAX_PREVIOUS_KEYS} previous keys; ${previous.length} were given.`
+    );
+  }
+  const keys = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const key of [options.current, ...previous]) {
+    if (key.byteLength !== KEYRING_KEY_BYTES) {
+      throw new Error(
+        `An approval grant key must be exactly ${KEYRING_KEY_BYTES} bytes.`
+      );
+    }
+    const id = keyFingerprint(key);
+    if (keys.has(id)) continue;
+    keys.set(id, Buffer.from(key));
+    order.push(id);
+  }
+  return {
+    keyId: order[0],
+    previousKeyIds: order.slice(1),
+    key: (keyId) => keys.get(keyId)
+  };
+}
+function decodeKey(value, variable) {
+  const key = Buffer.from(value.trim(), "base64");
+  if (key.byteLength !== KEYRING_KEY_BYTES) {
+    key.fill(0);
+    throw new Error(
+      `${variable} must be a base64-encoded ${KEYRING_KEY_BYTES}-byte key.`
+    );
+  }
+  return key;
+}
+function approvalGrantKeyringFromEnvironment(environment = process.env) {
+  const current = environment[APPROVAL_GRANT_KEY_VARIABLE];
+  if (!current) return void 0;
+  return createApprovalGrantKeyring({
+    current: decodeKey(current, APPROVAL_GRANT_KEY_VARIABLE),
+    previous: parsePreviousKeys(
+      environment[APPROVAL_GRANT_PREVIOUS_KEY_VARIABLE],
+      (entry) => decodeKey(entry, APPROVAL_GRANT_PREVIOUS_KEY_VARIABLE)
+    )
+  });
+}
+function canonical(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value === void 0 ? null : value);
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((entry) => canonical(entry)).join(",")}]`;
+  }
+  const entries = Object.entries(value).filter(([, entry]) => entry !== void 0).sort(([left], [right]) => left < right ? -1 : left > right ? 1 : 0);
+  return `{${entries.map(([key, entry]) => `${JSON.stringify(key)}:${canonical(entry)}`).join(",")}}`;
+}
+function approvalInputDigest(input) {
+  return createHash2("sha256").update(canonical(input), "utf8").digest("hex");
+}
+function claimString(value, maximum = MAX_CLAIM_LENGTH) {
+  return typeof value === "string" && value.length >= 1 && value.length <= maximum && !/[\s\u0000]/.test(value) ? value : void 0;
+}
+function claimInteger(value) {
+  return Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+}
+function readClaims(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  const raw = value;
+  const tenantId = claimString(raw.tenantId);
+  const capabilityId = claimString(raw.capabilityId);
+  const inputDigest = claimString(
+    raw.inputDigest,
+    APPROVAL_GRANT_INPUT_DIGEST_LENGTH
+  );
+  const requestId = claimString(raw.requestId);
+  const nonce = claimString(raw.nonce);
+  const issuedAt = claimInteger(raw.issuedAt);
+  const expiresAt = claimInteger(raw.expiresAt);
+  if (raw.v !== 1 || tenantId === void 0 || capabilityId === void 0 || inputDigest === void 0 || requestId === void 0 || nonce === void 0 || issuedAt === void 0 || expiresAt === void 0 || expiresAt <= issuedAt) {
+    return void 0;
+  }
+  return {
+    v: 1,
+    tenantId,
+    capabilityId,
+    inputDigest,
+    requestId,
+    issuedAt,
+    expiresAt,
+    nonce
+  };
+}
+function signature(key, signed) {
+  return createHmac("sha256", key).update(signed, "utf8").digest();
+}
+function invalid(message) {
+  return { ok: false, reason: "APPROVAL_GRANT_INVALID", message };
+}
+function verifyApprovalGrant(keyring, token, expected, now = Date.now()) {
+  if (typeof token !== "string" || token.length < 32 || token.length > APPROVAL_GRANT_MAX_TOKEN_LENGTH) {
+    return invalid("The approval grant is not a token this platform issued.");
+  }
+  const [prefix, keyId, payload, supplied, extra] = token.split(".");
+  if (prefix !== TOKEN_PREFIX || !keyId || !payload || !supplied || extra !== void 0) {
+    return invalid("The approval grant is not a token this platform issued.");
+  }
+  const key = keyring.key(keyId);
+  if (!key) {
+    return invalid(
+      "The approval grant names a key this platform does not hold."
+    );
+  }
+  const expectedSignature = signature(key, `${prefix}.${keyId}.${payload}`);
+  const suppliedSignature = Buffer.from(supplied, "base64url");
+  if (suppliedSignature.byteLength !== expectedSignature.byteLength || !timingSafeEqual(suppliedSignature, expectedSignature)) {
+    return invalid("The approval grant signature does not verify.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+  } catch {
+    return invalid("The approval grant payload is unreadable.");
+  }
+  const claims = readClaims(parsed);
+  if (!claims) return invalid("The approval grant payload is out of bounds.");
+  if (claims.expiresAt <= now) {
+    return {
+      ok: false,
+      reason: "APPROVAL_GRANT_EXPIRED",
+      message: "The approval grant has expired."
+    };
+  }
+  if (claims.tenantId !== expected.tenantId || claims.capabilityId !== expected.capabilityId || expected.inputDigest !== void 0 && claims.inputDigest !== expected.inputDigest) {
+    return {
+      ok: false,
+      reason: "APPROVAL_GRANT_MISMATCH",
+      message: "The approval grant was issued for another workspace, capability or input."
+    };
+  }
+  return { ok: true, claims };
+}
+
 // ../kernel/src/module-compatibility.ts
 var import_semver = __toESM(require_semver2(), 1);
 function incrementModuleVersion(version, level) {
@@ -5571,11 +5747,11 @@ import { dirname as dirname3, resolve as resolve2 } from "node:path";
 
 // src/module-artifact.ts
 import { parse as parseYaml2 } from "yaml";
-import { createHash } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 var MAX_ARTIFACT_BYTES = 48 * 1024 * 1024;
 var MAX_SOURCE_BYTES = 32 * 1024 * 1024;
 var MAX_FILES = 4096;
-var hashBytes = (bytes) => createHash("sha256").update(bytes).digest("hex");
+var hashBytes = (bytes) => createHash3("sha256").update(bytes).digest("hex");
 var HASH = /^[a-f0-9]{64}$/;
 var ROOTS = /* @__PURE__ */ new Set(["src", "tests", "migrations", "translations", "spec"]);
 var ROOT_FILES = /* @__PURE__ */ new Set([
@@ -5961,7 +6137,7 @@ import { dirname as dirname6, join as join5, relative as relative5 } from "node:
 import { createRequire } from "node:module";
 import { readFile as readFile4 } from "node:fs/promises";
 import { dirname as dirname4, join as join2 } from "node:path";
-var SDK_VERSION = "0.3.0";
+var SDK_VERSION = "0.3.1";
 var LIBRARIES = /* @__PURE__ */ new Set([
   "ai-provider",
   "cli-protocol",
@@ -7142,11 +7318,12 @@ $ledger_privileges$;`;
 }
 
 // ../database/src/migrations.ts
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 var DATABASE_MIGRATION_LEDGER = "_coreloom_migrations_v2";
+var DATABASE_MIGRATION_LEDGER_LOCK = "coreloom.migrations";
 function moduleMigrationChecksum(statements) {
   const normalized = statements.replace(/\r\n?/g, "\n").trim();
-  return `sha256:${createHash2("sha256").update(normalized, "utf8").digest("hex")}`;
+  return `sha256:${createHash4("sha256").update(normalized, "utf8").digest("hex")}`;
 }
 var DatabaseMigrationError = class extends Error {
   constructor(code, migrationId, message, options) {
@@ -7338,6 +7515,7 @@ async function runDatabaseMigrations(database, namespace, migrations, options =
   }
   return database.transaction(
     async (transaction) => {
+      await transaction.acquireMigrationLock(DATABASE_MIGRATION_LEDGER_LOCK);
       await transaction.acquireMigrationLock(namespace);
       await transaction.executeScript(
         database.capabilities.sql.migrationLedgerDdl(DATABASE_MIGRATION_LEDGER)
@@ -8278,12 +8456,13 @@ function createDatabaseProvider(config, factories = {}) {
 }
 
 // ../database/src/backup.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 var BACKUP_MANIFEST_FILE = "backup.json";
 var BACKUP_MANIFEST_VERSION = 1;
 var BACKUP_KEY_VARIABLES = Object.freeze([
   "FD_AGENT_CREDENTIAL_KEY",
   "FD_AGENT_RUN_GRANT_KEY",
+  "FD_APPROVAL_GRANT_KEY",
   "FD_WORKFLOWS_PAYLOAD_KEY",
   "FD_WORKFLOWS_CURSOR_KEY",
   "FD_AUTH_MFA_KEY",
@@ -8302,7 +8481,7 @@ function backupKeyFingerprint(value) {
   const trimmed = value?.trim();
   if (!trimmed) return null;
   const material = keyMaterial(trimmed);
-  const digest2 = createHash3("sha256").update(material).digest("hex");
+  const digest2 = createHash5("sha256").update(material).digest("hex");
   material.fill(0);
   return `sha256:${digest2}`;
 }
@@ -8339,7 +8518,7 @@ function createBackupManifest(input) {
     keys: backupKeyFingerprints(input.environment)
   };
 }
-function invalid(reason2) {
+function invalid2(reason2) {
   throw new DatabaseError(
     "INVALID_ARGUMENT",
     `The backup manifest is invalid: ${reason2}`
@@ -8347,27 +8526,27 @@ function invalid(reason2) {
 }
 function boundedString(value, field) {
   if (typeof value !== "string" || value.length < 1 || value.length > 256) {
-    invalid(`${field} must be a string of 1 to 256 characters.`);
+    invalid2(`${field} must be a string of 1 to 256 characters.`);
   }
   return value;
 }
 function parseBackupManifest(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    invalid("it is not an object.");
+    invalid2("it is not an object.");
   }
   const record = value;
   if (record.schemaVersion !== BACKUP_MANIFEST_VERSION) {
-    invalid(`schemaVersion must be ${BACKUP_MANIFEST_VERSION}.`);
+    invalid2(`schemaVersion must be ${BACKUP_MANIFEST_VERSION}.`);
   }
   const adapter = record.adapter;
   if (adapter !== "pglite" && adapter !== "postgresql") {
-    invalid('adapter must be "pglite" or "postgresql".');
+    invalid2('adapter must be "pglite" or "postgresql".');
   }
   if (!Array.isArray(record.modules) || record.modules.length > 512) {
-    invalid("modules must be a list of at most 512 module ids.");
+    invalid2("modules must be a list of at most 512 module ids.");
   }
   if (!Array.isArray(record.keys) || record.keys.length > 64) {
-    invalid("keys must be a list of at most 64 fingerprints.");
+    invalid2("keys must be a list of at most 64 fingerprints.");
   }
   return {
     schemaVersion: BACKUP_MANIFEST_VERSION,
@@ -8377,12 +8556,12 @@ function parseBackupManifest(value) {
     modules: record.modules.map((entry) => boundedString(entry, "modules[]")),
     keys: record.keys.map((entry) => {
       if (typeof entry !== "object" || entry === null) {
-        invalid("keys[] must be an object.");
+        invalid2("keys[] must be an object.");
       }
       const key = entry;
       const fingerprint = key.fingerprint;
       if (fingerprint !== null && typeof fingerprint !== "string") {
-        invalid("keys[].fingerprint must be a string or null.");
+        invalid2("keys[].fingerprint must be a string or null.");
       }
       return {
         variable: boundedString(key.variable, "keys[].variable"),
@@ -8564,6 +8743,15 @@ var capabilities = [
     localOnly: true,
     confirmation: "restore-database"
   },
+  {
+    id: "database.restore.production",
+    version: 1,
+    summary: "Replace a deployed database with the contents of a backup directory under a verified approval grant.",
+    risk: "destructive",
+    requiresApprovedSpec: false,
+    supportsDryRun: true,
+    confirmation: "restore-database"
+  },
   {
     id: "migration.scaffold",
     version: 1,
@@ -8829,6 +9017,8 @@ import { promisify } from "node:util";
 var POSTGRES_DUMP_FILE = "database.dump";
 var PGLITE_PAYLOAD_DIRECTORY = "pglite";
 var TOOL_OUTPUT_LIMIT = 4e3;
+var PLATFORM_PROBE_TIMEOUT_MS = 3e3;
+var PLATFORM_URL_LIMIT = 2048;
 var runFile = promisify(execFile);
 function reason(error) {
   return error instanceof Error ? error.message : String(error);
@@ -9060,11 +9250,97 @@ async function restrictTree(root) {
     else if (entry.isFile()) await chmod(path, 384);
   }
 }
-async function databaseRestore(workspace, input, apply) {
+function restoreTarget(config) {
+  if (config.adapter === "postgresql") {
+    const url = new URL(config.postgresql.migrator.connectionString);
+    return decodeURIComponent(url.pathname.slice(1));
+  }
+  const directory = config.pglite?.dataDirectory;
+  return directory === void 0 ? void 0 : resolve5(config.workspaceRoot, directory);
+}
+function describeKeyMismatch(divergent) {
+  return divergent.map((key) => `${key.variable} (${key.status})`).join(", ");
+}
+function platformEndpoint(options, environment) {
+  if (options.platformUrl !== void 0) {
+    return `${options.platformUrl.replace(/\/+$/, "")}/api/health`;
+  }
+  const port = environment.FD_PORT?.trim();
+  return port && /^[1-9]\d{0,4}$/.test(port) ? `http://127.0.0.1:${port}/api/health` : void 0;
+}
+function connectionRefused(cause) {
+  const failure_ = cause;
+  if (failure_?.code === "ECONNREFUSED") return true;
+  return Array.isArray(failure_?.errors) && failure_.errors.length > 0 && failure_.errors.every((entry) => connectionRefused(entry));
+}
+async function platformState(endpoint) {
+  try {
+    await fetch(endpoint, {
+      redirect: "manual",
+      signal: AbortSignal.timeout(PLATFORM_PROBE_TIMEOUT_MS)
+    });
+    return "running";
+  } catch (error) {
+    return connectionRefused(error.cause) ? "stopped" : "unknown";
+  }
+}
+async function platformRefusal(options, environment) {
+  const endpoint = platformEndpoint(options, environment);
+  if (!endpoint) {
+    return options.platformStopped ? void 0 : failure(
+      "PLATFORM_STATE_UNKNOWN",
+      "Nothing names the platform to probe. Pass --platform-url <origin>, set FD_PORT, or pass --platform-stopped to attest that it is not running."
+    );
+  }
+  const state = await platformState(endpoint);
+  if (state === "running") {
+    return failure(
+      "PLATFORM_RUNNING",
+      `The platform still answers at ${endpoint}. Stop it or take it out of the load balancer before restoring.`
+    );
+  }
+  if (state === "unknown" && !options.platformStopped) {
+    return failure(
+      "PLATFORM_STATE_UNKNOWN",
+      `${endpoint} could not be probed (no answer within ${PLATFORM_PROBE_TIMEOUT_MS}ms, an unknown host or an untrusted certificate), so the platform may still be running. Pass --platform-stopped to attest that it is not.`
+    );
+  }
+  return void 0;
+}
+function productionRefusal(options, config) {
+  if (!options.target) {
+    return failure(
+      "INPUT_REQUIRED",
+      "--target <database name> is required: it must repeat the database the migrator DSN names."
+    );
+  }
+  const expected = restoreTarget(config);
+  const target = config.adapter === "pglite" ? resolve5(config.workspaceRoot, options.target) : options.target;
+  if (target !== expected) {
+    return failure(
+      "RESTORE_TARGET_MISMATCH",
+      `--target names "${options.target}", but the migrator connection points at "${expected ?? ""}".`
+    );
+  }
+  if (options.platformUrl !== void 0 && (options.platformUrl.length > PLATFORM_URL_LIMIT || !/^https?:\/\//.test(options.platformUrl) || !URL.canParse(options.platformUrl))) {
+    return failure(
+      "INVALID_ARGUMENT",
+      "--platform-url must be an http or https origin."
+    );
+  }
+  if (config.adapter === "postgresql" && new URL(config.postgresql.migrator.connectionString).username === new URL(config.postgresql.runtime.connectionString).username) {
+    return failure(
+      "MIGRATOR_ROLE_REQUIRED",
+      "A production restore runs under the migrator role only. Set FD_DATABASE_MIGRATOR_URL to a connection whose user differs from the one in FD_DATABASE_URL."
+    );
+  }
+  return void 0;
+}
+async function databaseRestore(workspace, input, apply, production) {
   if (!input) {
     return failure(
       "INPUT_REQUIRED",
-      "Use database restore --input <dir> --apply --confirm restore-database."
+      production ? "Use database restore-production --input <dir> --target <database> --grant <token> --tenant <id> --apply --confirm restore-database." : "Use database restore --input <dir> --apply --confirm restore-database."
     );
   }
   let config;
@@ -9092,16 +9368,29 @@ async function databaseRestore(workspace, input, apply) {
       `The backup was taken from the ${manifest2.adapter} adapter, but this workspace is configured for ${config.adapter}.`
     );
   }
+  if (production) {
+    const refused = productionRefusal(production, config);
+    if (refused) return refused;
+  }
   const keys = compareBackupKeys(manifest2, config.environment);
   const divergent = keys.filter((key) => key.status !== "match");
+  if (production && divergent.length > 0 && !production.allowKeyMismatch) {
+    return failure(
+      "BACKUP_KEY_MISMATCH",
+      `The running environment holds keys this backup was not taken with: ${describeKeyMismatch(divergent)}. Restore the keys first, or pass --allow-key-mismatch to restore rows that stay unreadable.`,
+      { keys }
+    );
+  }
   const warnings = [
     ...divergent.length === 0 ? [] : [
-      `BACKUP_KEY_MISMATCH: ${divergent.map((key) => `${key.variable} (${key.status})`).join(
-        ", "
-      )}. Restore the keys this backup was taken with, or the credentials, MFA secrets and workflow payloads it carries stay unreadable.`
+      `BACKUP_KEY_MISMATCH: ${describeKeyMismatch(divergent)}. Restore the keys this backup was taken with, or the credentials, MFA secrets and workflow payloads it carries stay unreadable.`
     ],
     ...apply ? [] : ["Dry run only. Pass --apply to restore the database."]
   ];
+  if (production && apply) {
+    const refused = await platformRefusal(production, config.environment);
+    if (refused) return refused;
+  }
   if (config.adapter === "postgresql") {
     const tool = await resolveTool("pg_restore", process.env);
     if (!tool) {
@@ -9124,7 +9413,8 @@ async function databaseRestore(workspace, input, apply) {
       payload: payload2,
       tool,
       manifest: manifest2,
-      keys
+      keys,
+      ...production ? { target: production.target } : {}
     };
     if (!apply) return success(plan2, { warnings });
     const result2 = await withPostgresConnection(
@@ -10607,7 +10897,7 @@ import {
   stat as stat3
 } from "node:fs/promises";
 import { dirname as dirname14, join as join14, relative as relative9 } from "node:path";
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash6 } from "node:crypto";
 
 // ../kernel/src/legacy-local-state.ts
 var LEGACY_DATA_DIRECTORY = ".octane-erp";
@@ -10703,7 +10993,7 @@ async function migrationPlan(workspace) {
   };
 }
 async function digest(path) {
-  return createHash4("sha256").update(await readFile16(path)).digest("hex");
+  return createHash6("sha256").update(await readFile16(path)).digest("hex");
 }
 async function ensurePrivateDirectory(path) {
   try {
@@ -11037,19 +11327,35 @@ function relativeReports2(root, reports) {
     file: relative11(root, report.file)
   }));
 }
-function environmentRefusal(descriptor) {
-  if (descriptor.risk === "external") {
-    return failure(
-      "APPROVAL_VERIFIER_REQUIRED",
-      `Capability "${descriptor.id}" is disabled until a signed approval verifier is configured.`
-    );
-  }
-  if (descriptor.risk === "destructive" && !descriptor.localOnly) {
+var RUNNER_FLAGS = /* @__PURE__ */ new Set(["confirm", "grant", "json", "root", "tenant"]);
+function invocationDigest(arguments_, commandArguments) {
+  const flags = [...arguments_.flags].filter(([name]) => !RUNNER_FLAGS.has(name)).sort(([left], [right]) => left.localeCompare(right));
+  return approvalInputDigest({
+    arguments: commandArguments,
+    flags: Object.fromEntries(flags)
+  });
+}
+function approvalRefusal(descriptor, arguments_, commandArguments) {
+  const gated = descriptor.risk === "external" || descriptor.risk === "destructive" && !descriptor.localOnly;
+  if (!gated) return void 0;
+  const token = grantFlag(arguments_);
+  const keyring = approvalGrantKeyringFromEnvironment(process.env);
+  if (!token || !keyring) {
     return failure(
       "APPROVAL_VERIFIER_REQUIRED",
-      `Destructive capability "${descriptor.id}" is disabled until a signed approval verifier is configured.`
+      `Capability "${descriptor.id}" runs only with --grant <token> from an approved approvals.core request, verified under FD_APPROVAL_GRANT_KEY.`
     );
   }
+  const verification = verifyApprovalGrant(keyring, token, {
+    tenantId: stringFlag(arguments_, "tenant") ?? "",
+    capabilityId: descriptor.id,
+    inputDigest: invocationDigest(arguments_, commandArguments)
+  });
+  return verification.ok ? void 0 : failure(verification.reason, verification.message);
+}
+function environmentRefusal(descriptor, arguments_, commandArguments = []) {
+  const approval = approvalRefusal(descriptor, arguments_, commandArguments);
+  if (approval) return approval;
   const environment = process.env.FD_ENV ?? process.env.NODE_ENV ?? "development";
   if (descriptor.localOnly && environment !== "development" && environment !== "test") {
     return failure(
@@ -11080,7 +11386,11 @@ function writeRefusal(descriptor, arguments_) {
 }
 async function runExtensionCommand(workspace, extension, arguments_) {
   const descriptor = extension.command.capability;
-  const refused = environmentRefusal(descriptor);
+  const invokedByCapability = arguments_.positionals[0] === "capability" && arguments_.positionals[1] === "run";
+  const commandArguments = arguments_.positionals.slice(
+    invokedByCapability ? 3 : extension.command.path.length
+  );
+  const refused = environmentRefusal(descriptor, arguments_, commandArguments);
   if (refused) return refused;
   if (descriptor.requiresApprovedSpec) {
     const specFlag = stringFlag(arguments_, "spec");
@@ -11111,7 +11421,6 @@ async function runExtensionCommand(workspace, extension, arguments_) {
   if (writeRefused) return writeRefused;
   const apply = arguments_.flags.has("apply");
   const command = await loadCliCommand(extension);
-  const invokedByCapability = arguments_.positionals[0] === "capability" && arguments_.positionals[1] === "run";
   let databases;
   try {
     const result2 = await command.execute({
@@ -11119,9 +11428,7 @@ async function runExtensionCommand(workspace, extension, arguments_) {
       moduleRoot: extension.moduleRoot,
       apply,
       flags: arguments_.flags,
-      arguments: arguments_.positionals.slice(
-        invokedByCapability ? 3 : extension.command.path.length
-      ),
+      arguments: commandArguments,
       /* Built on first read, so a command that touches no database starts no
          embedded PostgreSQL and opens no pool. The runner owns it for the
          length of the command: an extension releases the leases it takes and
@@ -11168,6 +11475,7 @@ async function runCommand(arguments_) {
           "database reset [--module <id>] [--apply --confirm reset-database]",
           "database backup --output <dir> [--apply]",
           "database restore --input <dir> --apply --confirm restore-database",
+          "database restore-production --input <dir> --target <database> --grant <token> --tenant <id> [--allow-key-mismatch] [--platform-url <origin>|--platform-stopped] --apply --confirm restore-database",
           "setup (interactive)|check|quick [--apply --confirm reset-local-auth]|migrate-state [--apply --confirm migrate-legacy-state]",
           ...extensionCommands.map((entry) => entry.command.path.join(" "))
         ],
@@ -11217,7 +11525,7 @@ async function runCommand(arguments_) {
     }
     if (group === "setup" && action === "migrate-state") {
       const descriptor = capability("workspace.state.migrate");
-      const refused = environmentRefusal(descriptor) ?? writeRefusal(descriptor, arguments_);
+      const refused = environmentRefusal(descriptor, arguments_) ?? writeRefusal(descriptor, arguments_);
       if (refused) return refused;
       return migrateLegacyState(workspace, arguments_.flags.has("apply"));
     }
@@ -11261,7 +11569,8 @@ async function runCommand(arguments_) {
           "workspace.state.migrate": ["setup", "migrate-state"],
           "database.reset.local": ["database", "reset"],
           "database.backup": ["database", "backup"],
-          "database.restore": ["database", "restore"]
+          "database.restore": ["database", "restore"],
+          "database.restore.production": ["database", "restore-production"]
         };
         const alias = aliases[target];
         if (alias)
@@ -11336,7 +11645,7 @@ async function runCommand(arguments_) {
     if (group === "database") {
       if (action === "reset") {
         const descriptor = capability("database.reset.local");
-        const refused = environmentRefusal(descriptor) ?? writeRefusal(descriptor, arguments_);
+        const refused = environmentRefusal(descriptor, arguments_) ?? writeRefusal(descriptor, arguments_);
         if (refused) return refused;
         return databaseReset(
           workspace,
@@ -11346,7 +11655,7 @@ async function runCommand(arguments_) {
       }
       if (action === "backup") {
         const descriptor = capability("database.backup");
-        const refused = environmentRefusal(descriptor) ?? writeRefusal(descriptor, arguments_);
+        const refused = environmentRefusal(descriptor, arguments_) ?? writeRefusal(descriptor, arguments_);
         if (refused) return refused;
         return await databaseBackup(
           workspace,
@@ -11356,7 +11665,7 @@ async function runCommand(arguments_) {
       }
       if (action === "restore") {
         const descriptor = capability("database.restore");
-        const refused = environmentRefusal(descriptor) ?? writeRefusal(descriptor, arguments_);
+        const refused = environmentRefusal(descriptor, arguments_) ?? writeRefusal(descriptor, arguments_);
         if (refused) return refused;
         return await databaseRestore(
           workspace,
@@ -11364,9 +11673,25 @@ async function runCommand(arguments_) {
           arguments_.flags.has("apply")
         );
       }
+      if (action === "restore-production") {
+        const descriptor = capability("database.restore.production");
+        const refused = environmentRefusal(descriptor, arguments_) ?? writeRefusal(descriptor, arguments_);
+        if (refused) return refused;
+        return await databaseRestore(
+          workspace,
+          stringFlag(arguments_, "input"),
+          arguments_.flags.has("apply"),
+          {
+            target: stringFlag(arguments_, "target"),
+            allowKeyMismatch: arguments_.flags.has("allow-key-mismatch"),
+            platformUrl: stringFlag(arguments_, "platform-url"),
+            platformStopped: arguments_.flags.has("platform-stopped")
+          }
+        );
+      }
       return failure(
         "USAGE_ERROR",
-        "Use database reset [--module <id>] [--apply --confirm reset-database], database backup --output <dir> [--apply], or database restore --input <dir> --apply --confirm restore-database."
+        "Use database reset [--module <id>] [--apply --confirm reset-database], database backup --output <dir> [--apply], database restore --input <dir> --apply --confirm restore-database, or database restore-production --input <dir> --target <database> --grant <token> --tenant <id> --apply --confirm restore-database."
       );
     }
     if (group === "migration") {
@@ -11400,7 +11725,7 @@ async function runCommand(arguments_) {
           );
         }
         const descriptor = capability("migration.apply.local");
-        const refused = environmentRefusal(descriptor) ?? writeRefusal(descriptor, arguments_);
+        const refused = environmentRefusal(descriptor, arguments_) ?? writeRefusal(descriptor, arguments_);
         if (refused) return refused;
         return migrationApply(
           workspace,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "flowdular",
-	"version": "0.3.0",
+	"version": "0.3.1",
 	"type": "module",
 	"bin": {
 		"flowdular": "./dist/index.js",
@@ -16,7 +16,7 @@
 		"ajv": "8.20.0",
 		"pg": "8.23.0",
 		"yaml": "2.9.0",
-		"@flowdular/sdk": "0.3.0"
+		"@flowdular/sdk": "0.3.1"
 	},
 	"license": "MIT",
 	"repository": {