@paybox-sh/sdk 0.1.0

package/dist/chunk-23N5RHOB.js

@@ -0,0 +1,621 @@
+// src/auth.ts
+import { spawn } from "node:child_process";
+import { createHash, randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+function mcpResource(baseUrl) {
+  return `${baseUrl.replace(/\/+$/, "")}/mcp`;
+}
+async function metadata(baseUrl) {
+  const url = `${baseUrl.replace(/\/+$/, "")}/.well-known/oauth-authorization-server`;
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`could not read OAuth metadata from ${url} (${res.status})`);
+  }
+  return await res.json();
+}
+function base64url(b) {
+  return b.toString("base64url");
+}
+function pkce() {
+  const verifier = base64url(randomBytes(32));
+  const challenge = base64url(createHash("sha256").update(verifier).digest());
+  return { verifier, challenge };
+}
+function openBrowser(url) {
+  const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["rundll32", ["url.dll,FileProtocolHandler", url]] : ["xdg-open", [url]];
+  try {
+    spawn(cmd, [...args], { stdio: "ignore", detached: true }).unref();
+  } catch {
+  }
+}
+var CALLBACK_PAGE = '<!doctype html><meta charset=utf-8><title>Paybox</title><body style="font:16px system-ui;padding:3rem;text-align:center"><h2>Paybox CLI connected</h2><p>You can close this tab and return to the terminal.</p>';
+async function loginLoopback(baseUrl, opts = {}) {
+  const scope = opts.scope ?? "mcp offline_access";
+  const clientName = opts.clientName ?? "Paybox CLI";
+  const log = opts.log ?? ((m) => console.error(m));
+  const meta = await metadata(baseUrl);
+  const resource = mcpResource(baseUrl);
+  let resolveCode;
+  let rejectCode;
+  const codePromise = new Promise((res, rej) => {
+    resolveCode = res;
+    rejectCode = rej;
+  });
+  const server = createServer((req, res) => {
+    const u = new URL(req.url ?? "/", "http://127.0.0.1");
+    if (u.pathname !== "/callback") {
+      res.writeHead(404).end();
+      return;
+    }
+    res.writeHead(200, { "content-type": "text/html" }).end(CALLBACK_PAGE);
+    const code = u.searchParams.get("code");
+    if (code) resolveCode({ code, state: u.searchParams.get("state") });
+    else rejectCode(new Error(u.searchParams.get("error") ?? "authorization failed"));
+  });
+  await new Promise((r) => server.listen(0, "127.0.0.1", r));
+  const port = server.address().port;
+  const redirectUri = `http://127.0.0.1:${port}/callback`;
+  const timeoutMs = opts.timeoutMs ?? 3e5;
+  const timer = setTimeout(
+    () => rejectCode(new Error(`login timed out after ${Math.round(timeoutMs / 1e3)}s \u2014 no approval received`)),
+    timeoutMs
+  );
+  timer.unref();
+  try {
+    const reg = await fetch(meta.registration_endpoint, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        client_name: clientName,
+        redirect_uris: [redirectUri],
+        token_endpoint_auth_method: "none",
+        grant_types: ["authorization_code", "refresh_token"],
+        response_types: ["code"]
+      })
+    });
+    if (!reg.ok) throw new Error(`client registration failed (${reg.status}): ${await reg.text()}`);
+    const { client_id: clientId } = await reg.json();
+    const { verifier, challenge } = pkce();
+    const state = base64url(randomBytes(16));
+    const authUrl = `${meta.authorization_endpoint}?response_type=code&client_id=${encodeURIComponent(clientId)}&redirect_uri=${encodeURIComponent(redirectUri)}&code_challenge=${challenge}&code_challenge_method=S256&scope=${encodeURIComponent(scope)}&state=${state}&resource=${encodeURIComponent(resource)}`;
+    log(`Opening your browser to approve access:
+  ${authUrl}
+`);
+    openBrowser(authUrl);
+    const { code, state: returnedState } = await codePromise;
+    if (returnedState !== state) throw new Error("OAuth state mismatch \u2014 aborting");
+    const form = new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: redirectUri,
+      client_id: clientId,
+      code_verifier: verifier,
+      resource
+    });
+    const tok = await fetch(meta.token_endpoint, {
+      method: "POST",
+      headers: { "content-type": "application/x-www-form-urlencoded" },
+      body: form
+    });
+    if (!tok.ok) throw new Error(`token exchange failed (${tok.status}): ${await tok.text()}`);
+    const t = await tok.json();
+    return {
+      clientId,
+      accessToken: t.access_token,
+      refreshToken: t.refresh_token,
+      expiresAt: t.expires_in ? Date.now() + t.expires_in * 1e3 : void 0,
+      resource
+    };
+  } finally {
+    clearTimeout(timer);
+    server.close();
+  }
+}
+async function refreshTokens(baseUrl, current) {
+  if (!current.refreshToken) throw new Error("no refresh token \u2014 run `paybox login` again");
+  const meta = await metadata(baseUrl);
+  const resource = current.resource ?? mcpResource(baseUrl);
+  const form = new URLSearchParams({
+    grant_type: "refresh_token",
+    refresh_token: current.refreshToken,
+    client_id: current.clientId,
+    resource
+  });
+  const res = await fetch(meta.token_endpoint, {
+    method: "POST",
+    headers: { "content-type": "application/x-www-form-urlencoded" },
+    body: form
+  });
+  if (!res.ok) throw new Error(`token refresh failed (${res.status}): ${await res.text()}`);
+  const t = await res.json();
+  return {
+    ...current,
+    accessToken: t.access_token,
+    refreshToken: t.refresh_token ?? current.refreshToken,
+    expiresAt: t.expires_in ? Date.now() + t.expires_in * 1e3 : void 0,
+    resource
+  };
+}
+
+// src/config.ts
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+function configDir() {
+  if (process.env.PAYBOX_CONFIG_DIR) return process.env.PAYBOX_CONFIG_DIR;
+  const base = process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
+  return join(base, "paybox");
+}
+function configFile() {
+  return join(configDir(), "config.json");
+}
+function loadConfig() {
+  try {
+    return JSON.parse(readFileSync(configFile(), "utf8"));
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config) {
+  mkdirSync(configDir(), { recursive: true, mode: 448 });
+  writeFileSync(configFile(), `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+  if (process.platform !== "win32") chmodSync(configFile(), 384);
+}
+
+// node_modules/.pnpm/@paybox+mcp-app@file+..+mcp-app_@modelcontextprotocol+sdk@1.29.0_zod@4.4.3__bn.js@5.2.3_ac1e09a20c76a1143611be5dd3d4f9db/node_modules/@paybox/mcp-app/src/creds.ts
+var TOKEN_PREFIX = "pbxk1.";
+function validateHex(s, label) {
+  const trimmed = s.trim();
+  if (!trimmed) return `${label} is required`;
+  const body = trimmed.startsWith("0x") || trimmed.startsWith("0X") ? trimmed.slice(2) : trimmed;
+  if (body.length === 0) return `${label} is empty`;
+  if (body.length % 2 !== 0) return `${label} must have an even number of hex digits`;
+  if (!/^[0-9a-fA-F]+$/.test(body)) return `${label} must be hexadecimal`;
+  return null;
+}
+function b64urlDecode(s) {
+  let b = s.replace(/-/g, "+").replace(/_/g, "/");
+  while (b.length % 4) b += "=";
+  return atob(b);
+}
+function parseToken(input) {
+  const t = input.trim();
+  if (!t) return null;
+  const body = t.startsWith(TOKEN_PREFIX) ? t.slice(TOKEN_PREFIX.length) : t;
+  let obj;
+  try {
+    obj = JSON.parse(b64urlDecode(body));
+  } catch {
+    return null;
+  }
+  if (!obj || typeof obj !== "object") return null;
+  const o = obj;
+  const apiPubHex = String(o.p ?? o.apiPubHex ?? "").trim();
+  const apiPrivHex = String(o.s ?? o.apiPrivHex ?? "").trim();
+  if (!apiPubHex || !apiPrivHex) return null;
+  if (validateHex(apiPubHex, "key") || validateHex(apiPrivHex, "key")) return null;
+  return { apiPubHex, apiPrivHex };
+}
+
+// node_modules/.pnpm/@paybox+mcp-app@file+..+mcp-app_@modelcontextprotocol+sdk@1.29.0_zod@4.4.3__bn.js@5.2.3_ac1e09a20c76a1143611be5dd3d4f9db/node_modules/@paybox/mcp-app/src/sign.ts
+import { Buffer } from "buffer";
+import nacl from "tweetnacl";
+import { MoonXEvmSigner, EvmSchemeMismatchError } from "@moon-x/evm-adapter";
+import { MoonXSolanaSigner, SolanaSchemeMismatchError } from "@moon-x/solana-adapter";
+import { Transaction } from "@solana/web3.js";
+import { keccak256, serializeTransaction } from "viem";
+function reviveTx(w) {
+  return {
+    type: "eip1559",
+    to: w.to,
+    value: BigInt(w.value),
+    data: w.data,
+    chainId: w.chainId,
+    gas: BigInt(w.gas),
+    maxPriorityFeePerGas: BigInt(w.maxPriorityFeePerGas),
+    maxFeePerGas: BigInt(w.maxFeePerGas),
+    nonce: w.nonce
+  };
+}
+function hexToBytes(hex) {
+  return new Uint8Array(Buffer.from(hex.replace(/^0x/, ""), "hex"));
+}
+function bytesToHex(bytes) {
+  return Buffer.from(bytes).toString("hex");
+}
+function buildEnvelope(rawSigningPayloadHex, binding, creds) {
+  const signedPayload = {
+    raw_signing_payload: rawSigningPayloadHex.replace(/^0x/, "").toLowerCase(),
+    key_id: binding.keyId,
+    derivation_path: binding.derivationPath,
+    issued_at: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const signedBodyBytes = new TextEncoder().encode(JSON.stringify(signedPayload));
+  const keyPair = nacl.sign.keyPair.fromSeed(hexToBytes(creds.apiPrivHex));
+  const agentSig = nacl.sign.detached(signedBodyBytes, keyPair.secretKey);
+  return {
+    signed_body: bytesToHex(signedBodyBytes),
+    agent_signature: bytesToHex(agentSig)
+  };
+}
+function eip1559SigningHash(tx) {
+  return keccak256(serializeTransaction(reviveTx(tx)));
+}
+function solanaSigningPayload(base64Tx) {
+  const raw = Buffer.from(base64Tx, "base64");
+  let i = 0;
+  let sigCount = 0;
+  let shift = 0;
+  for (; ; ) {
+    const b = raw[i++];
+    sigCount |= (b & 127) << shift;
+    if ((b & 128) === 0) break;
+    shift += 7;
+  }
+  if (sigCount !== 1) {
+    throw new Error(`expected a single-signer solana tx, got ${sigCount} signature slot(s)`);
+  }
+  return bytesToHex(new Uint8Array(raw.subarray(i + 64)));
+}
+function buildSwapEnvelopes(txs, binding, creds) {
+  if (!binding.walletId) {
+    throw new Error("paybox did not supply a wallet id for this operation.");
+  }
+  if (!binding.keyId || !binding.derivationPath) {
+    throw new Error(
+      "This wallet isn't provisioned for signing yet (missing key binding). Re-provision it in the paybox app, then retry."
+    );
+  }
+  return txs.map((t) => {
+    const payload = t.vm === "solana" ? solanaSigningPayload(t.transaction) : eip1559SigningHash(t.transaction);
+    const { signed_body, agent_signature } = buildEnvelope(payload, binding, creds);
+    return { api_pub: creds.apiPubHex, signed_body, agent_signature };
+  });
+}
+function buildIssuedAtEnvelope(creds) {
+  const signedBodyBytes = new TextEncoder().encode(
+    JSON.stringify({ issued_at: (/* @__PURE__ */ new Date()).toISOString() })
+  );
+  const keyPair = nacl.sign.keyPair.fromSeed(hexToBytes(creds.apiPrivHex));
+  const agentSig = nacl.sign.detached(signedBodyBytes, keyPair.secretKey);
+  return {
+    signed_body: bytesToHex(signedBodyBytes),
+    agent_signature: bytesToHex(agentSig)
+  };
+}
+async function signIntent(intent, creds, binding, transport) {
+  if (!binding.walletId) {
+    return { ok: false, error: "paybox did not supply a wallet id for this operation." };
+  }
+  if (!binding.keyId || !binding.derivationPath) {
+    return {
+      ok: false,
+      error: "This wallet isn't provisioned for signing yet (missing key binding). Re-provision it in the paybox app, then retry."
+    };
+  }
+  const ecdsaSign = async (digest) => {
+    const result = await transport(buildEnvelope(digest, binding, creds));
+    const { r, s, recovery_id } = result.signature;
+    if (r == null || s == null || recovery_id == null) {
+      throw new Error("MoonX returned an ECDSA result without {r, s, recovery_id}");
+    }
+    return {
+      r: `0x${r}`,
+      s: `0x${s}`,
+      yParity: recovery_id
+    };
+  };
+  const ed25519Sign = async (message) => {
+    const result = await transport(buildEnvelope(bytesToHex(message), binding, creds));
+    const sig = result.signature.signature;
+    if (!sig) throw new Error("MoonX returned an Ed25519 result without a signature");
+    return hexToBytes(sig);
+  };
+  try {
+    switch (intent.op) {
+      case "message":
+        return {
+          ok: true,
+          artifact: { signature: await new MoonXEvmSigner(ecdsaSign).signMessage(intent.message) }
+        };
+      case "typedData":
+        return {
+          ok: true,
+          artifact: {
+            signature: await new MoonXEvmSigner(ecdsaSign).signTypedData(intent.typedData)
+          }
+        };
+      case "transaction":
+        return {
+          ok: true,
+          artifact: {
+            serializedTransaction: await new MoonXEvmSigner(ecdsaSign).signTransaction(
+              reviveTx(intent.transaction)
+            )
+          }
+        };
+      case "authorization":
+        return {
+          ok: true,
+          artifact: {
+            authorization: await new MoonXEvmSigner(ecdsaSign).signAuthorization(
+              intent.authorization
+            )
+          }
+        };
+      case "solanaMessage": {
+        const sig = await new MoonXSolanaSigner(ed25519Sign, intent.address).signMessage(
+          intent.message
+        );
+        return { ok: true, artifact: { signature: bytesToHex(sig) } };
+      }
+      case "solanaTransaction": {
+        const tx = Transaction.from(Buffer.from(intent.transactionBase64, "base64"));
+        const signed = await new MoonXSolanaSigner(ed25519Sign, intent.address).signTransaction(
+          tx
+        );
+        return {
+          ok: true,
+          artifact: { signedTransactionBase64: Buffer.from(signed).toString("base64") }
+        };
+      }
+      case "raw": {
+        const result = await transport(buildEnvelope(intent.rawSigningPayloadHex, binding, creds));
+        return { ok: true, artifact: { scheme: result.scheme, signature: result.signature } };
+      }
+      default:
+        return { ok: false, error: `unknown op: ${intent.op}` };
+    }
+  } catch (err) {
+    if (err instanceof EvmSchemeMismatchError || err instanceof SolanaSchemeMismatchError) {
+      return { ok: false, error: err.message };
+    }
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, error: message };
+  }
+}
+
+// src/signer.ts
+function credsFromToken(token) {
+  const kp = parseToken(token);
+  if (!kp) {
+    throw new Error("invalid signing key: expected a `pbxk1.` token (keypair only)");
+  }
+  return { apiPubHex: kp.apiPubHex, apiPrivHex: kp.apiPrivHex, savedAt: Date.now() };
+}
+function toBinding(b) {
+  return { walletId: b.wallet_id, keyId: b.key_id ?? "", derivationPath: b.derivation_path ?? "" };
+}
+async function resolveBinding(post, requestId, creds) {
+  const env = buildIssuedAtEnvelope(creds);
+  const r = await post(`/agent/requests/${requestId}/binding`, {
+    api_pub: creds.apiPubHex,
+    signed_body: env.signed_body,
+    agent_signature: env.agent_signature
+  });
+  return toBinding(r);
+}
+async function signWalletRequest(post, requestId, intent, creds, binding) {
+  const resolved = binding && binding.key_id && binding.derivation_path ? toBinding(binding) : await resolveBinding(post, requestId, creds);
+  const transport = (envelope) => post(`/agent/requests/${requestId}/moonx-sign`, {
+    api_pub: creds.apiPubHex,
+    ...envelope
+  });
+  const result = await signIntent(intent, creds, resolved, transport);
+  if (!result.ok) throw new Error(result.error);
+  await post(`/agent/requests/${requestId}/signature`, { artifact: result.artifact });
+  return result.artifact;
+}
+async function signSwapRequest(post, requestId, plan, creds) {
+  let binding = {
+    walletId: plan.binding.wallet_id,
+    keyId: plan.binding.key_id ?? "",
+    derivationPath: plan.binding.derivation_path ?? ""
+  };
+  if (binding.walletId && (!binding.keyId || !binding.derivationPath)) {
+    binding = await resolveBinding(post, requestId, creds);
+  }
+  const envelopes = buildSwapEnvelopes(plan.txs, binding, creds);
+  await post(`/agent/requests/${requestId}/envelopes`, { envelopes });
+}
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.paybox.sh";
+var EXPIRY_SKEW_MS = 6e4;
+var PayboxError = class extends Error {
+  constructor(status, body, context) {
+    super(`paybox ${context} failed (${status}): ${body}`);
+    this.status = status;
+    this.body = body;
+    this.name = "PayboxError";
+  }
+};
+var PayboxClient = class _PayboxClient {
+  baseUrl;
+  opts;
+  fetchImpl;
+  oauth;
+  configBacked = false;
+  constructor(options = {}) {
+    this.opts = options;
+    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.fetchImpl = options.fetchImpl ?? fetch;
+  }
+  /** Build a client from `~/.config/paybox/config.json` + env, with overrides. */
+  static fromConfig(overrides = {}) {
+    const cfg = loadConfig();
+    const client = new _PayboxClient({
+      baseUrl: overrides.baseUrl ?? process.env.PAYBOX_API_URL ?? cfg.baseUrl,
+      apiKey: overrides.apiKey ?? process.env.PAYBOX_API_KEY ?? cfg.apiKey,
+      token: overrides.token ?? process.env.PAYBOX_ACCESS_TOKEN,
+      signingKey: overrides.signingKey ?? process.env.PAYBOX_SIGNING_KEY ?? cfg.signingKey,
+      fetchImpl: overrides.fetchImpl
+    });
+    if (!client.opts.apiKey && !client.opts.token && cfg.oauth) {
+      client.oauth = cfg.oauth;
+      client.configBacked = true;
+    }
+    return client;
+  }
+  /** Whether in-process signing is available (a `pbxk1.` key is configured). */
+  get canSign() {
+    return Boolean(this.opts.signingKey);
+  }
+  async bearer() {
+    if (this.opts.token) return this.opts.token;
+    if (this.opts.apiKey) return this.opts.apiKey;
+    if (this.oauth) {
+      if (this.oauth.expiresAt && Date.now() > this.oauth.expiresAt - EXPIRY_SKEW_MS) {
+        this.oauth = await refreshTokens(this.baseUrl, this.oauth);
+        if (this.configBacked) {
+          const cfg = loadConfig();
+          cfg.oauth = this.oauth;
+          saveConfig(cfg);
+        }
+      }
+      return this.oauth.accessToken;
+    }
+    throw new Error(
+      "not authenticated \u2014 run `paybox login`, set PAYBOX_API_KEY, or pass { apiKey } / { token }"
+    );
+  }
+  async request(method, path, init = {}) {
+    const url = new URL(this.baseUrl + path);
+    for (const [k, v] of Object.entries(init.query ?? {})) {
+      if (v != null) url.searchParams.set(k, v);
+    }
+    const headers = { authorization: `Bearer ${await this.bearer()}` };
+    let body;
+    if (init.body !== void 0) {
+      headers["content-type"] = "application/json";
+      body = JSON.stringify(init.body);
+    }
+    const res = await this.fetchImpl(url, { method, headers, body });
+    const text = await res.text();
+    if (!res.ok) throw new PayboxError(res.status, text, `${method} ${path}`);
+    return text ? JSON.parse(text) : void 0;
+  }
+  poster = (path, body) => this.request("POST", path, { body });
+  /** List the credentials this client may use (the `list_credentials` tool). */
+  listCredentials() {
+    return this.request("GET", "/agent/grants");
+  }
+  /** Token balances across chains (the `get_portfolio` tool). */
+  getPortfolio(args) {
+    return this.request("GET", "/agent/portfolio", {
+      query: { address: args.address, network_ids: args.networkIds }
+    });
+  }
+  /** Charge a card credential (the `request_payment` tool). */
+  requestPayment(args) {
+    const operation = {
+      type: "payment",
+      credential_id: args.credentialId,
+      merchant: args.merchant,
+      merchant_url: args.merchantUrl,
+      amount_cents: args.amountCents,
+      currency: args.currency ?? "USD"
+    };
+    return this.request("POST", "/agent/request", { body: { operation } });
+  }
+  /** Reveal a secret credential (the `request_secret` tool). */
+  requestSecret(args) {
+    const operation = {
+      type: "secret",
+      credential_id: args.credentialId,
+      raw: args.raw ?? false,
+      purpose: args.purpose ?? null
+    };
+    return this.request("POST", "/agent/request", { body: { operation } });
+  }
+  /** Sign with a wallet credential (the `request_wallet_sign` tool). Signs
+   *  in-process and returns the completed request when a signing key is set and
+   *  the request clears immediately; otherwise returns the pending response.
+   *  Uses `/agent/wallet-sign`, which echoes the wallet binding so the signer
+   *  need not resolve it separately. */
+  async requestWalletSign(args, opts = {}) {
+    const operation = {
+      type: "wallet_sign",
+      credential_id: args.credentialId,
+      chain: args.chain,
+      contract: args.contract ?? null,
+      function: args.fn ?? null,
+      value_cents: args.valueCents ?? null,
+      intent: args.intent
+    };
+    const { response, binding } = await this.request(
+      "POST",
+      "/agent/wallet-sign",
+      { body: { operation } }
+    );
+    if ((opts.autoSign ?? true) && response.status === "pending_signature" && this.opts.signingKey) {
+      await signWalletRequest(
+        this.poster,
+        response.request_id,
+        args.intent,
+        credsFromToken(this.opts.signingKey),
+        binding
+      );
+      return this.getRequest(response.request_id);
+    }
+    return response;
+  }
+  /** Swap tokens from a wallet credential (the `request_swap` tool). Returns the
+   *  parked response + sign-ready plan; signs + submits in-process when a signing
+   *  key is set and the swap cleared immediately. */
+  async requestSwap(args, opts = {}) {
+    const operation = {
+      type: "swap",
+      credential_id: args.credentialId,
+      src_chain: args.srcChain,
+      dst_chain: args.dstChain ?? args.srcChain,
+      src_token: args.srcToken,
+      dst_token: args.dstToken,
+      amount: args.amount,
+      swap_direction: args.swapDirection ?? "exact-amount-in",
+      slippage_bps: args.slippageBps ?? 50,
+      recipient: args.recipient ?? null,
+      value_cents: args.valueCents ?? null
+    };
+    const result = await this.request("POST", "/agent/swap", { body: { operation } });
+    if ((opts.autoSign ?? true) && result.response.status === "pending_signature" && this.opts.signingKey) {
+      await signSwapRequest(
+        this.poster,
+        result.response.request_id,
+        result.plan,
+        credsFromToken(this.opts.signingKey)
+      );
+      return { ...result, response: await this.getRequest(result.response.request_id) };
+    }
+    return result;
+  }
+  /** Poll a request's status (the `get_request` tool). */
+  getRequest(requestId) {
+    return this.request("GET", `/agent/requests/${requestId}`);
+  }
+  /** Poll until the request leaves a pending state (or the timeout elapses). */
+  async waitForRequest(requestId, opts = {}) {
+    const interval = opts.intervalMs ?? 2e3;
+    const deadline = Date.now() + (opts.timeoutMs ?? 3e5);
+    for (; ; ) {
+      const r = await this.getRequest(requestId);
+      const pending = r.status === "pending_approval" || r.status === "pending_signature";
+      if (!pending || Date.now() > deadline) return r;
+      await new Promise((res) => setTimeout(res, interval));
+    }
+  }
+};
+
+export {
+  mcpResource,
+  loginLoopback,
+  refreshTokens,
+  configFile,
+  loadConfig,
+  saveConfig,
+  credsFromToken,
+  PayboxError,
+  PayboxClient
+};
+//# sourceMappingURL=chunk-23N5RHOB.js.map