tixbit 0.1.2 → 0.2.1

package/README.md

@@ -8,9 +8,9 @@ No command requires a TixBit developer API key. Public discovery and links need
 
 Run `tixbit auth` for public browser sign-in and wallet setup links. This command does not create a CLI session. Open the returned TixBit sign-in page, then complete checkout or selling in your browser. Do not copy browser cookies or bearer tokens.
 
-The public service currently has no supported browser-to-CLI seller session exchange. Website sign-in therefore does not unlock seller API calls from this CLI. Checkout discovery also does not expose the merchant identity needed for automatic Link shared-payment-token authorization. The CLI does not guess it or invent a login endpoint.
+The public service currently has no supported browser-to-CLI seller session exchange. Website sign-in therefore does not unlock seller API calls from this CLI. The `buy` web checkout route does not issue Link spend requests; it expects a token from an authorized integration.
 
-For wallet setup, use [official Link onboarding](https://link.com/agents): install `@stripe/link-cli` and run `link-cli onboard`. This requires your Link account, not a developer API key. It does not by itself authorize this CLI to charge TixBit. Browser checkout is the normal path until automatic authorization is supported; MPP remains available with your wallet.
+For wallet setup, use [official Link onboarding](https://link.com/agents): install `@stripe/link-cli` and run `link-cli onboard`. This requires your Link account, not a developer API key. A Link spend request is a separate approval for a selected purchase. See [Link agent checkout](#link-agent-checkout).
 
 | Operation | Required user authorization |
 |---|---|
@@ -78,11 +78,51 @@ tixbit purchase <listing-id> \
 
 `checkout` remains link-only: it creates a `https://www.tixbit.com/checkout/process` URL for browser completion. `purchase` is the separate public MPP machine surface. It uses the official `mppx` client to answer the server's HTTP 402 challenge and currently selects the Tempo one-time charge rail configured by the server.
 
+### Stripe Link machine checkout
+
+Sign in to Link once, then start a purchase with a total price limit:
+
+TixBit 0.2.0 needs Node.js 22 or later. The included Link CLI uses your local Link sign-in; TixBit does not ask for a developer API key.
+
+```sh
+npx @stripe/link-cli auth login
+tixbit link start <listing-id> --quantity 1 --email buyer@example.com --max-price 25.00
+```
+
+`link start` returns the exact server total and an `approvalUrl`. Open that URL and approve the spend request in Link. Then use the returned order reference:
+
+```sh
+tixbit link complete <order-reference>
+```
+
+The second command checks approval, sends one Stripe MPP credential, and reports whether the ticket was issued. If approval is still pending, it returns the same URL without sending payment. If the payment result is uncertain, use `link complete` with the same order reference. The CLI stores the purchase key in a private file under `~/.local/state/tixbit/link` (or `XDG_STATE_HOME`) and never prints or saves the Link payment token. Keep that file until the order is settled. Each command returns JSON; `approval_required` and payment failures use exit code 2.
+
+Each spend request includes its TixBit order reference in the approval details. Link can still rate limit a matching amount and merchant for a short time, even after a request is canceled. If Link rejects a request, the CLI reports a safe error code such as `LINK_DUPLICATE_REQUEST` or `LINK_NETWORK_UNAVAILABLE` without printing Link credentials.
+
 `--email` is always required and is never inferred from git or local account state. If a request times out or returns `pending` or `manual_review_required`, reuse the same idempotency key and follow the returned `action`; do not start another payment.
 
+### Link agent checkout
+
+Stripe's [Link CLI](https://github.com/stripe/link-cli) provides the spend-request and MPP payment tools. An agent host that supports local MCP servers can add it alongside TixBit:
+
+```json
+{
+  "mcpServers": {
+    "link": {
+      "command": "npx",
+      "args": ["@stripe/link-cli", "--mcp"]
+    }
+  }
+}
+```
+
+The buyer signs in with `link-cli auth login` and approves each spend request in Link. For a TixBit purchase, first POST the selected listing, quantity, buyer email, and a new UUID v4 idempotency key to `https://mcp.tixbit.com/api/purchase`. Inspect the `402` order total and Stripe challenge. Create a `shared_payment_token` spend request for that challenge's `network_id` and total in cents. After Link reports approval, use `link-cli mpp pay` with the same URL and identical POST body, including the original idempotency key. Link CLI handles the one-time credential; do not print or copy an SPT. Treat `pending` or `manual_review_required` as non-final and reconcile by the original idempotency key.
+
+This flow requires the TixBit MCP server to advertise Stripe in its `402` challenge. The published `tixbit purchase` command still selects Tempo. The `tixbit buy --confirm` command still uses the separate web checkout integration and cannot create a Link spend request. An agent host must expose Link's spend-request and MPP tools to its agent; this package cannot add tools to a third-party host such as Muse.
+
 ### Live inventory, Stripe Link, and seller commands
 
-These additions require a build of this PR or a later authorized package release. The existing registry package is still named `tixbit`; this PR does not publish it.
+These commands are in `tixbit@0.1.2`.
 
 ```sh
 # Refreshed listings, not a reservation. Fails if live freshness is unavailable.
@@ -150,6 +190,7 @@ tixbit purchase <listing-id> --quantity 2 --email buyer@example.com --confirm --
 | `listings <eventId>` | Get available ticket listings for an event |
 | `checkout <listingId>` | Get a checkout link to buy tickets |
 | `purchase <listingId>` | Buy a selected listing through MPP with explicit confirmation and total cap |
+| `link start <listingId>` / `link complete <orderReference>` | Approve and pay for a ticket with Stripe Link |
 | `quote <eventId>` | Refresh live listings, with freshness metadata |
 | `buy <listingId>` | Quote or confirm a capped Stripe Link purchase |
 | `sell list` / `sell create` | Use the existing gated seller API |

package/dist/cli.js

@@ -42,7 +42,7 @@ function redact(value, secrets = []) {
 }
 
 // src/cli.ts
-import { createRequire } from "module";
+import { createRequire as createRequire2 } from "module";
 
 // src/client.ts
 var DEFAULT_BASE_URL = "https://www.tixbit.com";
@@ -852,6 +852,287 @@ var TixBitTimeoutError = class extends Error {
   }
 };
 
+// src/link.ts
+import { execFile } from "child_process";
+import { randomUUID } from "crypto";
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import { homedir } from "os";
+import { dirname, join } from "path";
+import { createRequire } from "module";
+import { promisify } from "util";
+import { Challenge } from "mppx";
+import { Mppx, stripe } from "mppx/client";
+var execFileAsync = promisify(execFile);
+var PAYMENT_URL = "https://mcp.tixbit.com/api/purchase";
+var ORDER_REFERENCE = /^TBM-[ABCDEFGHJKLMNPQRSTUVWXYZ23456789]{10}$/;
+var NETWORK_ID = /^profile_[A-Za-z0-9]+$/;
+var SPEND_REQUEST_ID = /^lsrq_[A-Za-z0-9]+$/;
+var require2 = createRequire(import.meta.url);
+function linkCliEntry() {
+  if (Number(process.versions.node.split(".")[0]) < 22) {
+    throw new LinkCheckoutError("LINK_NODE_UNSUPPORTED", "TixBit 0.2.0 needs Node.js 22 or later.");
+  }
+  try {
+    return join(dirname(require2.resolve("@stripe/link-cli/package.json")), "dist", "cli.js");
+  } catch {
+    throw new LinkCheckoutError("LINK_CLI_MISSING", "The bundled Link CLI is missing. Reinstall TixBit, then retry.");
+  }
+}
+var LinkCheckoutError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+function paymentEndpoint() {
+  const endpoint = process.env.TIXBIT_PAYMENT_URL ?? PAYMENT_URL;
+  new TixBitClient({ paymentEndpoint: endpoint });
+  return endpoint;
+}
+function statePath(orderReference) {
+  if (!ORDER_REFERENCE.test(orderReference)) throw new LinkCheckoutError("INVALID_ORDER_REFERENCE", "Enter the order reference shown by link start.");
+  const base = process.env.XDG_STATE_HOME || join(homedir(), ".local", "state");
+  return join(base, "tixbit", "link", `${orderReference}.json`);
+}
+async function saveState(state) {
+  const path = statePath(state.orderReference);
+  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  const temporary = `${path}.${randomUUID()}.tmp`;
+  await writeFile(temporary, JSON.stringify(state), { mode: 384, flag: "wx" });
+  await rename(temporary, path);
+}
+async function loadState(orderReference) {
+  let value;
+  try {
+    value = JSON.parse(await readFile(statePath(orderReference), "utf8"));
+  } catch {
+    throw new LinkCheckoutError("CHECKOUT_NOT_FOUND", "This Link checkout was not found on this device.");
+  }
+  if (value.version !== 1 || value.orderReference !== orderReference || !SPEND_REQUEST_ID.test(value.spendRequestId) || !NETWORK_ID.test(value.networkId) || !Number.isSafeInteger(value.amountCents) || value.amountCents <= 0 || typeof value.externalId !== "string" || !value.externalId || typeof value.requestBody !== "string") {
+    throw new LinkCheckoutError("INVALID_CHECKOUT_STATE", "The saved Link checkout is invalid. Contact TixBit support before starting another purchase.");
+  }
+  return value;
+}
+async function linkCli(args) {
+  let stdout;
+  const entry = linkCliEntry();
+  try {
+    const result = await execFileAsync(process.execPath, [entry, ...args, "--format", "json"], {
+      timeout: 3e4,
+      maxBuffer: 1024 * 1024,
+      windowsHide: true
+    });
+    stdout = typeof result === "string" ? result : result.stdout;
+  } catch (error) {
+    const output2 = error && typeof error === "object" && "stdout" in error ? String(error.stdout) : "";
+    let message = "";
+    try {
+      const parsed = JSON.parse(output2);
+      const data = parsed && typeof parsed === "object" && !Array.isArray(parsed) && "data" in parsed ? parsed.data : parsed;
+      const item = Array.isArray(data) ? data[0] : data;
+      if (item && typeof item === "object" && "message" in item) {
+        message = String(item.message);
+      } else {
+        const nested = parsed && typeof parsed === "object" && !Array.isArray(parsed) && "error" in parsed ? parsed.error : void 0;
+        if (nested && typeof nested === "object" && "message" in nested) {
+          message = String(nested.message);
+        }
+      }
+    } catch {
+    }
+    if (/duplicate spend requests|matching spend request/i.test(message)) {
+      throw new LinkCheckoutError("LINK_DUPLICATE_REQUEST", "Link blocked a matching spend request. Wait a few minutes, then start a new checkout.");
+    }
+    if (/Invalid network_id|could not retrieve merchant information/i.test(message)) {
+      throw new LinkCheckoutError("LINK_NETWORK_UNAVAILABLE", "Link could not resolve the merchant profile in this account and mode. No payment was sent.");
+    }
+    throw new LinkCheckoutError("LINK_CLI_FAILED", "Link could not complete this step. Check Link sign-in and payment methods, then retry.");
+  }
+  try {
+    const parsed = JSON.parse(stdout);
+    const data = parsed && typeof parsed === "object" && !Array.isArray(parsed) && "data" in parsed ? parsed.data : parsed;
+    const item = Array.isArray(data) ? data[0] : data;
+    if (item && typeof item === "object") return item;
+  } catch {
+  }
+  throw new LinkCheckoutError("LINK_CLI_RESPONSE_INVALID", "Link returned an invalid response. No payment was submitted.");
+}
+function stripeChallenge(response, maxAmountCents) {
+  let challenges;
+  try {
+    challenges = Challenge.fromResponseList(response);
+  } catch {
+    throw new LinkCheckoutError("STRIPE_CHALLENGE_MISSING", "TixBit did not offer a valid Stripe Link payment challenge.");
+  }
+  const challenge = challenges.find((item) => item.method === "stripe" && item.intent === "charge");
+  const request = challenge?.request;
+  const amount = Number(request?.amount);
+  const details = request?.methodDetails;
+  if (!challenge || request?.currency !== "usd" || !Number.isSafeInteger(amount) || amount <= 0 || amount > maxAmountCents || typeof details?.networkId !== "string" || !NETWORK_ID.test(details.networkId) || typeof request.externalId !== "string" || !request.externalId) {
+    throw new LinkCheckoutError("STRIPE_CHALLENGE_UNSAFE", "The Stripe challenge is missing order details or exceeds your total price limit.");
+  }
+  return { amountCents: amount, networkId: details.networkId, externalId: request.externalId };
+}
+function approvalUrl(value) {
+  if (typeof value !== "string") throw new LinkCheckoutError("LINK_APPROVAL_MISSING", "Link did not return an approval link.");
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new LinkCheckoutError("LINK_APPROVAL_INVALID", "Link returned an unexpected approval link.");
+  }
+  if (url.origin !== "https://app.link.com" || !url.pathname.startsWith("/activity/approve/")) {
+    throw new LinkCheckoutError("LINK_APPROVAL_INVALID", "Link returned an unexpected approval link.");
+  }
+  return url.toString();
+}
+async function startLinkPurchase(input) {
+  linkCliEntry();
+  const purchase = normalizePurchaseTicketsParams({ ...input, idempotencyKey: randomUUID() });
+  if (!Number.isSafeInteger(input.maxAmountCents) || input.maxAmountCents <= 0) {
+    throw new LinkCheckoutError("INVALID_MAX_PRICE", "Set a positive total price limit.");
+  }
+  const requestBody = JSON.stringify(purchase);
+  const response = await fetch(paymentEndpoint(), {
+    method: "POST",
+    redirect: "error",
+    headers: { "content-type": "application/json", "accept-payment": "stripe/charge" },
+    body: requestBody,
+    signal: AbortSignal.timeout(3e4)
+  });
+  if (response.status !== 402) throw new LinkCheckoutError("PURCHASE_PREPARE_FAILED", `TixBit could not prepare this checkout (HTTP ${response.status}).`);
+  const { amountCents, networkId, externalId } = stripeChallenge(response, input.maxAmountCents);
+  const body = await response.json();
+  if (typeof body.orderReference !== "string" || !ORDER_REFERENCE.test(body.orderReference)) {
+    throw new LinkCheckoutError("ORDER_REFERENCE_MISSING", "TixBit did not return an order reference.");
+  }
+  const context = `Approve one TixBit ticket purchase for order ${body.orderReference}, listing ${purchase.listingId}, quantity ${purchase.quantity}. The total charge is USD ${(amountCents / 100).toFixed(2)}. This request permits one machine payment for this selected order only.`;
+  const created = await linkCli([
+    "spend-request",
+    "create",
+    "--credential-type",
+    "shared_payment_token",
+    "--network-id",
+    networkId,
+    "--amount",
+    String(amountCents),
+    "--currency",
+    "usd",
+    "--context",
+    context,
+    "--metadata",
+    `order_reference:${body.orderReference}`,
+    "--request-approval"
+  ]);
+  if (typeof created.id !== "string" || !SPEND_REQUEST_ID.test(created.id)) {
+    throw new LinkCheckoutError("LINK_SPEND_REQUEST_INVALID", "Link did not return a valid spend request.");
+  }
+  const url = approvalUrl(created.approval_url);
+  await saveState({
+    version: 1,
+    orderReference: body.orderReference,
+    requestBody,
+    spendRequestId: created.id,
+    approvalUrl: url,
+    amountCents,
+    networkId,
+    externalId
+  });
+  return {
+    success: false,
+    status: "approval_required",
+    orderReference: body.orderReference,
+    amountCents,
+    approvalUrl: url,
+    action: `Approve in Link, then run: tixbit link complete ${body.orderReference}`
+  };
+}
+async function completeLinkPurchase(orderReference) {
+  const state = await loadState(orderReference);
+  if (state.result?.status === "fulfilled" || state.result?.status === "manual_review_required") return state.result;
+  const approval = await linkCli(["spend-request", "retrieve", state.spendRequestId, "--include", "shared_payment_token"]);
+  if (["denied", "declined", "expired", "canceled", "cancelled"].includes(String(approval.status))) {
+    return {
+      success: false,
+      status: "rejected",
+      orderReference,
+      amountCents: state.amountCents,
+      error: { code: "LINK_APPROVAL_ENDED", message: "The Link spend approval ended without payment." },
+      action: "Start a new Link checkout if you still want this ticket."
+    };
+  }
+  if (approval.status !== "approved") {
+    return {
+      success: false,
+      status: "approval_required",
+      orderReference,
+      amountCents: state.amountCents,
+      approvalUrl: state.approvalUrl,
+      action: "Approve this spend request in Link, then run the same complete command."
+    };
+  }
+  const token = approval.shared_payment_token?.id;
+  if (approval.credential_type !== "shared_payment_token" || approval.amount !== state.amountCents || approval.currency !== "usd" || approval.network_id !== state.networkId || typeof token !== "string" || !/^spt_[A-Za-z0-9_]+$/.test(token)) {
+    throw new LinkCheckoutError("LINK_APPROVAL_MISMATCH", "The Link approval does not match this order. No payment was submitted.");
+  }
+  let challengeChanged = false;
+  const payments = Mppx.create({
+    methods: [stripe.charge({ paymentMethod: "link", createToken: async ({ amount, currency, networkId }) => {
+      if (Number(amount) !== state.amountCents || currency !== "usd" || networkId !== state.networkId) {
+        challengeChanged = true;
+        throw new LinkCheckoutError("CHALLENGE_CHANGED", "The payment amount or network changed. No payment was submitted.");
+      }
+      return token;
+    } })],
+    polyfill: false,
+    maxPaymentRetries: 1,
+    onChallenge: async (challenge) => {
+      const request2 = challenge.request;
+      const details = request2.methodDetails;
+      if (challenge.method !== "stripe" || challenge.intent !== "charge" || Number(request2.amount) !== state.amountCents || request2.currency !== "usd" || details?.networkId !== state.networkId || request2.externalId !== state.externalId) {
+        challengeChanged = true;
+        throw new LinkCheckoutError("CHALLENGE_CHANGED", "The order or payment amount changed. No payment was submitted.");
+      }
+      return void 0;
+    }
+  });
+  let decline = false;
+  const client2 = new TixBitClient({
+    paymentEndpoint: paymentEndpoint(),
+    timeoutMs: 9e4,
+    paymentFetch: async (url, init) => {
+      const response = await payments.fetch(url, { ...init, headers: { ...init?.headers, "accept-payment": "stripe/charge" } });
+      if (response.status === 402) {
+        const body = await response.clone().json().catch(() => ({}));
+        decline = typeof body.detail === "string" && /card was declined/i.test(body.detail);
+      }
+      return response;
+    }
+  });
+  const request = JSON.parse(state.requestBody);
+  const result = await client2.purchaseTickets(request);
+  if (challengeChanged) throw new LinkCheckoutError("CHALLENGE_CHANGED", "The order or payment amount changed. No payment was submitted.");
+  if (result.orderReference && result.orderReference !== orderReference) {
+    throw new LinkCheckoutError("ORDER_REFERENCE_CHANGED", "TixBit returned a different order reference. Check the order before another payment.");
+  }
+  const output2 = {
+    success: result.success,
+    status: decline ? "payment_failed" : result.status,
+    orderReference,
+    amountCents: state.amountCents,
+    ...result.order && !decline ? { order: result.order } : {},
+    ...!result.success ? {
+      error: decline ? { code: "CARD_DECLINED", message: "Stripe declined the card selected in Link." } : result.error,
+      action: decline ? "Select another card in Link and start a new spend approval. No ticket was issued." : result.action
+    } : {}
+  };
+  if (output2.status === "fulfilled" || output2.status === "manual_review_required") {
+    state.result = output2;
+    await saveState(state);
+  }
+  return output2;
+}
+
 // src/cli.ts
 var client = (() => {
   try {
@@ -860,7 +1141,7 @@ var client = (() => {
     return handleError(error);
   }
 })();
-var packageJson = createRequire(import.meta.url)("../package.json");
+var packageJson = createRequire2(import.meta.url)("../package.json");
 function output(data, json) {
   data = redact(data, [process.env.TIXBIT_LINK_TOKEN ?? "", process.env.TIXBIT_ACCESS_TOKEN ?? "", process.env.MPPX_PRIVATE_KEY ?? ""]);
   if (data && typeof data === "object" && !Array.isArray(data)) {
@@ -1103,9 +1384,9 @@ program.command("checkout <listingId>").description("Get a checkout link to buy
       listingInfo = (await client.getListing(listingId)).listing;
     } catch {
     }
-    const link = client.createCheckoutLink({ listingId, quantity });
+    const link2 = client.createCheckoutLink({ listingId, quantity });
     if (isJson) {
-      output({ ...link, listing: listingInfo ?? null }, true);
+      output({ ...link2, listing: listingInfo ?? null }, true);
       return;
     }
     process.stdout.write("\n\u{1F39F}  Checkout Link\n\n");
@@ -1126,7 +1407,7 @@ program.command("checkout <listingId>").description("Get a checkout link to buy
     process.stdout.write(`   Quantity: ${quantity}
 
 `);
-    process.stdout.write(`   ${link.url}
+    process.stdout.write(`   ${link2.url}
 
 `);
     process.stdout.write(
@@ -1136,6 +1417,41 @@ program.command("checkout <listingId>").description("Get a checkout link to buy
     handleError(err);
   }
 });
+var link = program.command("link").description("Buy tickets with a Stripe Link spend approval");
+link.command("start <listingId>").description("Prepare a capped purchase and return a Link approval URL").requiredOption("--quantity <n>", "Number of tickets to buy").requiredOption("--email <email>", "Buyer email for ticket delivery").requiredOption("--max-price <total>", "Maximum total USD charge").option("--name <name>", "Optional buyer name").action(async (listingId, opts) => {
+  try {
+    output(await startLinkPurchase({
+      listingId,
+      quantity: positiveInteger(opts.quantity, "--quantity", 8),
+      email: opts.email,
+      name: opts.name,
+      maxAmountCents: usdCents(opts.maxPrice)
+    }), true);
+  } catch (error) {
+    const known = error instanceof LinkCheckoutError || error instanceof TypeError || error instanceof RangeError;
+    output({ success: false, status: "rejected", error: {
+      code: error instanceof LinkCheckoutError ? error.code : "LINK_CHECKOUT_FAILED",
+      message: known && error instanceof Error ? error.message : "Link checkout could not start. Check your connection and try again."
+    } }, true);
+  }
+});
+link.command("complete <orderReference>").description("Complete an approved Link purchase with the saved order").action(async (orderReference) => {
+  try {
+    output(await completeLinkPurchase(orderReference), true);
+  } catch (error) {
+    const noPayment = error instanceof LinkCheckoutError && [
+      "INVALID_ORDER_REFERENCE",
+      "CHECKOUT_NOT_FOUND",
+      "INVALID_CHECKOUT_STATE",
+      "LINK_APPROVAL_MISMATCH",
+      "CHALLENGE_CHANGED"
+    ].includes(error.code);
+    output({ success: false, status: noPayment ? "rejected" : "pending", orderReference, error: {
+      code: error instanceof LinkCheckoutError ? error.code : "LINK_CHECKOUT_FAILED",
+      message: error instanceof LinkCheckoutError ? error.message : "Payment outcome is unknown. Check this order before another payment."
+    }, action: noPayment ? "Check the saved order and approval before another payment." : "Run the same complete command again to check this order. Do not start a new purchase yet." }, true);
+  }
+});
 program.command("purchase <listingId>").description("Buy tickets through MPP machine checkout").requiredOption("--quantity <n>", "Number of tickets to buy").option("--email <email>", "Buyer email for confirmation and delivery").option("--name <name>", "Optional buyer/recipient name").option(
   "--idempotency-key <uuid>",
   "Stable UUID v4 to reuse for retries and recovery"
@@ -1156,16 +1472,16 @@ program.command("purchase <listingId>").description("Buy tickets through MPP mac
       name: opts.name,
       idempotencyKey: opts.idempotencyKey
     });
-    const paymentEndpoint = process.env.TIXBIT_PAYMENT_URL;
-    new TixBitClient({ paymentEndpoint });
+    const paymentEndpoint2 = process.env.TIXBIT_PAYMENT_URL;
+    new TixBitClient({ paymentEndpoint: paymentEndpoint2 });
     publicErrorCode = "MPP_CLIENT_SETUP_FAILED";
     publicErrorMessage = "MPP payment client setup failed. Check the selected mppx account and local wallet configuration.";
-    const [{ Mppx, tempo }, { resolveAccount }] = await Promise.all([
+    const [{ Mppx: Mppx2, tempo }, { resolveAccount }] = await Promise.all([
       import("mppx/client"),
       import("mppx/cli")
     ]);
     const account = await resolveAccount(opts.account);
-    const payments = Mppx.create({
+    const payments = Mppx2.create({
       methods: [tempo({ account })],
       polyfill: false,
       maxPaymentRetries: 1,
@@ -1176,7 +1492,7 @@ program.command("purchase <listingId>").description("Buy tickets through MPP mac
     });
     const purchaseClient = new TixBitClient({
       baseUrl: process.env.TIXBIT_BASE_URL,
-      paymentEndpoint,
+      paymentEndpoint: paymentEndpoint2,
       paymentFetch: (input, init) => payments.fetch(input, init)
     });
     const result = await purchaseClient.purchaseTickets(purchase);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tixbit",
-  "version": "0.1.2",
+  "version": "0.2.1",
   "description": "Search events, browse listings, view seatmaps, and purchase TixBit tickets through MPP",
   "type": "module",
   "main": "./dist/index.js",
@@ -30,6 +30,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@stripe/link-cli": "0.22.0",
     "commander": "^13.1.0",
     "mppx": "^0.8.15"
   },
@@ -40,7 +41,7 @@
     "vitest": "3.2.7"
   },
   "engines": {
-    "node": "^20.19.0 || >=22.12.0"
+    "node": ">=22.12.0"
   },
   "keywords": [
     "tixbit",

package/skills/tixbit/SKILL.md

@@ -12,9 +12,21 @@ npx tixbit <command>
 ```
 
 Discovery, listings, seatmaps, event URLs, link-only checkout, and machine
-purchase require no TixBit API key. Machine purchase requires an mppx account
-and an email address supplied by the buyer. Never infer the email from git, OS,
-or account state.
+purchase require no TixBit API key. Link machine purchase needs the buyer's
+Link sign-in, spend approval, and Node.js 22 or later. Tempo machine purchase needs an mppx account.
+Both need an email address supplied by the buyer. Never infer the email from
+git, OS, or account state.
+
+For Stripe Link MPP payments, pair this skill with Stripe's official
+`@stripe/link-cli` MCP server. Add `{"mcpServers":{"link":{"command":"npx","args":["@stripe/link-cli","--mcp"]}}}`
+to a host that supports local MCP servers. The buyer must connect their Link
+account. First inspect TixBit's `402` Stripe offer and exact order total, then
+request an approved `shared_payment_token` spend for that network ID and total.
+Use Link's `mpp pay` tool with the same purchase URL and POST body, including the
+original UUID v4 idempotency key. Keep the one-time token inside Link CLI. The
+published `tixbit purchase` command selects Tempo, and `tixbit buy --confirm`
+cannot create a Link spend request. If the host does not expose Link's spend
+request and MPP tools, use browser checkout until that host adds them.
 
 ## Commands
 
@@ -27,7 +39,13 @@ npx tixbit url <eventId>
 # Link-only browser checkout; this does not charge the buyer.
 npx tixbit checkout <listingId> --quantity 2 --json
 
-# Machine checkout; obtain explicit authorization before any real payment.
+# Stripe Link machine checkout. Send approvalUrl to the buyer immediately.
+npx tixbit link start <listingId> --quantity 1 \
+  --email buyer@example.com --max-price <approved-total-usd>
+# After the buyer approves, use the orderReference returned by start.
+npx tixbit link complete <orderReference>
+
+# Tempo machine checkout; obtain explicit authorization before any real payment.
 npx tixbit purchase <listingId> \
   --quantity 2 \
   --email buyer@example.com \
@@ -36,13 +54,14 @@ npx tixbit purchase <listingId> \
   --json
 ```
 
-## Additional commands (requires this build or a later release)
+## Additional commands (in `tixbit@0.1.2`)
 
 - `tixbit quote <eventId> --size 100`: refresh existing listings; requires live freshness.
 - `tixbit auth`: public browser sign-in and wallet setup links; not a CLI login. No command needs a developer API key.
 - `tixbit buy <listingId> --quantity 2 --max-price <total-usd> --email <buyer-email>`: quote only, no payment credential required.
+- `tixbit link start` prepares one Stripe Link spend request, enforces the total cap, and returns an approval URL without charging. Present that URL immediately. `tixbit link complete` checks approval and pays with the saved order; use the same order reference for recovery. Do not print or extract the Link payment token.
 - Add `--confirm` only after approval. Without payment authorization, the result is `authorization_required` with a browser checkout URL, not a payment. Review the final total in the browser; the CLI cap is not transferred there. Optional advanced integrations can inject a user-approved `TIXBIT_LINK_TOKEN`; automatic payment still requires server cap support. Never put tokens in arguments.
-- Link supports 4-12 alphanumeric IDs only, not native `sl_UUID` listings. Use browser checkout for unsupported listings.
+- The older `buy` web route supports 4-12 alphanumeric IDs only. The new Link MPP command accepts the listing IDs supported by the MPP server.
 - Without a signed-in user integration, seller commands return browser sign-in guidance and do not read or submit listings. Browser-to-CLI seller sessions are not supported. Do not extract browser tokens. Optional authorized integrations may supply `TIXBIT_ACCESS_TOKEN`; seller creation still requires `--confirm`, `termsAccepted: true`, and server ownership/access checks.
 - All commands emit JSON, including errors. Preserve full case-sensitive IDs.
 - Never retry uncertain Link payment automatically. Reconcile with support and Stripe Link first. Read seller listings after uncertain creation.
@@ -53,9 +72,12 @@ npx tixbit purchase <listingId> \
 1. Search and select the event.
 2. Fetch listings and the seatmap before presenting ticket options.
 3. Confirm the exact listing, quantity, and buyer email.
-4. Use `checkout` for user-completed browser payment, or `purchase` only when the
-   user explicitly authorizes machine payment.
-5. Preserve the original idempotency key across retries and recovery checks.
+4. Use `checkout` for user-completed browser payment. For Stripe Link machine
+   payment, run `link start` with an approved cap, show `approvalUrl`, then run
+   `link complete` after approval. Use `purchase` for Tempo only when the user
+   explicitly authorizes that payment.
+5. Use the same order reference with `link complete` for recovery. For Tempo,
+   preserve the original idempotency key across retries and recovery checks.
 6. Treat `pending` and `manual_review_required` as non-final. Follow the returned
    `action`; never create another payment or ticket purchase for the same order.