@pr402/client 0.3.0

package/README.md

@@ -0,0 +1,120 @@
+# @pr402/client
+
+Lightweight [x402 v2](https://github.com/coinbase/x402/blob/main/specs/x402-specification-v2.md) client for buyer agents on Solana. Ships as one package with two faces:
+
+- **Library** (`X402AgentClient`) — drop into any Node project that needs to call paid HTTP endpoints.
+- **CLI** (`pr402-buy`) — single binary for quick tests, scripted pipelines, and one-off agents.
+
+Both share one code path, so behavior is identical.
+
+## Install
+
+Library and CLI both install from the same package:
+
+```bash
+# Project dependency
+npm install @pr402/client
+
+# Global CLI
+npm install -g @pr402/client
+
+# Or run without installing
+npx @pr402/client pr402-buy --help
+```
+
+## Use the CLI
+
+```bash
+pr402-buy \
+  --resource https://some.seller.com/api/thing \
+  --payer ~/.config/solana/buyer.json \
+  --mint 4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU
+```
+
+On success the paid body is printed to stdout. Pipeline-ready:
+
+```bash
+pr402-buy -r … -p … -m … | jq .
+```
+
+### Flags
+
+| Flag | Purpose |
+|---|---|
+| `--resource, -r <URL>` | **Required.** Paid URL. `pr402-buy` GETs first; 200 returns directly, 402 kicks off the payment loop. |
+| `--payer, -p <PATH>` | **Required.** Solana keypair JSON (array of 64 bytes, same shape as `solana-keygen new`). |
+| `--mint, -m <PUBKEY>` | **Required.** Base58 mint to pay with — must match one of `accepts[].asset` from the 402. |
+| `--auto-wrap-sol` | Advanced: inject WSOL wrap instructions. Off by default. |
+| `--verbose, -v` | Print bodies at each step on stderr. |
+| `--help, -h` | Usage info. |
+
+### Exit codes
+
+| Code | Meaning |
+|---|---|
+| `0` | Resource fetched successfully. |
+| `1` | Usage / flag error. |
+| `2` | Network or HTTP transport failure. |
+| `3` | Protocol-level rejection (facilitator or seller returned a definitive error). |
+
+## Use the library
+
+```ts
+import { X402AgentClient, X402Error } from "@miraland-labs/pr402-client";
+import { Keypair } from "@solana/web3.js";
+import * as fs from "node:fs";
+
+const bytes = JSON.parse(fs.readFileSync("/path/to/keypair.json", "utf8"));
+const wallet = Keypair.fromSecretKey(new Uint8Array(bytes));
+const client = new X402AgentClient(wallet);
+
+try {
+  const res = await client.fetchWithAutoPay(
+    "https://some.seller.com/api/thing",
+    "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU", // devnet USDC
+  );
+  const data = await res.json();
+  console.log(data);
+} catch (e) {
+  if (e instanceof X402Error && e.code === "MINT_NOT_ACCEPTED") {
+    console.error("Available mints:", e.availableMints);
+  } else {
+    throw e;
+  }
+}
+```
+
+The method returns a standard `Response` so you can inspect headers (`PAYMENT-RESPONSE`, correlation ids, caches) before reading the body.
+
+## What this does under the hood
+
+1. `GET <resource>` — expect 402.
+2. `POST <facilitator>/build-exact-payment-tx` — receive an unsigned `VersionedTransaction` plus a `verifyBodyTemplate` with everything except the signed tx pre-filled.
+3. Sign the transaction locally at `payerSignatureIndex`.
+4. `GET <resource>` with `PAYMENT-SIGNATURE` header — the seller forwards the proof to the facilitator, which verifies and settles in one hop, and returns the paid response.
+
+The client never builds a Solana transaction from scratch — the facilitator does. CU limits, token-program branches, PDA derivations, and fee-payer details come from the facilitator's build response, so buyer code stays forward-compatible across facilitator policy changes.
+
+## Error codes
+
+All protocol-level errors come as `X402Error` with a typed `code` field:
+
+| Code | Meaning |
+|---|---|
+| `MINT_NOT_ACCEPTED` | Preferred mint isn't in the seller's `accepts[]`. `e.availableMints` lists the options. |
+| `BLOCKHASH_EXPIRED` | Build response is too old; request a fresh build. `e.expiresAt` is the Unix timestamp. |
+| `RATE_LIMITED` | Facilitator returned 429. `e.retryAfterSecs` indicates the wait. |
+| `BUILD_FAILED` | Facilitator rejected the build request. `e.httpStatus` + the message carry the reason. |
+| `MISSING_CAPABILITIES_URL` | Seller didn't integrate with a facilitator; contact them. |
+| `MISSING_ACCEPTS` / `MISSING_VERIFY_TEMPLATE` / `MISSING_TRANSACTION` | Seller or facilitator configuration issue. |
+| `UNEXPECTED_STATUS` | Seller returned something other than 200 or 402. |
+| `TRANSPORT` | Network or serialization error. |
+
+## Supported schemes
+
+- `v2:solana:exact` (UniversalSettle) — today.
+- `v2:solana:sla-escrow` — not yet.
+
+## License
+
+Apache-2.0

package/dist/cli.d.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+/**
+ * pr402-buy — one-shot buyer CLI (TypeScript).
+ *
+ * Runs the full x402 lifecycle against any seller URL: fetch 402 → build → sign →
+ * verify → settle → retry. Seller-agnostic; uses the same `X402AgentClient` the
+ * library exposes so the CLI and the importable API evolve together.
+ *
+ * Distribution:
+ *   - Installed via the published npm package (`npm i -g @pr402/client`),
+ *     then: `pr402-buy --resource <url> --payer ~/.config/solana/id.json --mint <mint>`.
+ *   - Or one-shot without installing: `npx @pr402/client pr402-buy ...`.
+ *   - No Rust toolchain needed. Works anywhere Node ≥ 18 runs.
+ *
+ * Flags are intentionally a subset of the Rust `pr402-buy` binary so that scripts can
+ * target either implementation interchangeably; the underlying behavior is identical.
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * pr402-buy — one-shot buyer CLI (TypeScript).
+ *
+ * Runs the full x402 lifecycle against any seller URL: fetch 402 → build → sign →
+ * verify → settle → retry. Seller-agnostic; uses the same `X402AgentClient` the
+ * library exposes so the CLI and the importable API evolve together.
+ *
+ * Distribution:
+ *   - Installed via the published npm package (`npm i -g @pr402/client`),
+ *     then: `pr402-buy --resource <url> --payer ~/.config/solana/id.json --mint <mint>`.
+ *   - Or one-shot without installing: `npx @pr402/client pr402-buy ...`.
+ *   - No Rust toolchain needed. Works anywhere Node ≥ 18 runs.
+ *
+ * Flags are intentionally a subset of the Rust `pr402-buy` binary so that scripts can
+ * target either implementation interchangeably; the underlying behavior is identical.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("node:fs"));
+const web3_js_1 = require("@solana/web3.js");
+const index_js_1 = require("./index.js");
+const USAGE = `pr402-buy — one-shot buyer for x402 v2 resources.
+
+Usage:
+  pr402-buy --resource <URL> --payer <KEYPAIR_PATH> --mint <MINT>
+
+Options:
+  --resource, -r  <URL>          Seller resource URL. GET first; if 200, done. If 402, pay + retry.
+  --payer,    -p  <PATH>         Path to a Solana keypair JSON (array of 64 bytes, same as solana-keygen output).
+  --mint,     -m  <PUBKEY>       Base58 mint to pay with. Picks the matching accepts[] line from the 402 body.
+  --auto-wrap-sol                Ask the facilitator to wrap SOL automatically when paying with WSOL.
+  --verbose,  -v                 Print bodies at each step.
+  --help,     -h                 This help.
+
+Exit codes:
+  0  resource fetched successfully
+  1  usage / flag error
+  2  network or HTTP transport failure
+  3  protocol-level failure (facilitator / seller rejected the flow)
+`;
+function parseArgs(argv) {
+    const out = {
+        resource: "",
+        payer: "",
+        mint: "",
+        verbose: false,
+        autoWrapSol: false,
+        help: false,
+    };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        const next = () => argv[++i] ?? "";
+        switch (a) {
+            case "--resource":
+            case "-r":
+                out.resource = next();
+                break;
+            case "--payer":
+            case "-p":
+                out.payer = next();
+                break;
+            case "--mint":
+            case "-m":
+                out.mint = next();
+                break;
+            case "--auto-wrap-sol":
+                out.autoWrapSol = true;
+                break;
+            case "--verbose":
+            case "-v":
+                out.verbose = true;
+                break;
+            case "--help":
+            case "-h":
+                out.help = true;
+                break;
+            default:
+                // Unknown flag: bail early so typos don't silently succeed with defaults.
+                throw new Error(`unknown flag: ${a}`);
+        }
+    }
+    return out;
+}
+function loadKeypair(path) {
+    // Solana CLI keypair format: JSON array of 64 bytes.
+    const raw = fs.readFileSync(path, "utf8");
+    const bytes = JSON.parse(raw);
+    if (!Array.isArray(bytes) || bytes.length !== 64) {
+        throw new Error(`keypair file ${path} must be a JSON array of 64 bytes, got ${Array.isArray(bytes) ? `array of ${bytes.length}` : typeof bytes}`);
+    }
+    return web3_js_1.Keypair.fromSecretKey(new Uint8Array(bytes));
+}
+async function main() {
+    let args;
+    try {
+        args = parseArgs(process.argv.slice(2));
+    }
+    catch (e) {
+        process.stderr.write(`${e.message}\n\n${USAGE}`);
+        return 1;
+    }
+    if (args.help) {
+        process.stdout.write(USAGE);
+        return 0;
+    }
+    if (!args.resource || !args.payer || !args.mint) {
+        process.stderr.write(`missing required flag.\n\n${USAGE}`);
+        return 1;
+    }
+    const payer = loadKeypair(args.payer);
+    if (args.verbose) {
+        process.stderr.write(`payer: ${payer.publicKey.toBase58()}\n`);
+    }
+    const client = new index_js_1.X402AgentClient(payer);
+    try {
+        const res = await client.fetchWithAutoPay(args.resource, args.mint, {
+            autoWrapSol: args.autoWrapSol,
+        });
+        const text = await res.text();
+        if (!res.ok) {
+            process.stderr.write(`resource retry failed (HTTP ${res.status}): ${text}\n`);
+            return 3;
+        }
+        const paymentResponse = res.headers.get("PAYMENT-RESPONSE");
+        if (args.verbose && paymentResponse) {
+            process.stderr.write(`PAYMENT-RESPONSE (base64): ${paymentResponse}\n`);
+        }
+        process.stdout.write(text);
+        // Newline only when stdout is a TTY so piped output stays byte-identical.
+        if (process.stdout.isTTY)
+            process.stdout.write("\n");
+        return 0;
+    }
+    catch (e) {
+        if (e instanceof index_js_1.X402Error) {
+            // Protocol-level error codes come with actionable context — surface them.
+            process.stderr.write(`${e.code}: ${e.message}\n`);
+            if (e.availableMints?.length) {
+                process.stderr.write(`available mints: ${e.availableMints.join(", ")}\n`);
+            }
+            if (e.retryAfterSecs) {
+                process.stderr.write(`retry after: ${e.retryAfterSecs}s\n`);
+            }
+            if (e.expiresAt) {
+                process.stderr.write(`blockhash expired at unix ${e.expiresAt}\n`);
+            }
+            return 3;
+        }
+        process.stderr.write(`transport error: ${e.message}\n`);
+        return 2;
+    }
+}
+main().then((code) => process.exit(code), (e) => {
+    process.stderr.write(`unexpected: ${e.stack ?? e}\n`);
+    process.exit(2);
+});

package/dist/index.d.ts

@@ -0,0 +1,67 @@
+import { Keypair } from '@solana/web3.js';
+/**
+ * Specific, actionable error codes for autonomous agent remediation.
+ *
+ * @example
+ * ```ts
+ * try { await client.fetchWithAutoPay(url, mint); }
+ * catch (e) {
+ *   if (e instanceof X402Error && e.code === 'MINT_NOT_ACCEPTED')
+ *     console.log('Available mints:', e.availableMints);
+ * }
+ * ```
+ */
+export type X402ErrorCode = 'UNEXPECTED_STATUS' | 'MISSING_ACCEPTS' | 'MINT_NOT_ACCEPTED' | 'MISSING_CAPABILITIES_URL' | 'BUILD_FAILED' | 'MISSING_VERIFY_TEMPLATE' | 'MISSING_TRANSACTION' | 'BLOCKHASH_EXPIRED' | 'RATE_LIMITED' | 'TRANSPORT';
+export declare class X402Error extends Error {
+    readonly code: X402ErrorCode;
+    /** Mints accepted by the resource (only for MINT_NOT_ACCEPTED). */
+    readonly availableMints?: string[];
+    /** HTTP status from the facilitator (only for BUILD_FAILED / UNEXPECTED_STATUS). */
+    readonly httpStatus?: number;
+    /** Seconds to wait before retrying (only for RATE_LIMITED). */
+    readonly retryAfterSecs?: number;
+    /** UNIX epoch when blockhash expires (only for BLOCKHASH_EXPIRED). */
+    readonly expiresAt?: number;
+    constructor(code: X402ErrorCode, message: string, extra?: {
+        availableMints?: string[];
+        httpStatus?: number;
+        retryAfterSecs?: number;
+        expiresAt?: number;
+    });
+}
+export interface FetchAutoPayOptions extends RequestInit {
+    /** If true, the facilitator SDK build step will inject wSOL wrapping instructions automatically. */
+    autoWrapSol?: boolean;
+}
+/**
+ * Lightweight pr402 agent client.
+ *
+ * Wraps standard `fetch()` to automatically detect `402 Payment Required`,
+ * delegate transaction construction to the pr402 Facilitator,
+ * sign locally with Ed25519, and retry the original request with proof.
+ *
+ * @example
+ * ```ts
+ * const client = new X402AgentClient(myKeypair);
+ * const res = await client.fetchWithAutoPay(url, usdcMint);
+ * const data = await res.json();
+ * ```
+ */
+export declare class X402AgentClient {
+    private wallet;
+    constructor(wallet: Keypair);
+    /**
+     * GET a 402-gated resource. If challenged, automatically build, sign, and settle.
+     *
+     * On success (seller returns 200) the retry request carries the signed
+     * `verifyBodyTemplate` as a **`PAYMENT-SIGNATURE`** header (x402 v2). The value
+     * is base64(UTF-8 JSON). Sellers in this ecosystem accept either base64 or raw
+     * JSON in that header; this client emits base64 for URL-safety.
+     *
+     * @param url        - The target API endpoint
+     * @param preferredMint - Base58 mint address of the token you want to pay with
+     * @param options    - Optional extra fetch options (headers, autoWrapSol, etc.)
+     * @throws {X402Error} with a specific `code` for each failure mode
+     */
+    fetchWithAutoPay(url: string, preferredMint: string, options?: FetchAutoPayOptions): Promise<Response>;
+}

package/dist/index.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.X402AgentClient = exports.X402Error = void 0;
+const web3_js_1 = require("@solana/web3.js");
+class X402Error extends Error {
+    constructor(code, message, extra) {
+        super(message);
+        this.name = 'X402Error';
+        this.code = code;
+        this.availableMints = extra?.availableMints;
+        this.httpStatus = extra?.httpStatus;
+        this.retryAfterSecs = extra?.retryAfterSecs;
+        this.expiresAt = extra?.expiresAt;
+    }
+}
+exports.X402Error = X402Error;
+/**
+ * Lightweight pr402 agent client.
+ *
+ * Wraps standard `fetch()` to automatically detect `402 Payment Required`,
+ * delegate transaction construction to the pr402 Facilitator,
+ * sign locally with Ed25519, and retry the original request with proof.
+ *
+ * @example
+ * ```ts
+ * const client = new X402AgentClient(myKeypair);
+ * const res = await client.fetchWithAutoPay(url, usdcMint);
+ * const data = await res.json();
+ * ```
+ */
+class X402AgentClient {
+    constructor(wallet) {
+        this.wallet = wallet;
+    }
+    /**
+     * GET a 402-gated resource. If challenged, automatically build, sign, and settle.
+     *
+     * On success (seller returns 200) the retry request carries the signed
+     * `verifyBodyTemplate` as a **`PAYMENT-SIGNATURE`** header (x402 v2). The value
+     * is base64(UTF-8 JSON). Sellers in this ecosystem accept either base64 or raw
+     * JSON in that header; this client emits base64 for URL-safety.
+     *
+     * @param url        - The target API endpoint
+     * @param preferredMint - Base58 mint address of the token you want to pay with
+     * @param options    - Optional extra fetch options (headers, autoWrapSol, etc.)
+     * @throws {X402Error} with a specific `code` for each failure mode
+     */
+    async fetchWithAutoPay(url, preferredMint, options) {
+        const res = await fetch(url, options);
+        if (res.status === 200)
+            return res;
+        if (res.status !== 402)
+            throw new X402Error('UNEXPECTED_STATUS', `Unexpected HTTP status ${res.status}. Expected 200 (free) or 402 (payment required).`, { httpStatus: res.status });
+        // ── Step 1: Parse the 402 Challenge ─────────────────────────────
+        const requirement = await res.json();
+        const accepts = requirement.accepts || [];
+        if (accepts.length === 0)
+            throw new X402Error('MISSING_ACCEPTS', "The 402 response has no 'accepts' array. The Resource Provider's payment configuration is invalid. Contact the RP operator.");
+        const availableMints = accepts
+            .map((a) => a.asset)
+            .filter(Boolean);
+        const rule = accepts.find((a) => a.asset === preferredMint);
+        if (!rule)
+            throw new X402Error('MINT_NOT_ACCEPTED', `Resource does not accept mint ${preferredMint}. Available mints: [${availableMints.join(', ')}]. Pick one from this list.`, { availableMints });
+        const capUrl = rule.extra?.capabilitiesUrl;
+        if (!capUrl)
+            throw new X402Error('MISSING_CAPABILITIES_URL', 'This 402-gated resource did not provide extra.capabilitiesUrl. The Resource Provider has not completed Facilitator integration. See docs/SELLER_INTEGRATION.md.');
+        // ── Step 2: Ask Facilitator to build the tx ─────────────────────
+        const facilitatorBase = capUrl.replace('/capabilities', '');
+        const buildRes = await fetch(`${facilitatorBase}/build-exact-payment-tx`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                payer: this.wallet.publicKey.toBase58(),
+                accepted: rule,
+                resource: requirement.resource,
+                skipSourceBalanceCheck: true,
+                autoWrapSol: options?.autoWrapSol,
+            }),
+        });
+        if (buildRes.status === 429) {
+            const retryAfter = parseInt(buildRes.headers.get('retry-after') || '60', 10);
+            throw new X402Error('RATE_LIMITED', `Facilitator rate-limited this request. Retry after ${retryAfter}s.`, { retryAfterSecs: retryAfter });
+        }
+        if (!buildRes.ok) {
+            const detail = await buildRes.text();
+            throw new X402Error('BUILD_FAILED', `Facilitator build-exact-payment-tx returned HTTP ${buildRes.status}: ${detail}`, { httpStatus: buildRes.status });
+        }
+        const buildJson = await buildRes.json();
+        // BUY-3: Check blockhash expiry before signing
+        if (buildJson.recentBlockhashExpiresAt) {
+            const nowSec = Math.floor(Date.now() / 1000);
+            if (nowSec >= buildJson.recentBlockhashExpiresAt) {
+                throw new X402Error('BLOCKHASH_EXPIRED', `The embedded blockhash expired at UNIX ${buildJson.recentBlockhashExpiresAt}. Request a fresh build from the Facilitator.`, { expiresAt: buildJson.recentBlockhashExpiresAt });
+            }
+        }
+        if (!buildJson.verifyBodyTemplate)
+            throw new X402Error('MISSING_VERIFY_TEMPLATE', "Facilitator response is missing 'verifyBodyTemplate'. The Facilitator may be running an incompatible version.");
+        if (!buildJson.transaction)
+            throw new X402Error('MISSING_TRANSACTION', "Facilitator response is missing 'transaction'. The Facilitator may be running an incompatible version.");
+        // ── Step 3: Sign the unsigned transaction ───────────────────────
+        const txBytes = Uint8Array.from(atob(buildJson.transaction), (c) => c.charCodeAt(0));
+        const vtx = web3_js_1.VersionedTransaction.deserialize(txBytes);
+        vtx.sign([this.wallet]);
+        const signedB64 = btoa(String.fromCharCode(...vtx.serialize()));
+        // ── Step 4: Inject signature into verify body template ──────────
+        const verifyBody = buildJson.verifyBodyTemplate;
+        verifyBody.paymentPayload.payload.transaction = signedB64;
+        const proofB64 = btoa(JSON.stringify(verifyBody));
+        // ── Step 5: Replay original request with proof ──────────────────
+        //
+        // x402 v2 uses the `PAYMENT-SIGNATURE` header name (see the x402 HTTP
+        // transport-v2 spec and `public/agent-integration.md` in this repo).
+        // v1 used `X-PAYMENT`; every seller in this ecosystem today — aethervane,
+        // spl-token-balance-serverless, x402-seller-starter — reads only
+        // `PAYMENT-SIGNATURE`, so emitting `X-PAYMENT` silently fails with a
+        // repeated 402. Emit the canonical v2 header exclusively.
+        return fetch(url, {
+            ...options,
+            headers: {
+                ...(options?.headers || {}),
+                'PAYMENT-SIGNATURE': proofB64,
+            },
+        });
+    }
+}
+exports.X402AgentClient = X402AgentClient;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@pr402/client",
+  "version": "0.3.0",
+  "description": "Lightweight NPM library + CLI for autonomous agents paying HTTP 402 APIs settled on Solana via pr402.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "commonjs",
+  "bin": {
+    "pr402-buy": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "postbuild": "node -e \"require('fs').chmodSync('dist/cli.js', 0o755)\""
+  },
+  "dependencies": {
+    "@solana/web3.js": "^1.87.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "x402",
+    "solana",
+    "pr402",
+    "facilitator",
+    "agent"
+  ],
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/miralandlabs/pr402"
+  }
+}