xytara 3.1.16 → 3.2.0

package/scripts/state_backup_offsite.js

@@ -1,196 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-
-// Off-site, encrypted backups of the runtime's durable state (the Supabase snapshot row).
-//
-//   backup  <out_dir>                 read the live row, sanity-check it, gzip + AES-256-GCM encrypt
-//                                     it, verify the ciphertext decrypts back, write <out_dir>/
-//                                     xytara-state-<persisted>.enc + manifest.json (no secrets)
-//   decrypt <file.enc> <out.json>     decrypt a backup to the plain row { state_key, persisted_at_iso,
-//                                     snapshot }
-//   restore <file.enc> --runtime-stopped [--state-key k]
-//                                     write a decrypted backup back as the live row. ONLY with the
-//                                     runtime stopped (suspended on Render): a running runtime would
-//                                     overwrite it with its in-memory state on the next flush.
-//   selftest                          offline round-trip check (used by verify:all)
-//
-// Env: XYTARA_SUPABASE_URL, XYTARA_SUPABASE_SERVICE_ROLE_KEY, XYTARA_SUPABASE_STATE_TABLE
-// (default xytara_runtime_state), XYTARA_SUPABASE_STATE_KEY (default "default"), STATE_BACKUP_KEY
-// (base64, 32 bytes — keep a copy OFF this system: without it no backup can be decrypted),
-// STATE_BACKUP_MIN_PROVIDERS (default 1), STATE_BACKUP_MIN_BYTES (default 10000).
-// The snapshot contains secrets (provider owner secrets, auth tokens): it is only ever written
-// encrypted, and the manifest carries counts and digests only.
-
-const crypto = require("crypto");
-const fs = require("fs");
-const path = require("path");
-const zlib = require("zlib");
-
-const ENVELOPE_VERSION = "xytara-state-backup/1";
-
-function fail(message) {
-  console.error(`state backup: ${message}`);
-  process.exit(1);
-}
-
-function backupKey() {
-  const raw = String(process.env.STATE_BACKUP_KEY || "").trim();
-  if (!raw) fail("STATE_BACKUP_KEY is not set");
-  const key = Buffer.from(raw, "base64");
-  if (key.length !== 32) fail("STATE_BACKUP_KEY must be 32 bytes, base64-encoded");
-  return key;
-}
-
-function encrypt(rowJson, key) {
-  const plaintext = zlib.gzipSync(Buffer.from(rowJson, "utf8"), { level: 9 });
-  const iv = crypto.randomBytes(12);
-  const cipher = crypto.createCipheriv("aes-256-gcm", key, iv);
-  cipher.setAAD(Buffer.from(ENVELOPE_VERSION, "utf8"));
-  const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
-  return {
-    v: ENVELOPE_VERSION,
-    alg: "AES-256-GCM",
-    compression: "gzip",
-    iv: iv.toString("base64"),
-    tag: cipher.getAuthTag().toString("base64"),
-    plaintext_sha256: crypto.createHash("sha256").update(rowJson, "utf8").digest("hex"),
-    ciphertext: ciphertext.toString("base64")
-  };
-}
-
-function decrypt(envelope, key) {
-  if (!envelope || envelope.v !== ENVELOPE_VERSION) throw new Error("not a xytara state backup envelope");
-  const decipher = crypto.createDecipheriv("aes-256-gcm", key, Buffer.from(envelope.iv, "base64"));
-  decipher.setAAD(Buffer.from(ENVELOPE_VERSION, "utf8"));
-  decipher.setAuthTag(Buffer.from(envelope.tag, "base64"));
-  const plaintext = Buffer.concat([decipher.update(Buffer.from(envelope.ciphertext, "base64")), decipher.final()]);
-  const rowJson = zlib.gunzipSync(plaintext).toString("utf8");
-  if (crypto.createHash("sha256").update(rowJson, "utf8").digest("hex") !== envelope.plaintext_sha256) {
-    throw new Error("decrypted content digest mismatch");
-  }
-  return rowJson;
-}
-
-function entryCount(value) {
-  if (value && value.__runtime_state_kind && Array.isArray(value.value)) return value.value.length;
-  if (Array.isArray(value)) return value.length;
-  return value && typeof value === "object" ? Object.keys(value).length : 0;
-}
-
-function summarize(row, rowJson) {
-  const snapshot = row.snapshot || {};
-  const counts = {};
-  for (const key of ["providerRegistry", "providerSettlementLedger", "providerPayouts", "externalCreditGrants", "accountSpendCredentials", "transactions", "deliveryReceipts", "quotes"]) {
-    if (snapshot[key] !== undefined) counts[key] = entryCount(snapshot[key]);
-  }
-  return { state_key: row.state_key, persisted_at_iso: row.persisted_at_iso, snapshot_bytes: Buffer.byteLength(JSON.stringify(snapshot), "utf8"), row_bytes: Buffer.byteLength(rowJson, "utf8"), section_count: Object.keys(snapshot).length, counts };
-}
-
-function supabaseConfig() {
-  const url = String(process.env.XYTARA_SUPABASE_URL || "").trim().replace(/\/+$/, "");
-  const serviceKey = String(process.env.XYTARA_SUPABASE_SERVICE_ROLE_KEY || "").trim();
-  if (!url || !serviceKey) fail("XYTARA_SUPABASE_URL and XYTARA_SUPABASE_SERVICE_ROLE_KEY are required");
-  return {
-    url,
-    serviceKey,
-    table: String(process.env.XYTARA_SUPABASE_STATE_TABLE || "xytara_runtime_state").trim(),
-    stateKey: String(process.env.XYTARA_SUPABASE_STATE_KEY || "default").trim()
-  };
-}
-
-async function fetchRow(cfg) {
-  const endpoint = `${cfg.url}/rest/v1/${encodeURIComponent(cfg.table)}?state_key=eq.${encodeURIComponent(cfg.stateKey)}&select=state_key,snapshot,persisted_at_iso&limit=1`;
-  let lastError = null;
-  for (let attempt = 1; attempt <= 4; attempt += 1) {
-    try {
-      const response = await fetch(endpoint, {
-        headers: { apikey: cfg.serviceKey, authorization: `Bearer ${cfg.serviceKey}` },
-        signal: AbortSignal.timeout(45000)
-      });
-      if (!response.ok) throw new Error(`HTTP ${response.status}: ${(await response.text()).slice(0, 200)}`);
-      const rows = await response.json();
-      if (!Array.isArray(rows) || !rows[0]) throw new Error(`no row for state_key "${cfg.stateKey}"`);
-      return rows[0];
-    } catch (error) {
-      lastError = error;
-      if (attempt < 4) await new Promise((resolve) => setTimeout(resolve, attempt * 15000));
-    }
-  }
-  throw lastError;
-}
-
-async function backup(outDir) {
-  if (!outDir) fail("usage: backup <out_dir>");
-  const key = backupKey();
-  const row = await fetchRow(supabaseConfig()).catch((error) => fail(`could not read the state row: ${error.message}`));
-  const rowJson = JSON.stringify(row);
-  const summary = summarize(row, rowJson);
-  // Sanity gate: a near-empty snapshot means something already went wrong — fail loudly (the
-  // failed scheduled run is the alert) instead of quietly storing an empty backup.
-  const minProviders = Number(process.env.STATE_BACKUP_MIN_PROVIDERS || 1);
-  const minBytes = Number(process.env.STATE_BACKUP_MIN_BYTES || 10000);
-  if ((summary.counts.providerRegistry || 0) < minProviders) fail(`snapshot has ${summary.counts.providerRegistry || 0} providers (< ${minProviders}): refusing to treat it as healthy`);
-  if (summary.snapshot_bytes < minBytes) fail(`snapshot is only ${summary.snapshot_bytes} bytes (< ${minBytes}): refusing to treat it as healthy`);
-  const envelope = encrypt(rowJson, key);
-  if (decrypt(envelope, key) !== rowJson) fail("round-trip check failed");
-  fs.mkdirSync(outDir, { recursive: true });
-  const stamp = String(row.persisted_at_iso || new Date().toISOString()).replace(/[^0-9A-Za-z]/g, "").slice(0, 15);
-  const fileName = `xytara-state-${stamp}.enc`;
-  fs.writeFileSync(path.join(outDir, fileName), JSON.stringify(envelope));
-  const manifest = { v: ENVELOPE_VERSION, file: fileName, created_at_iso: new Date().toISOString(), plaintext_sha256: envelope.plaintext_sha256, ...summary };
-  fs.writeFileSync(path.join(outDir, "manifest.json"), JSON.stringify(manifest, null, 2));
-  console.log(JSON.stringify(manifest, null, 2));
-}
-
-function decryptCommand(inFile, outFile) {
-  if (!inFile || !outFile) fail("usage: decrypt <file.enc> <out.json>");
-  const rowJson = decrypt(JSON.parse(fs.readFileSync(inFile, "utf8")), backupKey());
-  fs.writeFileSync(outFile, rowJson);
-  console.log(JSON.stringify(summarize(JSON.parse(rowJson), rowJson), null, 2));
-}
-
-async function restoreCommand(inFile, args) {
-  if (!inFile || !args.includes("--runtime-stopped")) {
-    fail("usage: restore <file.enc> --runtime-stopped [--state-key k]  (suspend the runtime first, or it will overwrite the restored row)");
-  }
-  const cfg = supabaseConfig();
-  const keyIndex = args.indexOf("--state-key");
-  const stateKey = keyIndex >= 0 && args[keyIndex + 1] ? args[keyIndex + 1] : cfg.stateKey;
-  const row = JSON.parse(decrypt(JSON.parse(fs.readFileSync(inFile, "utf8")), backupKey()));
-  const response = await fetch(`${cfg.url}/rest/v1/${encodeURIComponent(cfg.table)}?on_conflict=state_key`, {
-    method: "POST",
-    headers: { apikey: cfg.serviceKey, authorization: `Bearer ${cfg.serviceKey}`, "content-type": "application/json", prefer: "resolution=merge-duplicates,return=minimal" },
-    body: JSON.stringify([{ state_key: stateKey, snapshot: row.snapshot, persisted_at_iso: row.persisted_at_iso }]),
-    signal: AbortSignal.timeout(60000)
-  });
-  if (!response.ok) fail(`restore write failed: HTTP ${response.status}`);
-  console.log(`restored ${row.state_key}@${row.persisted_at_iso} into state_key "${stateKey}". Resume the runtime now.`);
-}
-
-function selftest() {
-  const key = crypto.randomBytes(32);
-  const row = { state_key: "default", persisted_at_iso: "2026-10-17T00:00:00.000Z", snapshot: { providerRegistry: { __runtime_state_kind: "Map", value: [["p", { status: "active", owner_secret: "prvown_x" }]] } } };
-  const rowJson = JSON.stringify(row);
-  const envelope = encrypt(rowJson, key);
-  if (decrypt(envelope, key) !== rowJson) fail("selftest: round trip mismatch");
-  if (JSON.stringify(envelope).includes("prvown_x")) fail("selftest: plaintext secret visible in the envelope");
-  let wrongKeyRejected = false;
-  try { decrypt(envelope, crypto.randomBytes(32)); } catch (_) { wrongKeyRejected = true; }
-  if (!wrongKeyRejected) fail("selftest: a wrong key decrypted the backup");
-  const tampered = { ...envelope, ciphertext: Buffer.from(Buffer.from(envelope.ciphertext, "base64").map((b, i) => (i === 0 ? b ^ 1 : b))).toString("base64") };
-  let tamperRejected = false;
-  try { decrypt(tampered, key); } catch (_) { tamperRejected = true; }
-  if (!tamperRejected) fail("selftest: tampered ciphertext was accepted");
-  console.log("xytara state-backup selftest passed (round trip, no plaintext secrets, wrong key + tamper rejected)");
-}
-
-async function main() {
-  const [command, ...args] = process.argv.slice(2);
-  if (command === "backup") return backup(args[0]);
-  if (command === "decrypt") return decryptCommand(args[0], args[1]);
-  if (command === "restore") return restoreCommand(args[0], args);
-  if (command === "selftest") return selftest();
-  fail("usage: state_backup_offsite.js backup <out_dir> | decrypt <file.enc> <out.json> | restore <file.enc> --runtime-stopped | selftest");
-}
-
-main().catch((error) => fail(error && error.message ? error.message : String(error)));

package/scripts/verify_a2a_rpc.js

@@ -1,131 +0,0 @@
-"use strict";
-
-// Verifies the A2A JSON-RPC endpoint with the in-band x402 payment extension
-// (lib/a2a_rpc.js). The facilitator verify/settle and the command executor are
-// injected as mocks so this runs offline and moves no money.
-
-const assert = require("assert");
-const {
-  handleA2ARpc,
-  META_PAYLOAD,
-  META_STATUS,
-  META_REQUIRED,
-  META_ERROR
-} = require("../lib/a2a_rpc");
-
-const accepts = [
-  { scheme: "exact", network: "eip155:84532", asset: "0xUSDC", amount: "1000", payTo: "0xPAYTO", extra: { name: "USDC", version: "2" } }
-];
-const config = { verification_mode: "x402_facilitator", x402: { accepts, facilitator_url: "https://facilitator", settle: true } };
-
-function deps(overrides) {
-  return Object.assign(
-    {
-      createFacilitator: () => ({}),
-      verifyX402Payment: async () => ({ ok: true, authorization: { payer: "0xPAYER", paymentRequirements: accepts[0] } }),
-      settleX402Payment: async () => ({ ok: true, settlement: { success: true, transaction: "0xTX", network: "eip155:84532" } }),
-      encodeReceipt: (s) => Buffer.from(JSON.stringify(s), "utf8").toString("base64"),
-      executeAuthorized: async (state, payload, authz) => ({ status: 200, payload: { ok: true, ran: payload.task_ref, azmode: authz.verification_mode } }),
-      buildNamedTaskPayload: (ref, body) => ({ command: ref, task_ref: ref, body }),
-      state: {}
-    },
-    overrides || {}
-  );
-}
-
-function send(params, ctxOverrides) {
-  return handleA2ARpc(
-    { jsonrpc: "2.0", id: 1, method: "message/send", params },
-    Object.assign({ config, resourceUrl: "https://xytara.onrender.com/v1/a2a", deps: deps() }, ctxOverrides || {})
-  );
-}
-
-async function main() {
-  // 1. Unpaid -> input-required + x402 requirements in-band.
-  let out = await send({ message: { metadata: { task_ref: "a2a.negotiate" } } });
-  assert.strictEqual(out.http, 200);
-  assert.strictEqual(out.body.result.status.state, "input-required");
-  assert.strictEqual(out.body.result.status.message.metadata[META_STATUS], "payment-required");
-  assert.deepStrictEqual(out.body.result.status.message.metadata[META_REQUIRED].accepts, accepts);
-
-  // 2. Paid -> completed + PAYMENT-RESPONSE + executed through the x402 authz context.
-  out = await send({ message: { metadata: { task_ref: "a2a.negotiate", [META_PAYLOAD]: "BASE64PAYLOAD" } } });
-  assert.strictEqual(out.body.result.status.state, "completed");
-  assert.strictEqual(out.body.result.status.message.metadata[META_STATUS], "payment-completed");
-  assert.ok(out.headers && out.headers["PAYMENT-RESPONSE"], "settled 200 must carry PAYMENT-RESPONSE");
-  assert.strictEqual(out.body.result.artifacts[0].parts[0].data.ran, "a2a.negotiate");
-  assert.strictEqual(out.body.result.artifacts[0].parts[0].data.azmode, "x402_facilitator");
-
-  // 2b. Paid but the skill execution fails -> "failed", and the payment is NOT settled
-  // (verify -> execute -> settle: a failed skill never charges the paying agent).
-  let settleCalls = 0;
-  out = await send(
-    { message: { metadata: { task_ref: "a2a.negotiate", [META_PAYLOAD]: "B64" } } },
-    { deps: deps({
-      executeAuthorized: async () => ({ status: 500, payload: { ok: false, reason: "boom" } }),
-      settleX402Payment: async () => { settleCalls += 1; return { ok: true, settlement: { success: true } }; }
-    }) }
-  );
-  assert.strictEqual(out.body.result.status.state, "failed");
-  assert.strictEqual(out.body.result.status.message.metadata[META_STATUS], "not-charged");
-  assert.strictEqual(settleCalls, 0, "a failed skill must not be settled");
-  assert.ok(!(out.headers && out.headers["PAYMENT-RESPONSE"]), "nothing settled, so no receipt");
-  assert.strictEqual(out.body.result.artifacts.length, 0);
-
-  // 2c. A skill nothing can execute -> refused up front: no payment requested at all.
-  out = await send(
-    { message: { metadata: { task_ref: "a2a.negotiate" } } },
-    { deps: deps({ assessExecutability: () => ({ ok: false, payload: { reason: "capability_not_executable", detail: "no target", executable_task_refs: ["adapter.mcp.invoke"] } }) }) }
-  );
-  assert.strictEqual(out.body.result.status.state, "failed");
-  assert.strictEqual(out.body.result.status.message.metadata[META_STATUS], "not-required");
-  assert.ok(/adapter\.mcp\.invoke/.test(out.body.result.status.message.metadata[META_ERROR]), "the refusal names what IS executable");
-
-  // 2d. Settle times out but the authorization is used on-chain -> completed, not a lost payment.
-  out = await send(
-    { message: { metadata: { task_ref: "a2a.negotiate", [META_PAYLOAD]: "B64" } } },
-    { deps: deps({
-      verifyX402Payment: async () => ({ ok: true, authorization: { payer: "0xPAYER", paymentRequirements: accepts[0], paymentPayload: { payload: { authorization: { from: "0xPAYER", nonce: "0x01" } } } } }),
-      settleX402Payment: async () => ({ ok: false, reason: "facilitator_unreachable" }),
-      confirmAuthorizationUsed: async () => true
-    }) }
-  );
-  assert.strictEqual(out.body.result.status.state, "completed", "a settled-on-chain payment delivers despite the facilitator timeout");
-
-  // 3. Verify fails -> payment-rejected.
-  out = await send(
-    { message: { metadata: { [META_PAYLOAD]: "BAD" } } },
-    { deps: deps({ verifyX402Payment: async () => ({ ok: false, reason: "payment_verification_failed", detail: "insufficient_balance" }) }) }
-  );
-  assert.strictEqual(out.body.result.status.state, "failed");
-  assert.strictEqual(out.body.result.status.message.metadata[META_STATUS], "payment-rejected");
-
-  // 4. Settle fails -> payment-failed.
-  out = await send(
-    { message: { metadata: { [META_PAYLOAD]: "OK" } } },
-    { deps: deps({ settleX402Payment: async () => ({ ok: false, reason: "payment_settlement_failed", detail: "facilitator" }) }) }
-  );
-  assert.strictEqual(out.body.result.status.message.metadata[META_STATUS], "payment-failed");
-
-  // 5. Unknown method -> -32601.
-  out = await handleA2ARpc({ jsonrpc: "2.0", id: 9, method: "tasks/cancel" }, { config, resourceUrl: "x", deps: deps() });
-  assert.strictEqual(out.body.error.code, -32601);
-
-  // 6. x402 mode off -> -32010.
-  out = await handleA2ARpc(
-    { jsonrpc: "2.0", id: 9, method: "message/send", params: { message: {} } },
-    { config: { verification_mode: "local_signed", x402: { accepts } }, resourceUrl: "x", deps: deps() }
-  );
-  assert.strictEqual(out.body.error.code, -32010);
-
-  // 7. Non-2.0 envelope -> -32600.
-  out = await handleA2ARpc({ id: 1, method: "message/send" }, { config, resourceUrl: "x", deps: deps() });
-  assert.strictEqual(out.body.error.code, -32600);
-
-  console.log("verify_a2a_rpc: all A2A x402 JSON-RPC checks passed");
-}
-
-main().catch((error) => {
-  console.error("verify_a2a_rpc failed:", error && error.message ? error.message : error);
-  process.exitCode = 1;
-});