@supercuts-walrus/backend 0.0.0-stage → 0.1.0

package/dist/live-seller-transport.js

@@ -0,0 +1,169 @@
+import { createServer } from "node:http";
+import { decodeSuiPrivateKey } from "@mysten/sui/cryptography";
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+import { isValidPersonalMessageSignature } from "@mysten/sui/verify";
+import { validateCapabilityPayload } from "./capability.js";
+import { fail, SupercutsError } from "./errors.js";
+import { LiveRuntime } from "./live-runtime.js";
+import { LiveSellerPaymentVerifier } from "./live-seller-verifier.js";
+import { SellerRuntime } from "./seller-runtime.js";
+import { canonicalJson } from "./settlement.js";
+import { WalrusDealBlobs, wireDecrypt, wireEncrypt, wireHash, wireJsonHash, wireKey } from "./deal-wire.js";
+import { X402ResourceService } from "./x402-resource-service.js";
+import { dealChildId } from "./deal.js";
+const id = (value) => typeof value === "string" && /^[A-Za-z0-9._:-]{1,128}$/.test(value) ? value : fail("SELLER_REQUEST_INVALID", "deal wire identity is invalid");
+const object = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : fail("SELLER_REQUEST_INVALID", "deal wire object is invalid");
+const halves = (hash) => [BigInt(`0x${hash.slice(0, 32)}`).toString(), BigInt(`0x${hash.slice(32)}`).toString()];
+const signedOffer = (sessionId, capabilityId, buyerPublicKey, ciphertext) => Buffer.from(`${sessionId}:${capabilityId}:${buyerPublicKey}:${wireHash(Buffer.from(ciphertext, "base64"))}`);
+export class LiveSellerTransport {
+    app;
+    config;
+    runtime;
+    #blobs;
+    #verifier;
+    #resources = new Map();
+    #registrations = new Map();
+    constructor(app, config, runtimeFactory) {
+        this.app = app;
+        this.config = config;
+        if (app.profile.role !== "seller" || app.profile.mock)
+            fail("SELLER_LIVE_REQUIRED", "generic seller transport requires a live seller role home");
+        const origin = new URL(config.origin);
+        if (origin.protocol !== "https:" && !(origin.protocol === "http:" && ["localhost", "127.0.0.1", "::1"].includes(origin.hostname)))
+            fail("SELLER_ORIGIN_INVALID", "seller transport requires HTTPS except on loopback");
+        this.#blobs = new WalrusDealBlobs(app);
+        this.#verifier = new LiveSellerPaymentVerifier(app, runtimeFactory);
+        app.store.db.exec("CREATE TABLE IF NOT EXISTS seller_deal_prepares(session_id TEXT PRIMARY KEY,capability_id TEXT NOT NULL,buyer_address TEXT NOT NULL,buyer_public_key TEXT NOT NULL,offer_hash TEXT NOT NULL,offer_ciphertext TEXT NOT NULL,reply_ciphertext TEXT NOT NULL,offer_blob_id TEXT,reply_blob_id TEXT,payment_operation_id TEXT NOT NULL)");
+        this.runtime = new SellerRuntime(app.store, {
+            readBlob: (blobId) => this.#blobs.read(blobId),
+            verifyPayment: (request) => this.#verifier.verify(request),
+            encryptAndPublish: async (request, result) => {
+                const row = this.prepared(request.requestId);
+                const key = wireKey(app, row.buyer_public_key, request.requestId);
+                const encoded = wireEncrypt(key, request.requestId, "delivery", { artifactBase64: Buffer.from(result.artifact).toString("base64"), contentType: result.contentType, metadata: result.metadata });
+                const ciphertext = Buffer.from(encoded, "base64"), published = await this.#blobs.publish(ciphertext);
+                return { blobId: published.blobId, ciphertext };
+            },
+            serve: async () => fail("SELLER_TRANSPORT_START", "start the seller HTTP service with createServer"),
+        });
+    }
+    prepared(sessionId) { return this.app.store.db.prepare("SELECT * FROM seller_deal_prepares WHERE session_id=?").get(sessionId) ?? fail("NEGOTIATION_REQUIRED", "seller has no matching prepared deal"); }
+    async register(registration, handler) {
+        if (registration.manifest.sellerId.toLowerCase() !== (await this.signer()).toSuiAddress().toLowerCase())
+            fail("SELLER_IDENTITY_MISMATCH", "capability seller does not match this role signer");
+        if (new URL(registration.manifest.endpoint).origin !== new URL(this.config.origin).origin)
+            fail("SELLER_ENDPOINT_MISMATCH", "capability endpoint must be hosted by this seller transport");
+        await this.runtime.registerCapability(registration, handler);
+        this.#registrations.set(registration.manifest.capabilityId, registration);
+        if (registration.manifest.supportedRails.includes("x402")) {
+            const facilitatorUrl = this.config.facilitatorUrl ?? fail("SELLER_FACILITATOR_REQUIRED", "x402 capability requires a facilitator URL");
+            const facilitatorKey = this.config.facilitatorKey ?? fail("SELLER_FACILITATOR_REQUIRED", "x402 capability requires a seller-only facilitator key");
+            const endpoint = new URL(registration.manifest.endpoint);
+            const resource = new X402ResourceService(this.app.store, { origin: this.config.origin, pathPrefix: endpoint.pathname, facilitatorUrl, facilitatorKey, network: "sui:testnet", asset: registration.manifest.asset, payTo: registration.manifest.sellerId, amount: registration.manifest.priceBand.minimum }, fetch, this.config.persist, this.config.claimPayment);
+            this.#resources.set(registration.manifest.capabilityId, resource);
+            const rows = this.app.store.db.prepare("SELECT session_id,payment_operation_id FROM seller_deal_prepares WHERE capability_id=?").all(registration.manifest.capabilityId);
+            for (const row of rows)
+                resource.register(row.session_id, row.payment_operation_id, Buffer.from(canonicalJson({ status: "paid", requestId: row.session_id })));
+        }
+    }
+    async signer() {
+        const encoded = this.app.store.getSecret("live:sui-private-key")?.toString() ?? fail("LIVE_CREDENTIAL_MISSING", "seller signer is missing");
+        const decoded = decodeSuiPrivateKey(encoded);
+        if (decoded.scheme !== "ED25519")
+            fail("SIGNER_UNSUPPORTED", "seller requires an ED25519 signer");
+        return Ed25519Keypair.fromSecretKey(decoded.secretKey);
+    }
+    async body(request) {
+        const chunks = [];
+        let size = 0;
+        for await (const chunk of request) {
+            size += chunk.length;
+            if (size > 256 * 1024)
+                fail("SELLER_REQUEST_INVALID", "seller request exceeds 256 KiB");
+            chunks.push(chunk);
+        }
+        try {
+            return object(JSON.parse(Buffer.concat(chunks).toString()));
+        }
+        catch (error) {
+            return fail("SELLER_REQUEST_INVALID", "seller request is not JSON", error);
+        }
+    }
+    respond(response, code, value) {
+        const bytes = Buffer.from(JSON.stringify(value));
+        response.writeHead(code, { "content-type": "application/json", "content-length": String(bytes.length), "cache-control": "no-store" });
+        response.end(bytes);
+    }
+    async handle(request, response) {
+        try {
+            const url = new URL(request.url ?? "/", this.config.origin);
+            if (request.method === "GET" && url.pathname === "/v2/catalog")
+                return this.respond(response, 200, { capabilities: this.runtime.catalog() });
+            if (request.method === "POST" && url.pathname === "/v2/prepare")
+                return this.respond(response, 200, await this.prepareRequest(await this.body(request)));
+            if (request.method === "POST" && url.pathname === "/v2/fulfill")
+                return this.respond(response, 200, await this.fulfillRequest(await this.body(request)));
+            if (request.method === "GET") {
+                for (const resource of this.#resources.values())
+                    if (url.pathname.startsWith(`${(resource.config.pathPrefix ?? "/capability").replace(/\/$/, "")}/`))
+                        return resource.handle(request, response);
+            }
+            return this.respond(response, 404, { error: "NOT_FOUND" });
+        }
+        catch (error) {
+            const known = error instanceof SupercutsError ? error : new SupercutsError("SELLER_REQUEST_FAILED", "seller request failed");
+            if (!response.headersSent)
+                this.respond(response, 400, { error: known.code, message: known.message });
+        }
+    }
+    createServer() { return createServer((request, response) => void this.handle(request, response)); }
+    async prepareRequest(body) { const result = await this.prepare(body); await this.config.persist?.(); return result; }
+    async fulfillRequest(body) { const result = await this.fulfill(body); await this.config.persist?.(); return result; }
+    async prepare(body) {
+        const sessionId = id(body.sessionId), capabilityId = id(body.capabilityId);
+        const registration = this.#registrations.get(capabilityId) ?? fail("SELLER_CAPABILITY_UNKNOWN", "capability is not registered");
+        const buyerAddress = String(body.buyerAddress ?? ""), buyerPublicKey = String(body.buyerPublicKey ?? ""), ciphertext = String(body.ciphertext ?? ""), signature = String(body.buyerSignature ?? "");
+        if (!/^0x[0-9a-f]{64}$/i.test(buyerAddress) || !buyerPublicKey || ciphertext.length > 192 * 1024 || !ciphertext || !signature)
+            fail("SELLER_REQUEST_INVALID", "buyer identity or ciphertext is invalid");
+        if (this.config.allowedBuyers && !this.config.allowedBuyers.some((item) => item.toLowerCase() === buyerAddress.toLowerCase()))
+            fail("SELLER_BUYER_FORBIDDEN", "buyer is outside the seller allowlist");
+        if (!(await isValidPersonalMessageSignature(signedOffer(sessionId, capabilityId, buyerPublicKey, ciphertext), signature, { address: buyerAddress })))
+            fail("SELLER_BUYER_SIGNATURE_INVALID", "buyer did not authorize the encrypted offer");
+        const key = wireKey(this.app, buyerPublicKey, sessionId), offer = object(wireDecrypt(key, sessionId, "offer", ciphertext));
+        const manifest = registration.manifest, draft = object(offer.draft), amount = manifest.priceBand.minimum;
+        validateCapabilityPayload(manifest, "input", offer.input);
+        if (offer.amount !== amount || !/^[1-9][0-9]*$/.test(offer.maximum) || BigInt(offer.maximum) < BigInt(amount) || BigInt(offer.maximum) > BigInt(manifest.priceBand.maximum) || !manifest.supportedRails.includes(offer.rail) || !/^[0-9a-f]{64}$/.test(offer.planHash))
+            fail("SELLER_OFFER_INVALID", "offer is outside signed price or rail terms");
+        const taskHash = wireJsonHash(offer.input), transcript = wireJsonHash({ domain: "supercuts-deal-transcript-v1", sessionId, taskHash, planHash: offer.planHash, amount, rail: offer.rail });
+        const service = wireJsonHash({ domain: "supercuts-deal-service-v1", taskHash, planHash: offer.planHash, capabilityId, rail: offer.rail, buyerPublicKey });
+        const [transcriptRootLo, transcriptRootHi] = halves(transcript), [serviceDigestLo, serviceDigestHi] = halves(service);
+        const dealOperationId = typeof body.dealOperationId === "string" && body.dealOperationId.length <= 256 && body.dealOperationId.length > 0 ? body.dealOperationId : fail("SELLER_REQUEST_INVALID", "deal operation ID is invalid");
+        if (draft.sessionId !== sessionId || draft.dealOperationId !== dealOperationId || draft.capabilityId !== capabilityId || draft.manifestHash !== manifest.manifestHash || draft.counterparty !== manifest.sellerId || draft.paymentAmount !== amount || draft.rail !== offer.rail || draft.taskHash !== taskHash || draft.planHash !== offer.planHash || draft.transcriptRootLo !== transcriptRootLo || draft.transcriptRootHi !== transcriptRootHi || draft.serviceDigestLo !== serviceDigestLo || draft.serviceDigestHi !== serviceDigestHi || offer.paymentOperationId !== dealChildId(dealOperationId, "payment"))
+            fail("AGREEMENT_BINDING_MISMATCH", "draft does not bind the encrypted task and signed capability");
+        const prior = this.app.store.db.prepare("SELECT offer_hash FROM seller_deal_prepares WHERE session_id=?").get(sessionId);
+        const offerHash = wireHash(Buffer.from(ciphertext, "base64"));
+        if (prior && prior.offer_hash !== offerHash)
+            fail("NEGOTIATION_SESSION_CONFLICT", "session identifies a different encrypted offer");
+        const runtime = await LiveRuntime.create(this.app.profile, this.app.store);
+        const signed = runtime.prepareSellerAgreement(sessionId, Buffer.from(canonicalJson(draft)).toString("base64url"));
+        const agreement = Buffer.from(String(signed.agreement), "base64url").toString(), agreementHash = wireHash(agreement);
+        const resource = offer.rail === "x402" ? this.#resources.get(capabilityId) ?? fail("SELLER_RAIL_UNSUPPORTED", "seller has no x402 resource") : undefined;
+        const resourceUrl = resource?.register(sessionId, offer.paymentOperationId, Buffer.from(canonicalJson({ status: "paid", requestId: sessionId }))).url;
+        const replyCiphertext = prior ? this.prepared(sessionId).reply_ciphertext : wireEncrypt(key, sessionId, "reply", { agreement: signed.agreement, agreementHash, dealCommitment: signed.dealCommitment, ...(resourceUrl ? { resourceUrl } : {}) });
+        if (!prior)
+            this.app.store.db.prepare("INSERT INTO seller_deal_prepares(session_id,capability_id,buyer_address,buyer_public_key,offer_hash,offer_ciphertext,reply_ciphertext,payment_operation_id) VALUES(?,?,?,?,?,?,?,?)").run(sessionId, capabilityId, buyerAddress, buyerPublicKey, offerHash, ciphertext, replyCiphertext, offer.paymentOperationId);
+        const offerBlob = await this.#blobs.publish(Buffer.from(ciphertext, "base64")), replyBlob = await this.#blobs.publish(Buffer.from(replyCiphertext, "base64"));
+        this.app.store.db.prepare("UPDATE seller_deal_prepares SET offer_blob_id=?,reply_blob_id=? WHERE session_id=?").run(offerBlob.blobId, replyBlob.blobId, sessionId);
+        return { sessionId, capabilityId, offerBlob, replyBlob, agreementBlob: replyBlob, ciphertext: replyCiphertext };
+    }
+    async fulfill(body) {
+        const sessionId = id(body.sessionId), row = this.prepared(sessionId), ciphertext = String(body.ciphertext ?? ""), signature = String(body.buyerSignature ?? "");
+        if (!ciphertext || ciphertext.length > 192 * 1024 || !(await isValidPersonalMessageSignature(Buffer.from(`${sessionId}:${wireHash(Buffer.from(ciphertext, "base64"))}`), signature, { address: row.buyer_address })))
+            fail("SELLER_BUYER_SIGNATURE_INVALID", "buyer did not authorize the delivery request");
+        const key = wireKey(this.app, row.buyer_public_key, sessionId), serviceRequest = wireDecrypt(key, sessionId, "fulfill", ciphertext);
+        if (serviceRequest.requestId !== sessionId || serviceRequest.capabilityId !== row.capability_id)
+            fail("SELLER_REQUEST_INVALID", "fulfillment differs from prepared seller request");
+        const delivery = await this.runtime.fulfill(serviceRequest);
+        return { sessionId, ciphertext: wireEncrypt(key, sessionId, "receipt", delivery) };
+    }
+}

package/dist/live-seller-verifier.d.ts

@@ -0,0 +1,11 @@
+import type { Phase3App } from "./phase3.js";
+import { LiveRuntime } from "./live-runtime.js";
+import type { ServiceRequest, VerifiedSellerPayment } from "./seller-runtime.js";
+/** Reads independently finalized chain and Tatum evidence from the seller home.
+ * The signed agreement was already persisted by prepareSellerAgreement. */
+export declare class LiveSellerPaymentVerifier {
+    private readonly app;
+    private readonly runtimeFactory;
+    constructor(app: Phase3App, runtimeFactory?: () => Promise<LiveRuntime>);
+    verify(request: ServiceRequest): Promise<VerifiedSellerPayment>;
+}

package/dist/live-seller-verifier.js

@@ -0,0 +1,65 @@
+import { createHash } from "node:crypto";
+import { LiveRuntime } from "./live-runtime.js";
+import { fail } from "./errors.js";
+import { assertSuiFinality, assertTatumFinality } from "./finality.js";
+import { canonicalJson } from "./settlement.js";
+const sha256 = (value) => createHash("sha256").update(value).digest("hex");
+const canonicalType = (value) => value.replace(/^0x0*2::/, "0x2::").toLowerCase();
+function bytes32(value) {
+    if (typeof value !== "string")
+        return fail("SELLER_PAYMENT_UNVERIFIED", "pool event commitment is missing");
+    const bytes = /^(?:0x)?[0-9a-f]{64}$/i.test(value) ? Buffer.from(value.replace(/^0x/, ""), "hex") : Buffer.from(value, "base64");
+    if (bytes.length !== 32)
+        fail("SELLER_PAYMENT_UNVERIFIED", "pool event commitment is invalid");
+    return bytes.toString("hex");
+}
+/** Reads independently finalized chain and Tatum evidence from the seller home.
+ * The signed agreement was already persisted by prepareSellerAgreement. */
+export class LiveSellerPaymentVerifier {
+    app;
+    runtimeFactory;
+    constructor(app, runtimeFactory = () => LiveRuntime.create(app.profile, app.store)) {
+        this.app = app;
+        this.runtimeFactory = runtimeFactory;
+        if (app.profile.role !== "seller" || app.profile.mock)
+            fail("SELLER_LIVE_REQUIRED", "seller payment verification requires a live seller role home");
+        app.store.db.exec("CREATE TABLE IF NOT EXISTS seller_payment_claims(digest TEXT PRIMARY KEY,request_id TEXT NOT NULL,agreement_hash TEXT NOT NULL,created_at INTEGER NOT NULL)");
+    }
+    async verify(request) {
+        const row = this.app.store.db.prepare("SELECT agreement FROM live_seller_agreements WHERE session_id=?").get(request.requestId);
+        if (!row || sha256(row.agreement) !== request.agreementHash)
+            return fail("SELLER_AGREEMENT_MISMATCH", "request does not match the locally signed agreement");
+        const agreement = JSON.parse(row.agreement);
+        if (agreement.capabilityId !== request.capabilityId || agreement.paymentAmount !== request.agreedAmount || agreement.rail !== request.rail || agreement.sessionId && agreement.sessionId !== request.requestId || agreement.dealOperationId !== request.dealId || agreement.taskHash !== sha256(canonicalJson(request.input)))
+            fail("SELLER_AGREEMENT_MISMATCH", "request differs from signed agreement terms");
+        const runtime = await this.runtimeFactory();
+        const result = await runtime.client.getTransaction({ digest: request.paymentDigest, include: { effects: true, events: true, balanceChanges: true, transaction: true } });
+        const tx = result.Transaction ?? result.FailedTransaction;
+        const checkpoint = assertSuiFinality(result, request.paymentDigest);
+        if (tx.transaction?.sender?.toLowerCase() !== this.app.store.db.prepare("SELECT buyer_address FROM seller_deal_prepares WHERE session_id=?").get(request.requestId)?.buyer_address.toLowerCase())
+            fail("SELLER_PAYMENT_UNVERIFIED", "payment sender differs from the authenticated buyer");
+        assertTatumFinality(await runtime.tatum.getTransaction(request.paymentDigest), request.paymentDigest, checkpoint);
+        if (request.rail === "x402") {
+            if (!tx.balanceChanges?.some((change) => change.address?.toLowerCase() === String(agreement.counterparty).toLowerCase() && canonicalType(String(change.coinType)) === canonicalType(this.app.profile.coinType) && BigInt(String(change.amount)) === BigInt(request.agreedAmount)))
+                fail("SELLER_PAYMENT_UNVERIFIED", "x402 transaction does not credit the exact seller and amount");
+        }
+        else {
+            const values = runtime.engine.agreementValues({ dealId: BigInt(String(agreement.dealId)), revision: BigInt(String(agreement.revision)), transcriptRootLo: BigInt(String(agreement.transcriptRootLo)), transcriptRootHi: BigInt(String(agreement.transcriptRootHi)), serviceDigestLo: BigInt(String(agreement.serviceDigestLo)), serviceDigestHi: BigInt(String(agreement.serviceDigestHi)), settlementNonceLo: BigInt(String(agreement.settlementNonceLo)), settlementNonceHi: BigInt(String(agreement.settlementNonceHi)), paymentAmount: BigInt(String(agreement.paymentAmount)), blinding: BigInt(String(agreement.blinding)), expiry: BigInt(String(agreement.expiry)), buyer: { seed: new Uint8Array(32), publicKey: agreement.buyerPublicKey.map(BigInt) }, sellerPublicKey: agreement.sellerPublicKey.map(BigInt), recipientSpendTag: BigInt(String(agreement.recipientSpendTag)) });
+            const expected = values.dealCommitment.toString(16).padStart(64, "0");
+            if (!/^[0-9a-f]{64}$/.test(expected) || !tx.events?.some((event) => event.packageId?.toLowerCase() === this.app.profile.packageId.toLowerCase() && event.module === (this.app.profile.verifierVersion === 2 ? "pool_v2" : "pool") && event.eventType?.endsWith("::TransferEvent") && event.json && bytes32(event.json.deal_commitment) === expected))
+                fail("SELLER_PAYMENT_UNVERIFIED", "pool transfer does not contain the signed deal commitment");
+            await runtime.recover();
+            const note = this.app.store.db.prepare("SELECT commitment FROM notes WHERE operation_id=? AND role='payment'").get(request.requestId);
+            if (!note)
+                return fail("SELLER_PAYMENT_UNVERIFIED", "seller could not recover the payment note from the pinned pool");
+            const leaf = this.app.store.db.prepare("SELECT transaction_digest FROM live_pool_leaves WHERE commitment=?").get(note.commitment);
+            if (leaf?.transaction_digest !== request.paymentDigest)
+                fail("SELLER_PAYMENT_UNVERIFIED", "recovered note does not belong to the supplied payment transaction");
+        }
+        const prior = this.app.store.db.prepare("SELECT request_id,agreement_hash FROM seller_payment_claims WHERE digest=?").get(request.paymentDigest);
+        if (prior && (prior.request_id !== request.requestId || prior.agreement_hash !== request.agreementHash))
+            fail("SELLER_PAYMENT_REPLAY", "payment digest is already bound to another seller request");
+        this.app.store.db.prepare("INSERT OR IGNORE INTO seller_payment_claims(digest,request_id,agreement_hash,created_at) VALUES(?,?,?,?)").run(request.paymentDigest, request.requestId, request.agreementHash, Date.now());
+        return { finalized: true, tatumVerified: true, digest: request.paymentDigest, agreementHash: request.agreementHash, sellerId: String(agreement.counterparty), asset: this.app.profile.coinType, amount: request.agreedAmount, rail: request.rail };
+    }
+}

package/dist/mandate.d.ts

@@ -0,0 +1,34 @@
+import type { Phase3App, Role } from "./phase3.js";
+export interface AgentMandate {
+    version: "supercuts.mandate.v1" | "supercuts.mandate.v2";
+    owner: string;
+    role: Role;
+    allowedCommands: string[];
+    allowedCounterparties: string[];
+    allowedAssets: string[];
+    perDealCeiling: string;
+    totalRunBudget: string;
+    requiredPrivacy: "any" | "shielded";
+    expiresAt: number;
+    requireSettlementPlan?: boolean;
+    allowedCapabilityIds?: string[];
+    allowedCapabilityClasses?: string[];
+    allowedRails?: Array<"x402" | "shielded">;
+    allowPublicX402?: boolean;
+}
+export interface ToolSchema {
+    name: string;
+    description: string;
+    mutating: boolean;
+    inputSchema: {
+        type: "object";
+        properties: Record<string, Record<string, unknown>>;
+        required?: string[];
+        additionalProperties: false;
+    };
+}
+export declare function toolSchema(name: string): ToolSchema;
+export declare function validateToolArguments(spec: ToolSchema, raw: Record<string, unknown>): void;
+export declare function loadMandate(home: string): AgentMandate;
+/** Turns an allowed MCP invocation into a backend exact-intent approval without exposing its token. */
+export declare function executeMandated(app: Phase3App, mandate: AgentMandate, command: string, raw: Record<string, unknown>): Promise<Record<string, unknown>>;

package/dist/mandate.js

@@ -0,0 +1,178 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { fail } from "./errors.js";
+const string = (description, extra = {}) => ({ type: "string", minLength: 1, description, ...extra });
+const boolean = (description) => ({ type: "boolean", description });
+const object = (properties, required = [], mutating = false, description = "") => ({ properties: { ...properties, ...(mutating ? { "operation-id": string("Stable idempotency identity for this exact mutation.", { maxLength: 256 }) } : {}) }, required: [...required, ...(mutating ? ["operation-id"] : [])], mutating, description });
+const definitions = {
+    status: object({}, [], false, "Read this isolated agent's public runtime status."),
+    doctor: object({}, [], false, "Verify pinned deployment, artifacts, identities, and configured services."),
+    "capability.discover": object({ capabilities: { type: "array", description: "Validated supercuts.capability.v1 manifests.", items: { type: "object" } }, "blob-ids": { type: "array", description: "Walrus blob IDs containing capability manifests.", items: { type: "string" } } }, [], false, "Discover seller capabilities without assuming an agent framework."),
+    "capability.publish": object({ manifest: { type: "object", description: "A complete supercuts.capability.v1 manifest." } }, ["manifest"], true, "Publish an owner-approved, versioned capability manifest."),
+    "wallet.deposit": object({ amount: string("Unsigned base-unit amount.", { pattern: "^[1-9][0-9]*$" }) }, ["amount"], true, "Deposit funds into the shielded pool."),
+    "wallet.balance": object({}, [], false, "Read event-derived private-note balance."),
+    "wallet.recover": object({ commitment: string("Optional payment-note commitment."), amount: string("Optional matching amount.", { pattern: "^[1-9][0-9]*$" }) }, [], true, "Recover notes from pinned finalized pool events."),
+    "wallet.withdraw": object({ commitment: string("Note commitment to spend."), recipient: string("Sui recipient address.") }, ["commitment"], true, "Withdraw one owned shielded note."),
+    "wallet.exit.queue": object({ commitment: string("Recovered note commitment."), amount: string("Public exit amount in MIST.", { pattern: "^[1-9][0-9]*$" }), "exact-exit": boolean("Approve a nonstandard amount that is publicly visible."), "window-start": string("Exit window start as Unix milliseconds."), "window-end": string("Exit window end as Unix milliseconds.") }, ["commitment", "amount", "window-start", "window-end"], true, "Queue a v2 exit with a fresh payout address and owner-selected delayed window."),
+    "wallet.exit.status": object({ "operation-id": string("Queued exit operation ID.") }, ["operation-id"], false, "Read a queued v2 exit without exposing its proof or note opening."),
+    "wallet.exit.finalize": object({ "exit-id": string("Queued exit operation ID."), digest: string("Finalized relayer transaction digest.") }, ["exit-id", "digest"], true, "Verify Sui and Tatum exit evidence and reconcile the owner note journal."),
+    "offer.open": object({ session: string("Optional stable negotiation session ID.") }, [], true, "Open a durable negotiation session."),
+    "offer.propose": object({ session: string("Negotiation session ID."), revision: string("Positive revision.", { pattern: "^[1-9][0-9]*$" }), terms: string("Plain-language or canonical JSON terms.") }, ["session", "revision", "terms"], true, "Submit an offer revision."),
+    "offer.counter": object({ session: string("Negotiation session ID."), revision: string("Positive revision.", { pattern: "^[1-9][0-9]*$" }), terms: string("Plain-language or canonical JSON terms."), agreement: string("Backend-only encoded agreement draft.") }, ["session"], true, "Counter an offer under deterministic price policy."),
+    "offer.accept": object({ session: string("Negotiation session ID."), revision: string("Positive revision.", { pattern: "^[1-9][0-9]*$" }), terms: string("Accepted terms."), agreement: string("Backend-only encoded signed agreement."), "plan-hash": string("Shielded settlement plan hash.", { pattern: "^[0-9a-f]{64}$" }) }, ["session"], true, "Accept policy-approved final terms and optionally bind it to a shielded plan."),
+    "offer.show": object({ session: string("Negotiation session ID.") }, ["session"], false, "Read the latest durable offer revision."),
+    "pay.quote": object({ rail: string("Requested settlement rail.", { enum: ["x402", "shielded"] }), amount: string("Unsigned base-unit amount.", { pattern: "^[1-9][0-9]*$" }), counterparty: string("Mandate-approved payee."), asset: string("Sui coin type.") }, ["rail", "amount", "counterparty"], false, "Evaluate payment policy without signing."),
+    "pay.shielded": object({ session: string("Accepted agreement session."), amount: string("Unsigned base-unit amount.", { pattern: "^[1-9][0-9]*$" }), counterparty: string("Mandate-approved seller."), asset: string("Sui coin type."), "request-id": string("Bound delivery request ID."), "broadcast-only": boolean("Stop after broadcast for recovery testing."), "plan-hash": string("Approved settlement plan hash.", { pattern: "^[0-9a-f]{64}$" }) }, [], true, "Settle one accepted agreement through the experimental shielded pool."),
+    "pay.x402": object({ "resource-url": string("Seller-owned protected resource URL."), amount: string("Unsigned base-unit amount.", { pattern: "^[1-9][0-9]*$" }), counterparty: string("Mandate-approved public payee."), asset: string("Sui coin type."), "request-id": string("Bound delivery request ID."), "broadcast-only": boolean("Stop after broadcast for recovery testing."), "plan-hash": string("Approved settlement plan hash.", { pattern: "^[0-9a-f]{64}$" }) }, [], true, "Complete a standard x402 v2 exact Sui payment challenge."),
+    "pay.status": object({ "operation-id": string("Payment operation identity."), reconcile: boolean("Reconcile an ambiguous broadcast.") }, ["operation-id"], false, "Read or reconcile a previously journaled payment."),
+    "resource.serve": object({ "request-id": string("Unique request identity."), body: string("Base64-encoded artifact bytes.") }, ["request-id", "body"], true, "Bind one generated artifact to one request."),
+    "resource.fetch": object({ "request-id": string("Bound request identity."), "operation-id": string("Finalized payment operation."), response: string("Base64-encoded paid response.") }, ["request-id", "operation-id", "response"], false, "Record delivery separately from payment evidence."),
+    "settlement.plan": object({ manifest: { type: "object", description: "Primary supercuts.capability.v1 manifest." }, alternatives: { type: "array", description: "Optional alternative manifests.", items: { type: "object" } }, "requested-amount": string("Desired opening amount in base units.", { pattern: "^(?:0|[1-9][0-9]*)$" }), "privacy-hint": string("Agent hint that may only increase privacy.", { enum: ["any", "shielded"] }), "requested-rail": string("Explicit settlement rail request.", { enum: ["x402", "shielded"] }) }, ["manifest"], true, "Create and persist a deterministic mandate- and memory-bound settlement plan."),
+    "memory.remember": object({ fact: string("Legacy advisory fact, never a secret or full transcript.", { maxLength: 4096 }), memory: { type: "object", description: "Typed settlement memory; provenance is assigned as agent_observation." } }, [], true, "Write one advisory Mainnet Walrus memory without granting authority."),
+    "memory.recall": object({ query: string("Policy or experience query.", { maxLength: 1024 }) }, ["query"], false, "Recall relevant prior experience and privacy rules."),
+    "memory.status": object({ "operation-id": string("Optional memory job ID to reconcile without draining unrelated jobs.") }, [], false, "List completed memory blob identities or reconcile one job."),
+    "memory.inventory": object({ "blob-id": string("Optional role-owned outcome memory blob ID.") }, [], false, "Synchronize Walrus Memory metadata for this role and namespace."),
+    "deal.reconcile": object({ operationId: string("Existing verified deal operation ID.") }, ["operationId"], true, "Reconcile an ambiguous encrypted outcome memory using an exact local plaintext match; never resubmit payment or memory."),
+    "deal.execute": object({ input: { type: "object", description: "Versioned composite deal input." } }, ["input"], true, "Execute a protocol deal under the owner v2 mandate and configured seller adapter."),
+    "deal.get": object({ operationId: string("Existing deal operation ID.") }, ["operationId"], false, "Read a redacted composite deal status."),
+    "deal.resume": object({ operationId: string("Existing deal operation ID.") }, ["operationId"], false, "Resume the same journaled deal without changing task or payment intent."),
+    "deal.catalog": object({}, [], false, "List signed, Walrus-verified seller capabilities allowed by the standing buyer policy."),
+    "deal.policy": object({}, [], false, "Read the active buyer policy and remaining lifetime budget without exposing credentials."),
+    "deal.evidence": object({ dealId: string("Existing deal ID.") }, ["dealId"], false, "Read redacted Walrus and payment evidence for one deal."),
+    "deal.delivery": object({ dealId: string("Existing delivered deal ID.") }, ["dealId"], false, "Read a verified paid artifact from the buyer's encrypted journal."),
+    "remote.catalog": object({}, [], false, "Discover the signed remote seller catalog through Walrus."),
+    "remote.rank-briefs": object({ budget: string("Total budget in MIST.", { pattern: "^[1-9][0-9]*$" }), topic: string("Sui research topic.", { maxLength: 256 }) }, ["budget", "topic"], false, "Compare eligible market briefs with a visible quality and price rubric."),
+    "remote.negotiate": object({ capabilityId: string("Selected capability ID."), sessionId: string("Stable negotiation session ID."), runId: string("Demo run ID."), task: string("Private task summary.", { maxLength: 512 }), opening: string("Opening amount in MIST.", { pattern: "^[1-9][0-9]*$" }), maximum: string("Maximum amount in MIST.", { pattern: "^[1-9][0-9]*$" }), briefHash: string("Purchased brief SHA-256 if analyzing it.", { pattern: "^[0-9a-f]{64}$" }) }, ["capabilityId", "sessionId", "runId", "task", "opening", "maximum"], false, "Exchange an encrypted buyer offer and seller response through Walrus."),
+    "remote.quote": object({ capabilityId: string("Selected capability ID."), operationId: string("Stable public payment operation ID."), requestId: string("Stable artifact request ID."), runId: string("Demo run ID."), task: string("Brief task summary.", { maxLength: 512 }), briefHash: string("Purchased brief SHA-256 for an analysis variant.", { pattern: "^[0-9a-f]{64}$" }) }, ["capabilityId", "operationId", "requestId", "runId", "task"], false, "Ask a remote seller for its exact x402 quote and protected resource URL."),
+    "remote.purchase-brief": object({ capabilityId: string("Selected market brief capability ID."), operationId: string("Stable public payment operation ID."), requestId: string("Stable artifact request ID."), runId: string("Demo run ID."), task: string("Brief task summary.", { maxLength: 512 }), budget: string("Maximum brief spend in MIST.", { pattern: "^[1-9][0-9]*$" }) }, ["capabilityId", "operationId", "requestId", "runId", "task", "budget"], false, "Plan, buy, verify, and deliver the selected market brief through x402."),
+    "remote.agreement": object({ capabilityId: string("Analysis capability ID."), operationId: string("Stable shielded payment operation ID."), sessionId: string("Stable negotiation session ID."), runId: string("Demo run ID."), briefHash: string("Delivered brief SHA-256.", { pattern: "^[0-9a-f]{64}$" }) }, ["capabilityId", "operationId", "sessionId", "runId", "briefHash"], false, "Request and accept a seller-signed analysis agreement bound to the purchased brief and saved privacy rule."),
+    "remote.settle-analysis": object({ sessionId: string("Accepted analysis session ID."), operationId: string("Stable shielded payment operation ID.") }, ["sessionId", "operationId"], false, "Settle the accepted analysis agreement through the approved shielded pool plan."),
+    "remote.delivery": object({ sessionId: string("Accepted analysis session ID."), operationId: string("Finalized shielded payment operation ID.") }, ["sessionId", "operationId"], false, "Recover the seller payment and decrypt the delivered analysis."),
+    "remote.events": object({ runId: string("Demo run ID.") }, ["runId"], false, "Read safe remote seller activity for the demo."),
+    disclose: object({ "deal-id": string("Deal scope."), auditor: string("Designated auditor identity."), "payment-digest": string("Finalized payment digest."), "transcript-root": string("Authenticated agreement transcript root.") }, ["deal-id", "auditor", "payment-digest", "transcript-root"], true, "Create a deal- and auditor-scoped disclosure package."),
+    "audit.verify": object({ package: string("Seal ciphertext or mock disclosure package."), auditor: string("This auditor identity."), "deal-id": string("Exact deal scope.") }, ["package", "auditor", "deal-id"], false, "Verify agreement and payment only; delivery remains a separate observation."),
+};
+export function toolSchema(name) {
+    const definition = definitions[name] ?? fail("COMMAND_UNKNOWN", `unknown MCP tool ${name}`);
+    return { name, description: definition.description, mutating: definition.mutating, inputSchema: { type: "object", properties: definition.properties, ...(definition.required.length ? { required: definition.required } : {}), additionalProperties: false } };
+}
+function validateValue(name, schema, value) {
+    if (schema.type === "string" && typeof value !== "string")
+        fail("MCP_ARGUMENT_INVALID", `${name} must be a string`);
+    if (schema.type === "boolean" && typeof value !== "boolean")
+        fail("MCP_ARGUMENT_INVALID", `${name} must be a boolean`);
+    if (schema.type === "array" && !Array.isArray(value))
+        fail("MCP_ARGUMENT_INVALID", `${name} must be an array`);
+    if (schema.type === "object" && (!value || typeof value !== "object" || Array.isArray(value)))
+        fail("MCP_ARGUMENT_INVALID", `${name} must be an object`);
+    if (typeof value === "string" && typeof schema.pattern === "string" && !(new RegExp(schema.pattern).test(value)))
+        fail("MCP_ARGUMENT_INVALID", `${name} has an invalid format`);
+    if (typeof value === "string" && Array.isArray(schema.enum) && !schema.enum.includes(value))
+        fail("MCP_ARGUMENT_INVALID", `${name} is not an allowed value`);
+}
+export function validateToolArguments(spec, raw) {
+    for (const name of Object.keys(raw))
+        if (!(name in spec.inputSchema.properties))
+            fail("MCP_ARGUMENT_UNKNOWN", `${spec.name} does not accept ${name}`);
+    for (const name of spec.inputSchema.required ?? [])
+        if (!(name in raw))
+            fail("MCP_ARGUMENT_REQUIRED", `${spec.name} requires ${name}`);
+    for (const [name, value] of Object.entries(raw))
+        validateValue(name, spec.inputSchema.properties[name], value);
+}
+export function loadMandate(home) {
+    const path = join(home, "mandate.json");
+    if (!existsSync(path))
+        fail("MANDATE_NOT_FOUND", "MCP requires an owner-issued mandate.json");
+    if ((statSync(path).mode & 0o077) !== 0)
+        fail("MANDATE_PERMISSIONS", "mandate.json must be owner-only");
+    let mandate;
+    try {
+        mandate = JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch (error) {
+        return fail("MANDATE_INVALID", "mandate.json is not valid JSON", error);
+    }
+    if (!["supercuts.mandate.v1", "supercuts.mandate.v2"].includes(mandate.version) || !mandate.owner || !Array.isArray(mandate.allowedCommands) || !Array.isArray(mandate.allowedCounterparties) || !Array.isArray(mandate.allowedAssets) || !/^(?:0|[1-9][0-9]*)$/.test(mandate.perDealCeiling) || !/^(?:0|[1-9][0-9]*)$/.test(mandate.totalRunBudget) || !Number.isSafeInteger(mandate.expiresAt))
+        fail("MANDATE_INVALID", "mandate.json has an invalid shape");
+    if (mandate.version === "supercuts.mandate.v1" && mandate.allowPublicX402 !== undefined || mandate.version === "supercuts.mandate.v2" && mandate.allowPublicX402 !== undefined && typeof mandate.allowPublicX402 !== "boolean")
+        fail("MANDATE_INVALID", "public x402 permission has an invalid version or value");
+    if (mandate.requireSettlementPlan !== undefined && typeof mandate.requireSettlementPlan !== "boolean")
+        fail("MANDATE_INVALID", "requireSettlementPlan must be boolean");
+    for (const list of [mandate.allowedCapabilityIds, mandate.allowedCapabilityClasses, mandate.allowedRails])
+        if (list !== undefined && (!Array.isArray(list) || list.some((item) => typeof item !== "string" || !item)))
+            fail("MANDATE_INVALID", "mandate allowlists must contain non-empty strings");
+    if (mandate.allowedRails?.some((rail) => rail !== "x402" && rail !== "shielded"))
+        fail("MANDATE_INVALID", "mandate contains an unsupported rail");
+    return mandate;
+}
+function canonical(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonical).join(",")}]`;
+    if (value && typeof value === "object")
+        return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
+    return JSON.stringify(value);
+}
+/** Turns an allowed MCP invocation into a backend exact-intent approval without exposing its token. */
+export async function executeMandated(app, mandate, command, raw) {
+    const spec = toolSchema(command);
+    validateToolArguments(spec, raw);
+    if (mandate.role !== app.profile.role || Date.now() > mandate.expiresAt)
+        fail(Date.now() > mandate.expiresAt ? "MANDATE_EXPIRED" : "MANDATE_ROLE_MISMATCH", "owner mandate does not authorize this agent");
+    if (!mandate.allowedCommands.includes(command))
+        fail("MANDATE_COMMAND_FORBIDDEN", `mandate does not allow ${command}`);
+    const args = {};
+    for (const [key, value] of Object.entries(raw))
+        args[key] = typeof value === "boolean" ? value : typeof value === "string" ? value : Buffer.from(JSON.stringify(value)).toString("base64url");
+    if (!spec.mutating)
+        return (await app.execute(command, args)).data;
+    const operationId = String(raw["operation-id"]), journalOperationId = command === "settlement.plan" ? `settlement.plan:${operationId}` : operationId;
+    let amount = typeof raw.amount === "string" ? BigInt(raw.amount) : 0n;
+    if ((command === "pay.x402" || command === "pay.shielded") && typeof raw.amount !== "string" && typeof raw["plan-hash"] === "string") {
+        const row = app.store.db.prepare("SELECT plan_json FROM settlement_plans WHERE plan_hash=?").get(raw["plan-hash"]) ?? fail("SETTLEMENT_PLAN_NOT_FOUND", "payment plan is missing");
+        const plan = JSON.parse(row.plan_json);
+        amount = BigInt(plan.maximumAmount);
+    }
+    if ((command === "pay.x402" || command === "pay.shielded") && amount === 0n)
+        fail("MANDATE_AMOUNT_REQUIRED", "payment amount or approved plan is required for budget reservation");
+    if (amount > BigInt(mandate.perDealCeiling))
+        fail("MANDATE_DEAL_CEILING_EXCEEDED", "operation exceeds the owner mandate per-deal ceiling");
+    if (typeof raw.counterparty === "string" && !mandate.allowedCounterparties.includes(raw.counterparty))
+        fail("MANDATE_COUNTERPARTY_FORBIDDEN", "counterparty is outside the owner mandate");
+    if (typeof raw.asset === "string" && !mandate.allowedAssets.includes(raw.asset))
+        fail("MANDATE_ASSET_FORBIDDEN", "asset is outside the owner mandate");
+    if (mandate.requiredPrivacy === "shielded" && command === "pay.x402")
+        fail("MANDATE_PRIVACY_REQUIRED", "owner mandate requires shielded settlement");
+    if (mandate.version === "supercuts.mandate.v2" && command === "pay.x402" && mandate.allowPublicX402 !== true)
+        fail("DEAL_PUBLIC_RAIL_FORBIDDEN", "owner mandate did not opt into public x402");
+    const rail = command === "pay.x402" ? "x402" : command === "pay.shielded" ? "shielded" : undefined;
+    if (rail && mandate.allowedRails && !mandate.allowedRails.includes(rail))
+        fail("MANDATE_RAIL_FORBIDDEN", "settlement rail is outside the owner mandate");
+    if (rail && mandate.requireSettlementPlan && typeof raw["plan-hash"] !== "string")
+        fail("SETTLEMENT_PLAN_REQUIRED", "owner mandate requires an approved settlement plan");
+    const intentHash = createHash("sha256").update(canonical({ command, raw })).digest("hex");
+    app.store.db.exec("CREATE TABLE IF NOT EXISTS mandate_operations(operation_id TEXT PRIMARY KEY,intent_hash TEXT NOT NULL,amount TEXT NOT NULL,created_at INTEGER NOT NULL)");
+    app.store.db.exec("BEGIN IMMEDIATE");
+    try {
+        const existing = app.store.db.prepare("SELECT intent_hash FROM mandate_operations WHERE operation_id=?").get(journalOperationId);
+        if (existing && existing.intent_hash !== intentHash)
+            fail("OPERATION_ID_CONFLICT", "operation ID already identifies another mandated mutation");
+        const spent = app.store.db.prepare("SELECT amount FROM mandate_operations").all().reduce((sum, row) => sum + BigInt(row.amount), 0n);
+        if (!existing && spent + amount > BigInt(mandate.totalRunBudget))
+            fail("MANDATE_RUN_BUDGET_EXCEEDED", "operation exceeds the owner mandate total run budget");
+        if (!existing)
+            app.store.db.prepare("INSERT INTO mandate_operations(operation_id,intent_hash,amount,created_at) VALUES(?,?,?,?)").run(journalOperationId, intentHash, amount.toString(), Date.now());
+        app.store.db.exec("COMMIT");
+    }
+    catch (error) {
+        app.store.db.exec("ROLLBACK");
+        throw error;
+    }
+    // Keep the reservation on every failure: a thrown transport error can occur
+    // after signing or broadcast, so releasing budget here could authorize a
+    // second payment. Exact retries reconcile this same operation identity.
+    const executionArgs = command === "settlement.plan" ? { ...args, "mandate-json": Buffer.from(JSON.stringify(mandate)).toString("base64url") } : args;
+    const preview = app.preview(command, executionArgs), approval = app.approve(preview.challengeId);
+    return (await app.execute(command, { ...executionArgs, "approval-token": approval.token })).data;
+}

package/dist/mcp-bootstrap.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/mcp-bootstrap.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+import { createRequire } from "node:module";
+import { homePath } from "./phase3.js";
+const PACKAGE_VERSION = createRequire(import.meta.url)("../package.json").version;
+const home = homePath({});
+if (existsSync(join(home, "profile.json"))) {
+    await import("./mcp.js");
+}
+else {
+    const send = (value) => process.stdout.write(`${JSON.stringify(value)}\n`);
+    const rl = createInterface({ input: process.stdin });
+    rl.on("line", (line) => {
+        if (Buffer.byteLength(line) > 1024 * 1024)
+            return send({ jsonrpc: "2.0", id: null, error: { code: -32600, message: "Request exceeds 1 MiB" } });
+        let request;
+        try {
+            request = JSON.parse(line);
+        }
+        catch {
+            return send({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+        }
+        if (!request || typeof request !== "object" || typeof request.method !== "string" || request.params !== undefined && (!request.params || typeof request.params !== "object" || Array.isArray(request.params)))
+            return send({ jsonrpc: "2.0", id: null, error: { code: -32600, message: "Invalid JSON-RPC request" } });
+        if (request.method === "initialize")
+            return send({ jsonrpc: "2.0", id: request.id, result: { protocolVersion: "2025-06-18", capabilities: { tools: {} }, serverInfo: { name: "supercuts-setup", version: PACKAGE_VERSION } } });
+        if (request.method === "notifications/initialized")
+            return;
+        if (request.method === "tools/list")
+            return send({ jsonrpc: "2.0", id: request.id, result: { tools: [{ name: "setup.status", description: "Explain how the owner completes one-time buyer setup locally. Do not request secrets in chat.", inputSchema: { type: "object", properties: {}, additionalProperties: false } }] } });
+        if (request.method === "tools/call" && request.params?.name === "setup.status") {
+            const result = { schemaVersion: "supercuts.setup.v1", ok: true, configured: false, home, nextStep: `Run supercuts setup buyer --home ${JSON.stringify(home)} in a terminal, then restart this MCP connection. The command asks for policy limits, seller origins and local credential file paths. Do not paste keys or tokens into Codex.` };
+            return send({ jsonrpc: "2.0", id: request.id, result: { content: [{ type: "text", text: JSON.stringify(result) }], structuredContent: result } });
+        }
+        return send({ jsonrpc: "2.0", id: request.id, error: { code: -32601, message: "Method not found" } });
+    });
+}

package/dist/mcp.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};