@singularity-layer/grid 0.7.0 → 0.9.0

package/dist/index.mjs

@@ -449,161 +449,406 @@ var GridClient = class {
     }
     if (!sawFinal) throw new SGLAPIError(502, "stream ended before final chunk (truncated)");
   }
-  // -- Processor helpers ----------------------------------------------------
-  async requestWithWalletAuth(method, path, wallet, body) {
-    const url = `${this.baseUrl}${path}`;
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), this.timeout);
-    const reqHeaders = {
-      ...this.headers,
-      "X-Auth-Address": wallet.address,
-      "X-Auth-Chain": wallet.chain ?? "solana",
-      "X-Auth-Signature": wallet.signature,
-      "X-Auth-Timestamp": wallet.timestamp,
-      "X-Auth-Nonce": wallet.nonce
-    };
-    let response;
-    try {
-      response = await fetch(url, {
-        method,
-        headers: reqHeaders,
-        body: body ? JSON.stringify(body) : void 0,
-        signal: controller.signal
-      });
-    } catch (err) {
-      if (err instanceof Error && err.name === "AbortError") {
-        throw new SGLConnectionError(`Request to ${url} timed out`);
-      }
-      throw new SGLConnectionError(
-        `Could not connect to ${this.baseUrl}: ${err instanceof Error ? err.message : String(err)}`
-      );
-    } finally {
-      clearTimeout(timer);
+};
+
+// src/vault.ts
+import { gcm } from "@noble/ciphers/aes";
+import { scrypt } from "@noble/hashes/scrypt";
+var VAULT_URL = "https://compute.x402layer.cc";
+var SCRYPT_PARAMS = { N: 1 << 17, r: 8, p: 1 };
+var SCRYPT_MIN_N = 1 << 15;
+var te = new TextEncoder();
+var td = new TextDecoder();
+function aadBytes(aad) {
+  const { agentId, backupId, formatVersion, userId } = aad;
+  return te.encode(JSON.stringify({ agentId, backupId, formatVersion, userId }));
+}
+function b64(x) {
+  let s = "";
+  for (const b of x) s += String.fromCharCode(b);
+  return btoa(s);
+}
+function unb64(s) {
+  const bin = atob(s);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+function rand(n) {
+  const out = new Uint8Array(n);
+  crypto.getRandomValues(out);
+  return out;
+}
+function encryptEnvelope(plaintext, passphrase, aad) {
+  const salt = rand(16);
+  const kek = scrypt(te.encode(passphrase), salt, { ...SCRYPT_PARAMS, dkLen: 32 });
+  const dek = rand(32);
+  const aadBuf = aadBytes(aad);
+  const dekNonce = rand(12);
+  const wrapped = gcm(kek, dekNonce, aadBuf).encrypt(dek);
+  const blobNonce = rand(12);
+  const body = gcm(dek, blobNonce, aadBuf).encrypt(plaintext);
+  const header = te.encode(JSON.stringify({
+    formatVersion: 1,
+    kdf: "scrypt",
+    kdfParams: { ...SCRYPT_PARAMS, salt: b64(salt) },
+    cipher: "aes-256-gcm",
+    wrappedDek: { nonce: b64(dekNonce), ciphertext: b64(wrapped) },
+    blobNonce: b64(blobNonce),
+    aad
+  }));
+  const out = new Uint8Array(4 + header.length + body.length);
+  new DataView(out.buffer).setUint32(0, header.length, false);
+  out.set(header, 4);
+  out.set(body, 4 + header.length);
+  return out;
+}
+function decryptEnvelope(blob, passphrase, aad) {
+  if (blob.length < 4) throw new SGLAPIError(0, "malformed blob: too short");
+  const headerLen = new DataView(blob.buffer, blob.byteOffset).getUint32(0, false);
+  if (4 + headerLen > blob.length) throw new SGLAPIError(0, "malformed blob: header length out of bounds");
+  let header;
+  try {
+    header = JSON.parse(td.decode(blob.subarray(4, 4 + headerLen)));
+  } catch {
+    throw new SGLAPIError(0, "malformed blob: invalid header JSON");
+  }
+  if (header.kdf !== "scrypt") {
+    throw new SGLAPIError(0, `this backup uses ${String(header.kdf)} key derivation \u2014 restore it with the agentvault CLI`);
+  }
+  const p = header.kdfParams ?? {};
+  if (!Number.isInteger(p.N) || p.N < SCRYPT_MIN_N || p.N > SCRYPT_PARAMS.N || (p.N & p.N - 1) !== 0 || !Number.isInteger(p.r) || p.r < 8 || p.r > 16 || !Number.isInteger(p.p) || p.p < 1 || p.p > 4 || typeof p.salt !== "string" || !header.wrappedDek?.nonce || !header.wrappedDek?.ciphertext || !header.blobNonce) {
+    throw new SGLAPIError(0, "malformed blob: unsupported header parameters");
+  }
+  const salt = unb64(p.salt);
+  if (salt.length < 16) throw new SGLAPIError(0, "malformed blob: salt too short");
+  const kek = scrypt(te.encode(passphrase), salt, { N: p.N, r: p.r, p: p.p, dkLen: 32 });
+  const aadBuf = aadBytes(aad);
+  try {
+    const dek = gcm(kek, unb64(header.wrappedDek.nonce), aadBuf).decrypt(unb64(header.wrappedDek.ciphertext));
+    return gcm(dek, unb64(header.blobNonce), aadBuf).decrypt(blob.subarray(4 + headerLen));
+  } catch {
+    throw new SGLAPIError(0, "incorrect passphrase or corrupted backup");
+  }
+}
+function parseAadFromKey(r2Key) {
+  const parts = r2Key.split("/");
+  if (parts.length !== 5 || parts[0] !== "backups" || parts[4] !== "blob.enc" || !parts[1] || !parts[2] || !parts[3]) {
+    throw new SGLAPIError(0, `malformed r2 key: ${r2Key}`);
+  }
+  return { userId: parts[1], agentId: parts[2], backupId: parts[3], formatVersion: 1 };
+}
+var VaultClient = class _VaultClient {
+  constructor(options) {
+    const base = (options.baseUrl ?? VAULT_URL).replace(/\/+$/, "");
+    const u = new URL(base);
+    const local = ["localhost", "127.0.0.1", "[::1]"].includes(u.hostname);
+    if (u.protocol !== "https:" && !local) {
+      throw new SGLAPIError(0, "baseUrl must be https (the API key travels in a header)");
     }
-    if (!response.ok) {
-      let errorBody;
-      let message = response.statusText;
-      try {
-        errorBody = await response.json();
-        const err = errorBody?.error;
-        if (typeof err === "string") message = err;
-        else if (err && typeof err === "object" && "message" in err)
-          message = String(err.message);
-      } catch {
-      }
-      if (response.status === 401 || response.status === 403) {
-        throw new SGLAuthError(response.status, message, errorBody);
-      }
-      if (response.status === 404) {
-        throw new SGLNotFoundError(message, errorBody);
+    if (u.username || u.password || u.search || u.hash) {
+      throw new SGLAPIError(0, "baseUrl must be a bare origin");
+    }
+    this.base = base;
+    this.apiKey = options.apiKey;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  static id(v) {
+    if (!/^[0-9a-fA-F-]{36}$/.test(v)) throw new SGLAPIError(0, `not a snapshot id: ${v}`);
+    return v.toLowerCase();
+  }
+  async call(method, path, body) {
+    const res = await this.fetchImpl(`${this.base}${path}`, {
+      method,
+      headers: {
+        "x-api-key": this.apiKey,
+        ...body !== void 0 ? { "content-type": "application/json" } : {}
+      },
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) throw new SGLAPIError(res.status, String(data.error ?? `request failed: ${res.status}`));
+    return data;
+  }
+  async agents() {
+    return (await this.call("GET", "/backups/agents")).agents;
+  }
+  async createAgent(name, framework) {
+    return (await this.call("POST", "/backups/agents", { name, framework })).agent;
+  }
+  async snapshots(agentId) {
+    const q = agentId ? `?agentId=${encodeURIComponent(agentId)}` : "";
+    return (await this.call("GET", `/backups${q}`)).backups;
+  }
+  async usage() {
+    return this.call("GET", "/backups/usage");
+  }
+  /** Activate Vault Pro ($3/mo from credits). */
+  async subscribePro() {
+    return this.call("POST", "/backups/subscribe");
+  }
+  async deleteSnapshot(id) {
+    await this.call("DELETE", `/backups/${_VaultClient.id(id)}`);
+  }
+  /**
+   * Encrypt + upload arbitrary payload bytes (e.g. a tarball you packed) as a
+   * snapshot of `agentId`. Returns the snapshot id.
+   */
+  async backupBytes(agentId, payload, passphrase) {
+    const res = await this.call(
+      "POST",
+      "/backups",
+      { agentId, sizeBytes: payload.length }
+    );
+    const blob = encryptEnvelope(payload, passphrase, parseAadFromKey(res.r2Key));
+    const up = await this.fetchImpl(res.uploadUrl, {
+      method: "PUT",
+      body: blob,
+      headers: { "content-type": "application/octet-stream" }
+    });
+    if (!up.ok) throw new SGLAPIError(up.status, `upload failed: ${up.status}`);
+    const digest = await crypto.subtle.digest("SHA-256", blob);
+    const sha2562 = [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+    await this.call("POST", `/backups/${res.backupId}/complete`, { sha256: sha2562 });
+    return res.backupId;
+  }
+  /** Download + decrypt a snapshot's payload bytes. */
+  async restoreBytes(snapshotId, passphrase) {
+    const info = await this.call("GET", `/backups/${_VaultClient.id(snapshotId)}/restore`);
+    const dl = await this.fetchImpl(info.downloadUrl);
+    if (!dl.ok) throw new SGLAPIError(dl.status, `download failed: ${dl.status}`);
+    const blob = new Uint8Array(await dl.arrayBuffer());
+    return decryptEnvelope(blob, passphrase, parseAadFromKey(info.r2Key));
+  }
+};
+
+// src/processors.ts
+var PROCESSORS_BASE_URL = "https://processors.x402compute.cc";
+var DEFAULT_TIMEOUT2 = 6e4;
+function isLoopback(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]" || hostname === "::1";
+}
+function parseBaseUrl(raw) {
+  let u;
+  try {
+    u = new URL(raw);
+  } catch {
+    throw new Error(`ProcessorsClient baseUrl is not a valid URL: ${raw}`);
+  }
+  if (u.protocol !== "https:" && !(u.protocol === "http:" && isLoopback(u.hostname))) {
+    throw new Error(
+      `ProcessorsClient baseUrl must be https (or http on localhost); got ${u.protocol}//${u.hostname}. The API key is a long-lived full-control credential and must not be sent in the clear.`
+    );
+  }
+  return u;
+}
+function keyAllowedOnHost(u) {
+  return u.origin === new URL(PROCESSORS_BASE_URL).origin || isLoopback(u.hostname);
+}
+var ProcessorsClient = class {
+  constructor(options = {}) {
+    const parsed = parseBaseUrl(options.baseUrl ?? PROCESSORS_BASE_URL);
+    this.baseUrl = (options.baseUrl ?? PROCESSORS_BASE_URL).replace(/\/+$/, "");
+    this.timeout = options.timeoutMs ?? DEFAULT_TIMEOUT2;
+    this.headers = { Accept: "application/json", "Content-Type": "application/json" };
+    if (options.apiKey) {
+      if (!keyAllowedOnHost(parsed) && !options.allowKeyOnCustomHost) {
+        throw new Error(
+          `ProcessorsClient refuses to send an API key to ${parsed.origin}. It is neither ${new URL(PROCESSORS_BASE_URL).origin} nor loopback. If you really do run your own processors host, pass allowKeyOnCustomHost: true.`
+        );
       }
-      throw new SGLAPIError(response.status, message, errorBody);
+      this.headers["X-API-Key"] = options.apiKey;
     }
-    if (response.status === 204) return {};
-    return await response.json();
   }
-  async requestWithPayment(method, path, body, paymentHeader) {
+  async request(method, path, body, extraHeaders, sendApiKey = true) {
     const url = `${this.baseUrl}${path}`;
     const controller = new AbortController();
     const timer = setTimeout(() => controller.abort(), this.timeout);
-    const reqHeaders = { ...this.headers };
-    if (paymentHeader) {
-      reqHeaders["X-Payment"] = paymentHeader;
-    }
     let response;
     try {
+      const base = { ...this.headers };
+      if (!sendApiKey) delete base["X-API-Key"];
       response = await fetch(url, {
         method,
-        headers: reqHeaders,
-        body: body ? JSON.stringify(body) : void 0,
+        headers: { ...base, ...extraHeaders },
+        body: body === void 0 ? void 0 : JSON.stringify(body),
         signal: controller.signal
       });
     } catch (err) {
-      if (err instanceof Error && err.name === "AbortError") {
-        throw new SGLConnectionError(`Request to ${url} timed out`);
-      }
       throw new SGLConnectionError(
-        `Could not connect to ${this.baseUrl}: ${err instanceof Error ? err.message : String(err)}`
+        `Could not reach ${url}: ${err instanceof Error ? err.message : String(err)}`
       );
     } finally {
       clearTimeout(timer);
     }
-    if (response.status === 402) {
-      const requirements = await response.json();
-      throw new SGLAPIError(402, "Payment required", requirements);
+    if (response.status === 204) return {};
+    const text = await response.text();
+    let parsed;
+    try {
+      parsed = text ? JSON.parse(text) : void 0;
+    } catch {
+      parsed = text;
     }
     if (!response.ok) {
-      let errorBody;
-      let message = response.statusText;
-      try {
-        errorBody = await response.json();
-        const err = errorBody?.error;
-        if (typeof err === "string") message = err;
-      } catch {
+      const body2 = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : void 0;
+      const detail = typeof body2?.detail === "string" && body2.detail || typeof body2?.error === "string" && body2.error || "";
+      if (response.status === 401 || response.status === 403) {
+        throw new SGLAuthError(response.status, detail || "unauthorized", body2);
       }
-      throw new SGLAPIError(response.status, message, errorBody);
+      if (response.status === 404) {
+        throw new SGLNotFoundError(detail || "not found", body2);
+      }
+      throw new SGLAPIError(response.status, detail || `HTTP ${response.status}`, body2);
     }
-    return await response.json();
+    return parsed;
   }
-  // -- Processors -----------------------------------------------------------
-  async deployProcessor(wallet, options) {
-    return this.requestWithWalletAuth(
-      "POST",
-      "/grid/processors",
-      wallet,
-      options
-    );
+  // ── Discovery ────────────────────────────────────────────────────────────
+  /**
+   * The public catalogue.
+   *
+   * Sends NO credential, even when the client holds one. `GET /processors` is owner-scoped when a
+   * key is presented and public otherwise, so passing the key here would silently return your own
+   * processors instead of the catalogue — the opposite of what the name promises. Use `list()`
+   * when you want yours.
+   */
+  async catalogue() {
+    return this.request("GET", "/processors", void 0, void 0, false);
   }
-  async invokeProcessor(processorName, input, options) {
-    const body = { input };
-    if (options?.paymentToken) body.payment_token = options.paymentToken;
-    return this.requestWithPayment(
-      "POST",
-      `/grid/processors/${encodeURIComponent(processorName)}/invoke`,
-      body,
-      options?.paymentHeader
-    );
+  /** Processors owned by this key's wallet. Needs `processors:read`. */
+  async list() {
+    return this.request("GET", "/processors");
   }
-  async listProcessors(options) {
-    const params = new URLSearchParams();
-    if (options?.owner) params.set("owner", options.owner);
-    if (options?.page != null) params.set("page", String(options.page));
-    if (options?.limit != null) params.set("limit", String(options.limit));
-    const qs = params.toString();
+  /** Owner projection when the key owns it, public projection otherwise. */
+  async get(slug) {
+    return this.request("GET", `/processors/${encodeURIComponent(slug)}`);
+  }
+  // ── Lifecycle (needs processors:write) ───────────────────────────────────
+  /**
+   * Deploy. The wallet behind the key becomes `owner_wallet`, which is also the x402 `payTo` and
+   * the runtime-billing account — so the key must be minted on a SOLANA wallet or this returns
+   * `400 solana_wallet_required`.
+   *
+   * The `invoke_token` in the response is shown once and never again.
+   */
+  async deploy(input) {
+    return this.request("POST", "/processors", input);
+  }
+  /** Push new code, a new manifest, or both. Omitting `manifest` keeps the stored one. */
+  async update(slug, input) {
+    return this.request("PATCH", `/processors/${encodeURIComponent(slug)}`, input);
+  }
+  /**
+   * Delete. **Irreversible, and the slug is burned forever** — it can never be reused, by you or
+   * anyone. In-flight runs finish first; the code is wiped when they drain.
+   */
+  async delete(slug) {
+    return this.request("DELETE", `/processors/${encodeURIComponent(slug)}`);
+  }
+  /** Stop or restart traffic WITHOUT losing the slug. This is the switch, not `delete`. */
+  async setPaused(slug, paused) {
+    return this.request("PUT", `/processors/${encodeURIComponent(slug)}/pause`, { paused });
+  }
+  /**
+   * List or unlist publicly. Instant, no review step.
+   *
+   * Unlisting is NOT stopping: an unlisted processor keeps answering anyone holding the URL or an
+   * invoke token, earning nothing while still drawing compute from your balance. Use `setPaused`.
+   */
+  async setListing(slug, listed) {
+    return this.request("PUT", `/processors/${encodeURIComponent(slug)}/listing`, { listed });
+  }
+  /** Set secret VALUES. Each name must already be declared in `manifest.secrets`. */
+  async setSecrets(slug, values) {
+    return this.request("PUT", `/processors/${encodeURIComponent(slug)}/secrets`, { values });
+  }
+  /** Mint a new invoke token. The old one stops working immediately. */
+  async rotateToken(slug) {
+    return this.request("POST", `/processors/${encodeURIComponent(slug)}/rotate-token`);
+  }
+  // ── Observability ────────────────────────────────────────────────────────
+  async runs(slug) {
+    return this.request("GET", `/processors/${encodeURIComponent(slug)}/runs`);
+  }
+  async run_(slug, runId) {
     return this.request(
       "GET",
-      `/grid/processors${qs ? `?${qs}` : ""}`
+      `/processors/${encodeURIComponent(slug)}/runs/${encodeURIComponent(runId)}`
     );
   }
-  async getProcessor(processorId) {
-    return this.request("GET", `/grid/processors/${processorId}`);
+  /** Sales (paid straight to your wallet, with the on-chain tx per row) and runtime spend. */
+  async earnings(slug) {
+    return this.request("GET", `/processors/${encodeURIComponent(slug)}/earnings`);
   }
-  async deleteProcessor(processorId, wallet) {
-    return this.requestWithWalletAuth(
-      "DELETE",
-      `/grid/processors/${processorId}`,
-      wallet
-    );
+  /** The processor's own key/value state. Read-only from out here, by design. */
+  async kv(slug) {
+    return this.request("GET", `/processors/${encodeURIComponent(slug)}/kv`);
   }
-  async getProcessorLogs(processorId, wallet, options) {
-    const params = new URLSearchParams();
-    if (options?.page != null) params.set("page", String(options.page));
-    if (options?.limit != null) params.set("limit", String(options.limit));
-    const qs = params.toString();
-    return this.requestWithWalletAuth(
-      "GET",
-      `/grid/processors/${processorId}/logs${qs ? `?${qs}` : ""}`,
-      wallet
+  // ── Webhooks ─────────────────────────────────────────────────────────────
+  async getWebhook(slug) {
+    return this.request("GET", `/processors/${encodeURIComponent(slug)}/webhook`);
+  }
+  /**
+   * Register or replace. We immediately POST a signed verification to the URL: it must answer 2xx
+   * or the webhook stays registered-but-inactive and delivers nothing. The signing secret comes
+   * back EXACTLY ONCE.
+   */
+  async setWebhook(slug, url) {
+    return this.request("PUT", `/processors/${encodeURIComponent(slug)}/webhook`, { url });
+  }
+  async deleteWebhook(slug) {
+    return this.request("DELETE", `/processors/${encodeURIComponent(slug)}/webhook`);
+  }
+  async testWebhook(slug) {
+    return this.request("POST", `/processors/${encodeURIComponent(slug)}/webhook/test`);
+  }
+  // ── Invoking ─────────────────────────────────────────────────────────────
+  /**
+   * Run YOUR OWN processor with the invoke token from `deploy()`.
+   *
+   * Not the API key: the run route deliberately does not read a key as an ownership claim, because
+   * it is the only route with both a money path and an anonymous buyer lane. You pay for the
+   * compute; nobody pays at call time.
+   */
+  async run(slug, input, invokeToken) {
+    return this.request(
+      "POST",
+      `/processors/${encodeURIComponent(slug)}/run`,
+      { input },
+      { Authorization: `Bearer ${invokeToken}` },
+      false
     );
   }
+  /**
+   * Run someone else's processor as a buyer, with an x402 payment header.
+   *
+   * Call once WITHOUT `paymentHeader` to get the 402 and its `accepts` array — one entry per chain
+   * that publisher takes. Match on `network`, pay that entry, and retry with the header.
+   *
+   * Re-sending the SAME header returns the run that payment already bought and does NOT charge
+   * again. That is the recovery path for every failure mode, because **there are no refunds**: the
+   * money went straight to the publisher and the platform never held it.
+   */
+  async runWithPayment(slug, input, paymentHeader, acceptNetworks) {
+    const extra = {};
+    if (paymentHeader) extra["X-Payment"] = paymentHeader;
+    if (acceptNetworks?.length) extra["X-Accept-Networks"] = acceptNetworks.join(",");
+    return this.request("POST", `/processors/${encodeURIComponent(slug)}/run`, { input }, extra, false);
+  }
 };
 export {
   DEFAULT_BASE_URL,
   GridClient,
+  PROCESSORS_BASE_URL,
+  ProcessorsClient,
   SGLAPIError,
   SGLAuthError,
   SGLConnectionError,
   SGLError,
-  SGLNotFoundError
+  SGLNotFoundError,
+  VAULT_URL,
+  VaultClient,
+  decryptEnvelope,
+  encryptEnvelope,
+  parseAadFromKey
 };
 //# sourceMappingURL=index.mjs.map