@singularity-layer/grid 0.8.0 → 0.9.0

package/dist/index.js

@@ -32,6 +32,8 @@ var index_exports = {};
 __export(index_exports, {
   DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
   GridClient: () => GridClient,
+  PROCESSORS_BASE_URL: () => PROCESSORS_BASE_URL,
+  ProcessorsClient: () => ProcessorsClient,
   SGLAPIError: () => SGLAPIError,
   SGLAuthError: () => SGLAuthError,
   SGLConnectionError: () => SGLConnectionError,
@@ -496,153 +498,6 @@ 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);
-    }
-    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);
-      }
-      throw new SGLAPIError(response.status, message, errorBody);
-    }
-    if (response.status === 204) return {};
-    return await response.json();
-  }
-  async requestWithPayment(method, path, body, paymentHeader) {
-    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 {
-      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);
-    }
-    if (response.status === 402) {
-      const requirements = await response.json();
-      throw new SGLAPIError(402, "Payment required", requirements);
-    }
-    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 {
-      }
-      throw new SGLAPIError(response.status, message, errorBody);
-    }
-    return await response.json();
-  }
-  // -- Processors -----------------------------------------------------------
-  async deployProcessor(wallet, options) {
-    return this.requestWithWalletAuth(
-      "POST",
-      "/grid/processors",
-      wallet,
-      options
-    );
-  }
-  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
-    );
-  }
-  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();
-    return this.request(
-      "GET",
-      `/grid/processors${qs ? `?${qs}` : ""}`
-    );
-  }
-  async getProcessor(processorId) {
-    return this.request("GET", `/grid/processors/${processorId}`);
-  }
-  async deleteProcessor(processorId, wallet) {
-    return this.requestWithWalletAuth(
-      "DELETE",
-      `/grid/processors/${processorId}`,
-      wallet
-    );
-  }
-  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
-    );
-  }
 };
 
 // src/vault.ts
@@ -815,10 +670,226 @@ var VaultClient = class _VaultClient {
     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.`
+        );
+      }
+      this.headers["X-API-Key"] = options.apiKey;
+    }
+  }
+  async request(method, path, body, extraHeaders, sendApiKey = true) {
+    const url = `${this.baseUrl}${path}`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeout);
+    let response;
+    try {
+      const base = { ...this.headers };
+      if (!sendApiKey) delete base["X-API-Key"];
+      response = await fetch(url, {
+        method,
+        headers: { ...base, ...extraHeaders },
+        body: body === void 0 ? void 0 : JSON.stringify(body),
+        signal: controller.signal
+      });
+    } catch (err) {
+      throw new SGLConnectionError(
+        `Could not reach ${url}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    } finally {
+      clearTimeout(timer);
+    }
+    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) {
+      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);
+      }
+      if (response.status === 404) {
+        throw new SGLNotFoundError(detail || "not found", body2);
+      }
+      throw new SGLAPIError(response.status, detail || `HTTP ${response.status}`, body2);
+    }
+    return parsed;
+  }
+  // ── 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);
+  }
+  /** Processors owned by this key's wallet. Needs `processors:read`. */
+  async list() {
+    return this.request("GET", "/processors");
+  }
+  /** 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",
+      `/processors/${encodeURIComponent(slug)}/runs/${encodeURIComponent(runId)}`
+    );
+  }
+  /** 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`);
+  }
+  /** 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`);
+  }
+  // ── 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);
+  }
+};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_BASE_URL,
   GridClient,
+  PROCESSORS_BASE_URL,
+  ProcessorsClient,
   SGLAPIError,
   SGLAuthError,
   SGLConnectionError,