@ukiyocompute/mcp 0.0.0-stage → 0.2.1

package/dist/main.js

@@ -0,0 +1,807 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// packages/machine-client/src/state.ts
+var state_exports = {};
+__export(state_exports, {
+  withMachineState: () => withMachineState
+});
+import { DatabaseSync } from "node:sqlite";
+import { mkdir, open, readFile, rename, chmod, lstat } from "node:fs/promises";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+async function withMachineState(directory2, fn) {
+  await mkdir(directory2, { recursive: true, mode: 448 });
+  const dir = await lstat(directory2);
+  if (!dir.isDirectory() || dir.isSymbolicLink() || dir.uid !== process.getuid?.()) throw Error("State directory must be an owned directory, not a symlink");
+  await chmod(directory2, 448);
+  for (const name of ["lock.sqlite", "state.json"]) {
+    try {
+      const info = await lstat(join(directory2, name));
+      if (!info.isFile() || info.isSymbolicLink() || info.uid !== process.getuid?.()) throw Error("Unsafe machine state file");
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+    }
+  }
+  const lock = new DatabaseSync(join(directory2, "lock.sqlite"), { timeout: 1e3 });
+  try {
+    lock.exec("CREATE TABLE IF NOT EXISTS client_lock (id INTEGER PRIMARY KEY); BEGIN IMMEDIATE;");
+    const file = join(directory2, "state.json");
+    let state;
+    try {
+      state = JSON.parse(await readFile(file, "utf8"));
+    } catch (e) {
+      if (e.code !== "ENOENT") throw e;
+      state = { reservedMinor: 0, purchases: {} };
+    }
+    if (!Number.isSafeInteger(state.reservedMinor) || state.reservedMinor < 0 || !state.purchases) throw Error("Invalid machine client state; refusing to reset spend history");
+    const save = async () => {
+      const temporary = join(directory2, `state-${randomUUID()}.tmp`), f = await open(temporary, "wx", 384);
+      try {
+        await f.writeFile(JSON.stringify(state));
+        await f.sync();
+      } finally {
+        await f.close();
+      }
+      await rename(temporary, file);
+      const d = await open(directory2, "r");
+      try {
+        await d.sync();
+      } finally {
+        await d.close();
+      }
+    };
+    return await fn(state, save);
+  } finally {
+    try {
+      lock.exec("ROLLBACK");
+    } catch {
+    }
+    lock.close();
+  }
+}
+var init_state = __esm({
+  "packages/machine-client/src/state.ts"() {
+    "use strict";
+  }
+});
+
+// apps/mcp/src/main.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// packages/machine-client/src/index.ts
+import { readFile as readFile2, lstat as lstat2 } from "node:fs/promises";
+import { resolve } from "node:path";
+import { privateKeyToAccount } from "viem/accounts";
+import { createKeyPairSignerFromBytes } from "@solana/kit";
+import { x402Client } from "@x402/fetch";
+import { registerExactEvmScheme } from "@x402/evm/exact/client";
+import { Mppx, tempo } from "mppx/client";
+import { Challenge } from "mppx";
+import { solana } from "@solana/mpp/client";
+import { generateKeyPair, exportJWK, importJWK, compactDecrypt } from "jose";
+
+// packages/core/src/machine-client-policy.ts
+import { createHash } from "node:crypto";
+
+// packages/core/src/domain.ts
+var DomainError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "DomainError";
+  }
+  code;
+  details;
+};
+
+// packages/core/src/machine-client-policy.ts
+function canonical(v) {
+  if (v === null || typeof v === "string" || typeof v === "boolean") return JSON.stringify(v);
+  if (typeof v === "number" && Number.isSafeInteger(v)) return String(v);
+  if (Array.isArray(v)) return "[" + v.map(canonical).join(",") + "]";
+  if (v && typeof v === "object") return "{" + Object.keys(v).sort().map((k) => JSON.stringify(k) + ":" + canonical(v[k])).join(",") + "}";
+  throw new DomainError("INVALID_QUOTE", "Invalid quote JSON");
+}
+function validateMachineQuote(envelope, request, policy) {
+  const e = envelope, q = e?.quote;
+  const fail = () => {
+    throw new DomainError("QUOTE_MISMATCH", "Quote differs from the requested purchase or local payment policy");
+  };
+  if (!q || typeof e.digest !== "string" || createHash("sha256").update(canonical(q)).digest("hex") !== e.digest) fail();
+  if (q.origin !== policy.origin || canonical(q.request) !== canonical(request) || !Number.isSafeInteger(q.amountMinor) || q.amountMinor <= 0 || !Number.isFinite(Date.parse(q.expiresAt)) || Date.parse(q.expiresAt) <= Date.now()) fail();
+  if (![policy.perPaymentMinor, policy.remainingMinor].every((x) => Number.isSafeInteger(x) && x >= 0) || q.amountMinor > policy.perPaymentMinor || q.amountMinor > policy.remainingMinor || q.amountMinor > q.request.maxPriceMinor) throw new DomainError("SPEND_CAP_EXCEEDED", "Payment exceeds a local cap");
+  const r = q.requirements;
+  if (q.request.method === "base") {
+    if (r?.scheme !== "exact" || r.network !== policy.network || String(r.asset).toLowerCase() !== policy.asset.toLowerCase() || String(r.payTo).toLowerCase() !== policy.recipient.toLowerCase() || r.amount !== (BigInt(q.amountMinor) * 10000n).toString()) fail();
+  } else {
+    if (!["tempo", "solana"].includes(q.request.method)) fail();
+    const details = r?.methodDetails;
+    const allowed = q.request.method === "tempo" ? ["chainId", "feePayer"] : ["network", "decimals", "tokenProgram", "recentBlockhash"];
+    if (!details || Object.keys(details).some((k) => !allowed.includes(k)) || details.feePayer === true || r.splits || r.decimals !== void 0 && r.decimals !== 6) fail();
+    if (q.request.method === "solana" && (details.decimals !== 6 || details.tokenProgram && details.tokenProgram !== "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA")) fail();
+    const chain = q.request.method === "tempo" ? `eip155:${r?.methodDetails?.chainId}` : r?.methodDetails?.network === "devnet" ? "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1" : r?.methodDetails?.network === "mainnet" ? "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp" : "";
+    if (chain !== policy.network || r?.currency !== policy.asset || r?.recipient !== policy.recipient || r?.amount !== (BigInt(q.amountMinor) * 10000n).toString()) fail();
+  }
+  return { digest: e.digest, amountMinor: q.amountMinor, quote: q };
+}
+var machineQuoteDigest = (value) => createHash("sha256").update(canonical(value)).digest("hex");
+
+// packages/machine-client/src/account-topups.ts
+var FundingError = class extends Error {
+  constructor(code, message, status = 0, body = null) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.body = body;
+  }
+  code;
+  status;
+  body;
+};
+async function fundingRequest(origin, token, path, init = {}, fetcher = fetch) {
+  const url = new URL(path, origin);
+  if (url.origin !== new URL(origin).origin || !url.pathname.startsWith("/api/v1/")) throw new FundingError("INVALID_URL", "Cross-origin funding request refused");
+  const response = await fetcher(url, { ...init, redirect: "error", signal: AbortSignal.timeout(3e4), headers: { authorization: `Bearer ${token}`, ...init.body ? { "content-type": "application/json" } : {}, ...init.headers } });
+  const body = await response.json();
+  if (!response.ok) throw new FundingError(body?.error?.code ?? `HTTP_${response.status}`, body?.error?.message ?? JSON.stringify(body), response.status, body);
+  return body.settlementPending ? { ...body.data, settlementPending: true, message: "Settlement pending; do not pay again." } : body.data ?? body;
+}
+async function createAccountTopup(origin, token, amountMinor, idempotencyKey, fetcher = fetch) {
+  if (!idempotencyKey?.trim()) throw new FundingError("IDEMPOTENCY_KEY_REQUIRED", "Supply one stable top-up key and reuse it on retries");
+  const terms = await fundingRequest(origin, token, "/api/v1/terms", {}, fetcher);
+  if (!terms?.version || !/^[a-f0-9]{64}$/.test(terms.sha256 ?? "") || !/^https:\/\//.test(terms.url ?? "")) throw new FundingError("TERMS_UNAVAILABLE", "Read current approved Terms before authorizing this top-up");
+  return fundingRequest(origin, token, "/api/v1/billing/machine-topups", { method: "POST", headers: { "idempotency-key": idempotencyKey }, body: JSON.stringify({ amountMinor, termsAcceptance: { accepted: true, version: terms.version, sha256: terms.sha256 } }) }, fetcher);
+}
+async function topupChallenge(origin, token, topup, method, fetcher = fetch) {
+  const selected = topup.paymentMethods?.find((m) => m.method === method);
+  if (!selected) throw new FundingError("PAYMENT_METHOD_DISABLED", `Payment method ${method} disabled. Enabled rails: ${(topup.paymentMethods ?? []).map((m) => m.method).join(", ")}`);
+  const expected = `/api/v1/billing/machine-topups/${encodeURIComponent(topup.topUpId)}/pay${method === "tempo" ? "" : "/" + method}`;
+  const url = new URL(selected.url);
+  if (url.username || url.password || url.origin !== new URL(origin).origin || url.pathname !== expected || url.search || url.hash) throw new FundingError("INVALID_URL", "Unexpected top-up payment URL");
+  const response = await fetcher(url, { method: "POST", headers: { "x-ukiyo-api-key": token }, redirect: "error", signal: AbortSignal.timeout(3e4) });
+  const body = await response.json();
+  if (response.status === 202 || response.ok) return { topup: body.data ?? topup, settlementPending: response.status === 202 || body.settlementPending === true, message: response.status === 202 ? "Settlement pending; do not pay again." : void 0 };
+  if (response.status !== 402) throw new FundingError(body?.error?.code ?? `HTTP_${response.status}`, body?.error?.message ?? "Top-up challenge failed", response.status, body);
+  return { topup, paymentUrl: url.href, method, protocol: selected.protocol, challenge: body, paymentRequired: response.headers.get("payment-required"), wwwAuthenticate: response.headers.get("www-authenticate") };
+}
+
+// packages/machine-client/src/index.ts
+async function withMachineState2(directory2, fn) {
+  if (Number(process.versions.node.split(".")[0]) < 24) throw Error("Wallet purchase commands require Node.js 24 or newer");
+  return (await Promise.resolve().then(() => (init_state(), state_exports))).withMachineState(directory2, fn);
+}
+async function loadMachineClient(path) {
+  const cfg = JSON.parse(await readFile2(path, "utf8"));
+  if (!["base", "solana", "tempo"].includes(cfg.method) || !Number.isSafeInteger(cfg.perPaymentMinor) || !Number.isSafeInteger(cfg.totalMinor) || cfg.perPaymentMinor <= 0 || cfg.totalMinor < cfg.perPaymentMinor) throw Error("Explicit positive payment and cumulative caps are required");
+  const url = new URL(cfg.origin);
+  if (url.origin !== cfg.origin || url.protocol !== "https:" && !(url.protocol === "http:" && url.hostname === "127.0.0.1")) throw Error("Configured origin must be HTTPS (loopback allowed for tests)");
+  for (const p of [cfg.walletFile, cfg.stateDirectory]) if (typeof p !== "string" || resolve(p) !== p) throw Error("Wallet and state paths must be absolute");
+  const info = await lstat2(cfg.walletFile);
+  if (!info.isFile() || info.isSymbolicLink() || info.uid !== process.getuid?.() || info.mode & 63) throw Error("Wallet file must be private (0600)");
+  const key = (await readFile2(cfg.walletFile, "utf8")).trim();
+  let signer;
+  try {
+    signer = cfg.method === "solana" ? await createKeyPairSignerFromBytes(Buffer.from(key, "base64")) : privateKeyToAccount(key);
+  } catch {
+    throw Error("Invalid private wallet file");
+  }
+  return new MachinePurchaseClient(cfg, signer);
+}
+var MachinePurchaseClient = class {
+  constructor(config, signer, fetcher = fetch) {
+    this.config = config;
+    this.signer = signer;
+    this.fetcher = fetcher;
+  }
+  config;
+  signer;
+  fetcher;
+  async post(path, body, headers = {}) {
+    const u = new URL(path, this.config.origin);
+    if (u.origin !== this.config.origin) throw Error("Cross-origin payment request refused");
+    const r = await this.fetcher(u, { method: "POST", redirect: "error", headers: { "content-type": "application/json", ...headers }, body: JSON.stringify(body), signal: AbortSignal.timeout(3e4) });
+    const value = await r.json();
+    if (![200, 202, 402].includes(r.status)) throw Error(value?.error?.code ?? `HTTP ${r.status}`);
+    return { status: r.status, value, headers: r.headers };
+  }
+  async recover(p) {
+    const r = await this.fetcher(`${this.config.origin}/api/machine/quotes/${p.envelope.digest}/recovery`, { redirect: "error" });
+    if (!r.ok) throw Error("Purchase recovery unavailable");
+    const value = await r.json();
+    if (!value.encrypted) throw Error("Payment still pending; retry original payment");
+    const plain = await compactDecrypt(value.encrypted, await importJWK(p.privateKey, "ECDH-ES"));
+    const result = JSON.parse(Buffer.from(plain.plaintext).toString());
+    if (result.purchaseId !== p.envelope.digest) throw Error("Purchase mismatch");
+    return result;
+  }
+  async action(id, action) {
+    return withMachineState2(this.config.stateDirectory, async (state, save) => {
+      const p = state.purchases[id];
+      if (!p?.envelope) throw Error("Saved purchase is required for recovery");
+      if (p.binding !== machineQuoteDigest({ ...this.config, signer: this.signer.address })) throw Error("Wallet policy mismatch");
+      const current = p.result?.accessToken ? p.result : await this.recover(p);
+      const r = await this.post(`/api/machine/quotes/${p.envelope.digest}/actions/${action}`, {}, { authorization: `Bearer ${current.accessToken}` });
+      if (r.value.purchaseId !== p.envelope.digest) throw Error("Purchase mismatch");
+      p.result = r.value;
+      await save();
+      return r.value;
+    });
+  }
+  /** Account funding uses the same signer, policy and durable payment store as purchases. */
+  async fundTopup(topup, token, method = this.config.method) {
+    if (method !== this.config.method) throw new FundingError("WALLET_POLICY_MISMATCH", "Requested rail differs from configured wallet");
+    if (!/^[a-f0-9-]{36}$/i.test(topup.topUpId ?? "") || !Number.isSafeInteger(topup.amountMinor) || topup.amountMinor <= 0) throw new FundingError("INVALID_TOPUP", "Invalid account top-up");
+    return withMachineState2(this.config.stateDirectory, async (state, save) => {
+      const id = "topup:" + topup.topUpId, binding = machineQuoteDigest({ ...this.config, signer: this.signer.address });
+      let p = state.purchases[id];
+      if (p && (p.binding !== binding || p.amountMinor !== topup.amountMinor)) throw new FundingError("WALLET_POLICY_MISMATCH", "Saved top-up conflicts with wallet policy");
+      if (p?.pending || p?.complete) {
+        const result2 = await fundingRequest(this.config.origin, token, `/api/v1/billing/machine-topups/${topup.topUpId}`, {}, this.fetcher);
+        return { topup: result2, settlementPending: result2.status !== "SUCCEEDED", message: result2.status !== "SUCCEEDED" ? "Settlement pending; do not pay again." : void 0 };
+      }
+      if (!p) {
+        if (topup.amountMinor > this.config.perPaymentMinor || topup.amountMinor > this.config.totalMinor - state.reservedMinor) throw new FundingError("SPEND_CAP_EXCEEDED", "Top-up exceeds local wallet spending caps");
+        p = state.purchases[id] = { binding, amountMinor: topup.amountMinor };
+        state.reservedMinor += topup.amountMinor;
+        await save();
+      }
+      if (!p.payment) {
+        const q = await topupChallenge(this.config.origin, token, topup, method, this.fetcher);
+        if (!q.paymentUrl) {
+          p.pending = q.settlementPending;
+          p.complete = !q.settlementPending;
+          await save();
+          return q;
+        }
+        p.url = q.paymentUrl;
+        const required = method === "base" ? JSON.parse(Buffer.from(q.paymentRequired ?? "", "base64").toString()) : void 0;
+        const challenge = method === "base" ? void 0 : Challenge.fromResponse(new Response(null, { status: 402, headers: { "www-authenticate": q.wwwAuthenticate ?? "" } }));
+        const requirements = method === "base" ? required.accepts?.[0] : { ...challenge.request };
+        if (method === "base" && (required.resource?.url !== p.url || required.accepts?.length !== 1)) throw new FundingError("QUOTE_MISMATCH", "Unexpected funding resource");
+        if (challenge && (challenge.method !== method || challenge.intent !== "charge")) throw new FundingError("QUOTE_MISMATCH", "Unexpected funding challenge");
+        if (method !== "base") delete requirements.externalId;
+        const request = { method, maxPriceMinor: topup.amountMinor };
+        const quote = { origin: this.config.origin, request, amountMinor: topup.amountMinor, expiresAt: topup.expiresAt, requirements };
+        validateMachineQuote({ quote, digest: machineQuoteDigest(quote) }, request, { ...this.config, remainingMinor: topup.amountMinor });
+        if (method === "base") {
+          const client = registerExactEvmScheme(new x402Client().setSpendControls({ maxAmountPerPayment: `$${(this.config.perPaymentMinor / 100).toFixed(2)}` }), { signer: this.signer });
+          p.payment = await client.createPaymentPayload(required);
+        } else {
+          const methods = method === "solana" ? [solana.charge({ signer: this.signer, rpcUrl: this.config.network === "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1" ? "https://api.devnet.solana.com" : "https://api.mainnet-beta.solana.com" })] : [...tempo({ account: this.signer })];
+          const client = Mppx.create({ methods, polyfill: false, fetch: async (i, init) => {
+            const credential = new Request(i, init).headers.get("authorization");
+            if (credential) {
+              p.payment = credential;
+              return Response.json({ captured: true });
+            }
+            return new Response(null, { status: 402, headers: { "www-authenticate": Challenge.serialize(challenge) } });
+          } });
+          await client.fetch(p.url, { method: "POST" });
+          if (!p.payment) throw new FundingError("SIGNING_FAILED", "Payment signer returned no credential");
+        }
+        await save();
+      }
+      const headers = { "x-ukiyo-api-key": token, ...method === "base" ? { "payment-signature": Buffer.from(JSON.stringify(p.payment)).toString("base64") } : { authorization: p.payment } };
+      const response = await this.fetcher(p.url, { method: "POST", headers, redirect: "error", signal: AbortSignal.timeout(3e4) });
+      const body = await response.json().catch(() => null);
+      if (response.status === 202 || body?.settlementPending) {
+        p.pending = true;
+        await save();
+        return { topup: body?.data ?? topup, settlementPending: true, message: "Settlement pending; do not pay again." };
+      }
+      if (!response.ok) throw new FundingError(body?.error?.code ?? `HTTP_${response.status}`, body?.error?.message ?? "Funding unresolved; retry only this same top-up", response.status, body);
+      const result = await fundingRequest(this.config.origin, token, `/api/v1/billing/machine-topups/${topup.topUpId}`, {}, this.fetcher);
+      p.complete = result.status === "SUCCEEDED";
+      p.pending = !p.complete;
+      await save();
+      return { topup: result, settlementPending: p.pending, ...p.pending ? { message: "Settlement pending; do not pay again." } : {} };
+    });
+  }
+  async purchase(id, input, serviceCredit = false) {
+    if (!/^[a-zA-Z0-9_-]{1,128}$/.test(id)) throw Error("Supply a stable purchase id for retries");
+    return withMachineState2(this.config.stateDirectory, async (state, save) => {
+      const binding = machineQuoteDigest({ ...this.config, signer: this.signer.address });
+      let p = state.purchases[id];
+      if (p && (p.binding !== binding || p.serviceCredit !== serviceCredit || canonical(p.input) !== canonical(input))) throw Error("Purchase id conflicts with saved request or wallet policy");
+      if (!p) {
+        const R = await generateKeyPair("ECDH-ES", { extractable: true });
+        p = state.purchases[id] = { binding, input, serviceCredit, privateKey: await exportJWK(R.privateKey), publicKey: await exportJWK(R.publicKey) };
+        await save();
+      }
+      const request = { ...input, requestId: id, method: this.config.method, recoveryKey: p.publicKey };
+      if (!p.envelope) {
+        const q = await this.post(`/api/machine/${input.kind === "gpu-job" ? "gpu-jobs" : "gpu-blocks"}`, request);
+        if (q.status !== 402) throw Error("Expected immutable payment quote");
+        validateMachineQuote(q.value, request, { ...this.config, remainingMinor: this.config.totalMinor - state.reservedMinor });
+        p.envelope = q.value;
+        p.required = q.headers.get("payment-required");
+        state.reservedMinor += q.value.quote.amountMinor;
+        await save();
+      }
+      const e = p.envelope;
+      if (serviceCredit) {
+        const source = Object.values(state.purchases).find((v) => v !== p && v.binding === binding && v.result?.accessToken);
+        if (!source) throw Error("A saved source purchase token is required to reuse service credit");
+        const paid2 = await this.post(`/api/machine/quotes/${e.digest}/credits`, { sourcePurchaseId: source.result.purchaseId }, { authorization: `Bearer ${source.result.accessToken}` });
+        if (paid2.value.purchaseId !== e.digest) throw Error("Purchase mismatch");
+        p.result = paid2.value;
+        await save();
+        return { pending: paid2.status === 202, purchaseId: e.digest, result: p.result };
+      }
+      if (!p.payment) {
+        validateMachineQuote(e, request, { ...this.config, remainingMinor: e.quote.amountMinor });
+        if (this.config.method === "base") {
+          const client = registerExactEvmScheme(new x402Client().setSpendControls({ maxAmountPerPayment: `$${(this.config.perPaymentMinor / 100).toFixed(2)}` }), { signer: this.signer });
+          const required = JSON.parse(Buffer.from(p.required ?? "", "base64").toString());
+          if (required.resource?.url !== `${this.config.origin}/api/machine/${input.kind === "gpu-job" ? "gpu-jobs" : "gpu-blocks"}` || canonical(required.accepts) !== canonical([e.quote.requirements])) throw Error("x402 wire requirements mismatch");
+          p.payment = await client.createPaymentPayload(required);
+        } else {
+          const challenge = e.paymentChallenge, normalized = { ...challenge?.request };
+          delete normalized.externalId;
+          if (canonical(normalized) !== canonical(e.quote.requirements) || challenge.method !== this.config.method || this.config.method === "solana" && challenge.request.externalId !== e.digest) throw Error("MPP challenge does not match immutable quote");
+          const methods = this.config.method === "solana" ? [solana.charge({ signer: this.signer, rpcUrl: this.config.network === "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1" ? "https://api.devnet.solana.com" : "https://api.mainnet-beta.solana.com" })] : [...tempo({ account: this.signer })];
+          const client = Mppx.create({ methods, polyfill: false, fetch: async (i, init) => {
+            const r = new Request(i, init);
+            const credential = r.headers.get("authorization");
+            if (credential) {
+              p.payment = credential;
+              return Response.json({ captured: true });
+            }
+            return new Response(null, { status: 402, headers: { "www-authenticate": Challenge.serialize(challenge) } });
+          } });
+          await client.fetch(`${this.config.origin}/api/machine/${input.kind === "gpu-job" ? "gpu-jobs" : "gpu-blocks"}`, { method: "POST", body: JSON.stringify(request) });
+          if (!p.payment) throw Error("Payment signer returned no credential");
+        }
+        await save();
+      }
+      const headers = this.config.method === "base" ? { "payment-signature": Buffer.from(JSON.stringify(p.payment)).toString("base64") } : { authorization: p.payment };
+      const paid = await this.post(`/api/machine/${input.kind === "gpu-job" ? "gpu-jobs" : "gpu-blocks"}`, request, headers);
+      if (paid.value.purchaseId !== e.digest) throw Error("Purchase mismatch");
+      p.result = paid.value;
+      await save();
+      return { pending: paid.status === 202, purchaseId: e.digest, result: p.result };
+    });
+  }
+};
+
+// apps/cli/src/client.ts
+var ApiError = class extends Error {
+  constructor(status, code, message, body) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.body = body;
+    this.name = "ApiError";
+    this.requestId = body?.error?.requestId ?? body?.requestId ?? body?.meta?.requestId;
+  }
+  status;
+  code;
+  body;
+  context = {};
+  requestId;
+};
+var UkiyoClient = class {
+  baseUrl;
+  token;
+  fetcher;
+  constructor(options = {}) {
+    this.baseUrl = (options.baseUrl ?? "https://pay.u-kiyo.ai").replace(/\/+$/, "");
+    this.token = options.token;
+    this.fetcher = options.fetcher ?? fetch;
+  }
+  async request(path, init = {}) {
+    const { authenticated = true, headers, ...rest } = init;
+    if (authenticated && !this.token) {
+      throw new ApiError(0, "UNAUTHENTICATED", "No API token. New account: ukiyo signup --json. Existing human-owned account: ukiyo connect. Never give an agent an owner token.", null);
+    }
+    const signal = rest.signal ?? AbortSignal.timeout(15e3);
+    let response;
+    try {
+      response = await this.fetcher(`${this.baseUrl}/api/v1${path}`, {
+        ...rest,
+        signal,
+        redirect: "error",
+        headers: {
+          // Only declare a JSON body when there is one. A bodyless POST that
+          // still claims application/json is rejected before it reaches a route.
+          ...rest.body === void 0 ? {} : { "content-type": "application/json" },
+          ...authenticated && this.token ? { authorization: `Bearer ${this.token}` } : {},
+          ...headers
+        }
+      });
+    } catch {
+      throw new ApiError(0, "NETWORK_ERROR", "API request failed or timed out. For a write, retry only with the same Idempotency-Key and original parameters.", null);
+    }
+    const body = await response.json().catch(() => null);
+    if (signal.aborted) throw new ApiError(0, "NETWORK_ERROR", "API response timed out. Retry writes only with the same Idempotency-Key and original parameters.", null);
+    if (!response.ok) {
+      const code = body?.error?.code ?? body?.code ?? `HTTP_${response.status}`;
+      const message = body?.error?.message ?? body?.message ?? describe(response.status);
+      throw new ApiError(response.status, String(code), String(message), body);
+    }
+    if (body === null) throw new ApiError(response.status, "INVALID_RESPONSE", "API did not return a JSON response.", null);
+    return body?.data ?? body;
+  }
+  offers() {
+    return this.request("/offers", { authenticated: false });
+  }
+  me(signal) {
+    return this.request("/me", { signal: signal ?? null });
+  }
+  balance() {
+    return this.request("/billing/balance");
+  }
+  topup(amountMinor, idempotencyKey) {
+    return this.request("/billing/topups", { method: "POST", headers: { "idempotency-key": idempotencyKey }, body: JSON.stringify({ amountMinor }) });
+  }
+  async topupStatus(id) {
+    if (!this.token) throw new ApiError(401, "UNAUTHENTICATED", "An account token is required", null);
+    try {
+      return await fundingRequest(this.baseUrl, this.token, `/api/v1/billing/machine-topups/${encodeURIComponent(id)}`, {}, this.fetcher);
+    } catch (error) {
+      if (error instanceof FundingError) throw new ApiError(error.status, error.code, error.message, error.body);
+      throw error;
+    }
+  }
+  async topupRails(amountMinor, key, method, plain = false) {
+    if (!this.token) throw new ApiError(401, "UNAUTHENTICATED", "An account token is required", null);
+    if (!plain && !process.env.UKIYO_MACHINE_CONFIG) throw new ApiError(0, "WALLET_CONFIG_REQUIRED", "Set UKIYO_MACHINE_CONFIG or use --plain for an unpaid challenge", null);
+    try {
+      const wallet = plain ? void 0 : await loadMachineClient(process.env.UKIYO_MACHINE_CONFIG);
+      if (wallet && wallet.config.origin !== this.baseUrl) throw new ApiError(0, "INVALID_URL", "Wallet and API origins must match", null);
+      const topup = await createAccountTopup(this.baseUrl, this.token, amountMinor, key, this.fetcher);
+      const rail = method ?? wallet?.config.method ?? topup.paymentMethods?.[0]?.method;
+      if (!rail) throw new ApiError(0, "PAYMENT_METHOD_DISABLED", "No funding rails are enabled", null);
+      return plain ? topupChallenge(this.baseUrl, this.token, topup, rail, this.fetcher) : wallet.fundTopup(topup, this.token, rail);
+    } catch (error) {
+      if (error instanceof FundingError) throw new ApiError(error.status, error.code, error.message, error.body);
+      throw error;
+    }
+  }
+  rent(offerId, budgetMinor, idempotencyKey, signal) {
+    return this.request("/rentals", { signal: signal ?? null, method: "POST", headers: { "idempotency-key": idempotencyKey }, body: JSON.stringify({ offerId, ...budgetMinor === void 0 ? {} : { budgetMinor } }) });
+  }
+  rentGpu(input, idempotencyKey, signal) {
+    return this.request("/rentals", { signal: signal ?? null, method: "POST", headers: { "idempotency-key": idempotencyKey }, body: JSON.stringify(input) });
+  }
+  rental(id, signal) {
+    return this.request(`/rentals/${encodeURIComponent(id)}`, signal ? { signal } : {});
+  }
+  deployments() {
+    return this.request("/deployments");
+  }
+  deployment(id, signal) {
+    return this.request(`/deployments/${encodeURIComponent(id)}`, signal ? { signal } : {});
+  }
+  credentials(id) {
+    return this.request(`/deployments/${encodeURIComponent(id)}/credentials/reveal`, { method: "POST" });
+  }
+  terminate(id, signal) {
+    return this.request(`/deployments/${encodeURIComponent(id)}/terminate`, { signal: signal ?? null, method: "POST", body: JSON.stringify({ reason: "USER_REQUESTED" }) });
+  }
+  checkout(offerId, budgetMinor, idempotencyKey) {
+    return this.request("/orders/checkout", { method: "POST", headers: { "idempotency-key": idempotencyKey }, body: JSON.stringify({ offerId, budgetMinor }) });
+  }
+};
+function describe(status) {
+  if (status === 401) return "Invalid or expired API token. Check the saved credential and API origin. Existing-account agents can reconnect with owner approval; do not create a new account to recover a funded balance.";
+  if (status === 404) return "Not found.";
+  if (status === 429) return "Rate limited. Try again shortly.";
+  return `Request failed with status ${status}.`;
+}
+
+// apps/cli/src/credentials.ts
+import { constants as constants2, closeSync as closeSync2, fsyncSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { join as join3 } from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// apps/cli/src/storage.ts
+import { execFileSync } from "node:child_process";
+import { constants, closeSync, fstatSync, lstatSync, mkdirSync, openSync } from "node:fs";
+import { homedir } from "node:os";
+import { join as join2 } from "node:path";
+var isWindows = () => process.platform === "win32";
+var credentialDirectory = () => join2(homedir(), ".ukiyo");
+var WINDOWS_ACL = `
+$ErrorActionPreference = 'Stop'
+$env:PSModulePath = Join-Path $PSHOME 'Modules'
+$p = $env:UKIYO_STORAGE_PATH
+$item = Get-Item -LiteralPath $p -Force
+if (($item.Attributes -band [IO.FileAttributes]::ReparsePoint) -ne 0) { throw 'Reparse point' }
+$sid = [Security.Principal.WindowsIdentity]::GetCurrent().User
+$acl = Get-Acl -LiteralPath $p
+if ($env:UKIYO_STORAGE_ACTION -eq 'protect') {
+  if ($item.PSIsContainer) {
+    $acl = New-Object Security.AccessControl.DirectorySecurity
+    $inherit = [Security.AccessControl.InheritanceFlags]'ContainerInherit, ObjectInherit'
+  } else {
+    $acl = New-Object Security.AccessControl.FileSecurity
+    $inherit = [Security.AccessControl.InheritanceFlags]::None
+  }
+  $acl.SetOwner($sid)
+  $acl.SetAccessRuleProtection($true, $false)
+  $rule = New-Object Security.AccessControl.FileSystemAccessRule($sid, [Security.AccessControl.FileSystemRights]::FullControl, $inherit, [Security.AccessControl.PropagationFlags]::None, [Security.AccessControl.AccessControlType]::Allow)
+  $acl.AddAccessRule($rule)
+  Set-Acl -LiteralPath $p -AclObject $acl
+  $acl = Get-Acl -LiteralPath $p
+}
+if ($acl.GetOwner([Security.Principal.SecurityIdentifier]).Value -ne $sid.Value -or -not $acl.AreAccessRulesProtected) { throw 'Owner or inheritance' }
+$own = $false
+foreach ($r in $acl.GetAccessRules($true, $true, [Security.Principal.SecurityIdentifier])) {
+  if ($r.AccessControlType -eq [Security.AccessControl.AccessControlType]::Allow) {
+    if ($r.IdentityReference.Value -ne $sid.Value) { throw 'Other principal has access' }
+    if (($r.FileSystemRights -band [Security.AccessControl.FileSystemRights]::FullControl) -eq [Security.AccessControl.FileSystemRights]::FullControl) { $own = $true }
+  }
+}
+if (-not $own) { throw 'Missing owner access' }
+exit 0
+`;
+function windowsAcl(path, action) {
+  try {
+    const env = { UKIYO_STORAGE_PATH: path, UKIYO_STORAGE_ACTION: action };
+    for (const name of ["SystemRoot", "WINDIR", "USERPROFILE", "LOCALAPPDATA", "APPDATA", "PATH", "TEMP", "TMP", "PSModulePath", "PSModuleAnalysisCachePath", "ProgramFiles", "ProgramFiles(x86)", "ProgramW6432", "ProgramData", "ALLUSERSPROFILE", "USERDOMAIN", "USERNAME", "COMPUTERNAME", "ComSpec", "OS", "PROCESSOR_ARCHITECTURE", "PROCESSOR_IDENTIFIER", "NUMBER_OF_PROCESSORS"]) if (process.env[name]) env[name] = process.env[name];
+    env.PSModulePath = join2(process.env.SystemRoot || "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "Modules");
+    execFileSync(
+      join2(process.env.SystemRoot || "C:\\Windows", "System32", "WindowsPowerShell", "v1.0", "powershell.exe"),
+      ["-NoLogo", "-NoProfile", "-NonInteractive", "-EncodedCommand", Buffer.from(WINDOWS_ACL, "utf16le").toString("base64")],
+      { env, stdio: ["ignore", "pipe", "pipe"], timeout: 3e4, windowsHide: true }
+    );
+  } catch (error) {
+    throw new Error(`Ukiyo storage requires user-only Windows access controls (ACLs), an owned regular path, and Windows PowerShell (${error.code === "ETIMEDOUT" ? "access-control check timed out" : "access-control check failed"}). No credential was exposed.`);
+  }
+}
+function validateStorageStat(stat, dir) {
+  if ((dir ? !stat.isDirectory() : !stat.isFile()) || stat.isSymbolicLink()) throw new Error("Ukiyo credential storage must be a regular owned path, not a symlink.");
+  if (!isWindows() && ((stat.mode & 63) !== 0 || process.getuid && stat.uid !== process.getuid()))
+    throw new Error("Ukiyo credential storage must be owned by you, private (0700 directory / 0600 file), and not a symlink.");
+}
+function validateStoragePath(path, dir) {
+  validateStorageStat(lstatSync(path), dir);
+  if (isWindows()) windowsAcl(path, "validate");
+}
+function ensureCredentialDirectory() {
+  const path = credentialDirectory();
+  let created = false;
+  try {
+    mkdirSync(path, isWindows() ? {} : { mode: 448 });
+    created = true;
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+  }
+  validateStorageStat(lstatSync(path), true);
+  if (isWindows()) windowsAcl(path, created ? "protect" : "validate");
+  return path;
+}
+function openPrivateFile(path, flags, create = false) {
+  const noFollow = isWindows() ? 0 : constants.O_NOFOLLOW;
+  let fd;
+  if (create) fd = openSync(path, flags | constants.O_CREAT | constants.O_EXCL | noFollow, isWindows() ? void 0 : 384);
+  else {
+    validateStoragePath(path, false);
+    fd = openSync(path, flags | noFollow);
+  }
+  try {
+    validateStorageStat(fstatSync(fd), false);
+    if (isWindows()) windowsAcl(path, create ? "protect" : "validate");
+    return fd;
+  } catch (error) {
+    closeSync(fd);
+    throw error;
+  }
+}
+
+// apps/cli/src/credentials.ts
+var DEFAULT_API_URL = "https://pay.u-kiyo.ai";
+function apiOrigin(value = DEFAULT_API_URL) {
+  const url = new URL(value);
+  if (url.username || url.password || url.pathname !== "/" || url.search || url.hash || !(url.protocol === "https:" || url.protocol === "http:" && ["127.0.0.1", "localhost", "[::1]"].includes(url.hostname))) {
+    throw new Error("Use an HTTPS API origin (HTTP is allowed only on loopback for local testing).");
+  }
+  return url.origin;
+}
+var directory = credentialDirectory;
+var filename = () => join3(directory(), "credentials.json");
+function savedCredential(baseUrl) {
+  try {
+    validateStoragePath(directory(), true);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+  let fd;
+  try {
+    fd = openPrivateFile(filename(), constants2.O_RDONLY);
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+  try {
+    const data = JSON.parse(readFileSync(fd, "utf8"));
+    if (data.apiUrl !== apiOrigin(baseUrl)) throw new Error("Saved credential belongs to a different API origin.");
+    if (typeof data.token !== "string" || !/^uk_[a-f0-9]{12}\.[A-Za-z0-9_-]{32}$/.test(data.token)) throw new Error("Invalid saved Ukiyo credential.");
+    return data.token;
+  } finally {
+    closeSync2(fd);
+  }
+}
+async function signupAgent(limits, baseUrl = DEFAULT_API_URL, fetcher = fetch, acceptedTermsVersion) {
+  const apiUrl = apiOrigin(baseUrl);
+  if (process.env.UKIYO_API_TOKEN) throw new Error("Unset UKIYO_API_TOKEN before signup; signup creates a new account, never attaches to an existing one.");
+  ensureCredentialDirectory();
+  const fd = openPrivateFile(filename(), constants2.O_WRONLY, true);
+  let stored = false;
+  try {
+    let agreedTerms;
+    if (acceptedTermsVersion !== void 0) {
+      const response2 = await fetcher(`${apiUrl}/api/v1/terms`, { redirect: "error", signal: AbortSignal.timeout(15e3) });
+      const body2 = await response2.json();
+      if (!response2.ok) throw new ApiError(response2.status, body2?.error?.code ?? "TERMS_UNAVAILABLE", body2?.error?.message ?? "Approved Terms are unavailable.", body2);
+      const document = body2?.data;
+      if (!document || typeof document.version !== "string" || !/^https:\/\//.test(document.url ?? "") || !/^[a-f0-9]{64}$/.test(document.sha256 ?? "")) throw new ApiError(0, "TERMS_UNAVAILABLE", "Approved Terms are not configured. Signup was not attempted.", null);
+      if (document.version !== acceptedTermsVersion) throw new ApiError(0, "TERMS_VERSION_MISMATCH", "Review GET /api/v1/terms and explicitly supply its current version with --accept-terms. Signup was not attempted.", null);
+      agreedTerms = { version: document.version, sha256: document.sha256 };
+    }
+    const response = await fetcher(`${apiUrl}/api/v1/signup`, {
+      method: "POST",
+      redirect: "error",
+      signal: AbortSignal.timeout(15e3),
+      headers: { "content-type": "application/json", "idempotency-key": randomUUID2() },
+      body: JSON.stringify({ ...limits, ...agreedTerms ? { termsAcceptance: { ...agreedTerms, accepted: true } } : {} })
+    });
+    const body = await response.json();
+    if (!response.ok) throw new ApiError(response.status, body?.error?.code ?? "SIGNUP_FAILED", body?.error?.message ?? "Signup failed.", body);
+    const data = body.data;
+    if (data?.key?.kind !== "AGENT" || !/^uk_[a-f0-9]{12}\.[A-Za-z0-9_-]{32}$/.test(data?.token ?? "") || JSON.stringify([...data?.key?.scopes ?? []].sort()) !== JSON.stringify(["billing", "manage", "read", "rent"])) throw new Error("Unexpected signup credential.");
+    writeFileSync(fd, JSON.stringify({ apiUrl, token: data.token, keyId: data.key.id }) + "\n");
+    fsyncSync(fd);
+    stored = true;
+    const me = await fetcher(`${apiUrl}/api/v1/me`, { redirect: "error", signal: AbortSignal.timeout(15e3), headers: { authorization: `Bearer ${data.token}` } });
+    if (!me.ok) throw new Error("Credential saved, but verification failed. Retry ukiyo me --json; do not sign up again.");
+    const identity = (await me.json()).data;
+    if (identity?.user?.id !== data.account.id || identity?.key?.id !== data.key.id || identity?.key?.kind !== "AGENT") throw new Error("Saved credential identity did not match signup.");
+    return { account: data.account, key: data.key, credentialFile: filename(), ...agreedTerms ? { termsAcceptance: agreedTerms } : {} };
+  } finally {
+    closeSync2(fd);
+    if (!stored) unlinkSync(filename());
+  }
+}
+
+// apps/cli/src/output.ts
+function redact(text, secrets = []) {
+  let result = text;
+  for (const secret of secrets) if (secret) result = result.split(secret).join("[REDACTED]");
+  return result.replace(/-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?(?:-----END [^-]*PRIVATE KEY-----|$)/g, "[REDACTED PRIVATE KEY]").replace(/uk_[a-f0-9]{12}\.[A-Za-z0-9_-]{32,}/g, "[REDACTED TOKEN]");
+}
+function safeOutput(value) {
+  if (typeof value === "string") return redact(value, [process.env.UKIYO_API_TOKEN ?? ""]);
+  if (Array.isArray(value)) return value.map(safeOutput);
+  if (value && typeof value === "object") return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, /^(?:privateKey|private_key|token|secret|password|authorization)$/i.test(key) ? "[REDACTED]" : safeOutput(item)]));
+  return value;
+}
+
+// apps/mcp/src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+var DEFAULT_API_URL2 = "https://pay.u-kiyo.ai";
+var PUBLIC_PATHS = /* @__PURE__ */ new Set(["/offers"]);
+function createApiCall(env = process.env, fetcher = fetch) {
+  return async (path, init) => {
+    const url = env.UKIYO_API_URL ?? DEFAULT_API_URL2;
+    const token = env.UKIYO_API_TOKEN ?? (env === process.env ? savedCredential(apiOrigin(url)) : void 0);
+    if (!token && !PUBLIC_PATHS.has(path)) throw new Error("UKIYO_API_TOKEN is required: run signup_account or ukiyo signup for headless signup. Telegram is an optional existing-owner account route.");
+    const response = await fetcher(`${url.replace(/\/+$/, "")}/api/v1${path}`, {
+      ...init,
+      redirect: "error",
+      signal: AbortSignal.timeout(3e4),
+      headers: {
+        ...token ? { authorization: `Bearer ${token}` } : {},
+        // A bodyless POST must not claim application/json; the server rejects it.
+        ...init?.body === void 0 ? {} : { "content-type": "application/json" },
+        ...init?.headers
+      }
+    });
+    const text = await response.text();
+    if (!response.ok) {
+      let body;
+      try {
+        body = JSON.parse(text || "{}");
+      } catch {
+        throw new ApiError(response.status, "INVALID_RESPONSE", "API returned invalid JSON", null);
+      }
+      throw new ApiError(response.status, body?.error?.code ?? `HTTP_${response.status}`, body?.error?.message ?? text, body);
+    }
+    return text;
+  };
+}
+var deploymentId = z.string().uuid();
+function registerTools(server, call) {
+  const reply = async (path, init) => {
+    try {
+      const result = await call(path, init);
+      return { content: [{ type: "text", text: typeof result === "string" ? result : JSON.stringify(result) }] };
+    } catch (error) {
+      if (error instanceof ApiError) return { isError: true, content: [{ type: "text", text: JSON.stringify(safeOutput({ error: { code: error.code, status: error.status, message: error.message, requestId: error.requestId }, details: error.body })) }] };
+      throw error;
+    }
+  };
+  server.tool("list_compute_offers", "List currently available Ukiyo compute", {}, () => reply("/offers"));
+  server.tool("list_deployments", "List the authenticated user's deployments", {}, () => reply("/deployments"));
+  server.tool("get_deployment_status", "Get one deployment", { deploymentId }, ({ deploymentId: id }) => reply(`/deployments/${encodeURIComponent(id)}`));
+  server.tool(
+    "get_deployment_credentials",
+    "Reveal SSH access credentials for one active deployment. Returns a private key, so the result must be handled as a secret: never echo it into a shared transcript, log, or file the user has not asked for. Each call is audited.",
+    { deploymentId },
+    ({ deploymentId: id }) => reply(`/deployments/${encodeURIComponent(id)}/credentials/reveal`, { method: "POST" })
+  );
+  server.tool(
+    "terminate_deployment",
+    "Terminate a deployment. This is irreversible and destroys instance data. Confirm with the user before calling. Listed-runtime rentals return the final usage charge; legacy prepaid rentals forfeit remaining runtime.",
+    { deploymentId },
+    ({ deploymentId: id }) => reply(`/deployments/${encodeURIComponent(id)}/terminate`, { method: "POST", body: JSON.stringify({ reason: "USER_REQUESTED" }) })
+  );
+  const json = (value) => ({ content: [{ type: "text", text: JSON.stringify(safeOutput(value)) }] });
+  const action = async (fn) => {
+    try {
+      return json(await fn());
+    } catch (error) {
+      if (error instanceof ApiError) return { isError: true, ...json({ error: { code: error.code, status: error.status, message: error.message, requestId: error.requestId }, details: error.body }) };
+      throw error;
+    }
+  };
+  const accountClient = () => {
+    const baseUrl = apiOrigin(process.env.UKIYO_API_URL);
+    const token = process.env.UKIYO_API_TOKEN ?? savedCredential(baseUrl);
+    return new UkiyoClient({ baseUrl, ...token ? { token } : {} });
+  };
+  const key = z.string().min(1).max(128);
+  server.tool("signup_account", "Create a headless account after explicitly accepting the current Terms URL/version from GET /api/v1/terms. Stores a scoped credential securely locally; never returns the token. No browser or Telegram required.", {
+    maxPerRentalMinor: z.number().int().positive(),
+    budgetLimitMinor: z.number().int().positive(),
+    maxConcurrentDeployments: z.number().int().positive(),
+    acceptedTermsVersion: z.string().min(1),
+    acceptTerms: z.literal(true)
+  }, async ({ acceptedTermsVersion, acceptTerms, ...limits }) => action(() => signupAgent(limits, apiOrigin(process.env.UKIYO_API_URL), fetch, acceptedTermsVersion)));
+  server.tool("get_account_balance", "Read available account credit and key limits", {}, () => reply("/billing/balance"));
+  server.tool("rent_gpu", "Spends account credit to rent a GPU type; Ukiyo selects the machine. Supply a stable idempotencyKey and reuse it for retries. Retain rentalId/deploymentId; timeout never means create another rental.", {
+    gpuModel: z.string().min(1),
+    gpuCount: z.union([z.literal(1), z.literal(2), z.literal(4), z.literal(8)]).default(1),
+    maxHourlyPriceMinor: z.number().int().positive().optional(),
+    budgetMinor: z.number().int().positive().optional(),
+    idempotencyKey: key
+  }, ({ idempotencyKey, ...input }) => reply("/rentals", { method: "POST", headers: { "idempotency-key": idempotencyKey }, body: JSON.stringify(input) }));
+  server.tool("get_rental_status", "Read the existing rental and deployment IDs; wait for ACTIVE, never start a replacement on a timeout.", { rentalId: deploymentId }, ({ rentalId }) => reply(`/rentals/${encodeURIComponent(rentalId)}`));
+  server.tool("topup_account_with_card", "Create a hosted card funding link, not a rental. Reuse the caller-supplied idempotencyKey and amount on retries.", { amountMinor: z.number().int().positive(), idempotencyKey: key }, ({ amountMinor, idempotencyKey }) => reply("/billing/topups", { method: "POST", headers: { "idempotency-key": idempotencyKey }, body: JSON.stringify({ amountMinor }) }));
+  server.tool("topup_account_with_wallet", "Fund account credit using the configured wallet. Calling authorizes current API Terms consent and spending within local wallet caps. Reuse idempotencyKey and amount; pending means do not pay again.", { amountMinor: z.number().int().positive(), method: z.enum(["base", "solana", "tempo"]).optional(), idempotencyKey: key }, async ({ amountMinor, method, idempotencyKey }) => {
+    if (!process.env.UKIYO_MACHINE_CONFIG) throw new Error("Local machine wallet/cap configuration is not enabled");
+    return action(() => accountClient().topupRails(amountMinor, idempotencyKey, method));
+  });
+  server.tool("get_topup_status", "Poll existing funding; settlementPending means do not pay again.", { topupId: deploymentId }, ({ topupId }) => reply(`/billing/machine-topups/${encodeURIComponent(topupId)}`));
+  const machine = async () => {
+    if (!process.env.UKIYO_MACHINE_CONFIG) throw new Error("Local machine wallet/cap configuration is not enabled");
+    return loadMachineClient(process.env.UKIYO_MACHINE_CONFIG);
+  };
+  server.tool("purchase_compute_with_wallet", "Purchase a bounded GPU block or job without prior signup. Uses the locally configured wallet, immutable quote validation and persistent spend caps. Supply explicit current Terms and Privacy acceptance.", { purchaseId: z.string().regex(/^[a-zA-Z0-9_-]{1,128}$/), request: z.record(z.string(), z.unknown()), serviceCredit: z.boolean().default(false) }, async ({ purchaseId, request, serviceCredit }) => ({ content: [{ type: "text", text: JSON.stringify(await (await machine()).purchase(purchaseId, request, serviceCredit)) }] }));
+  for (const action2 of ["status", "terminate"]) server.tool(`machine_purchase_${action2}`, action2 === "status" ? "Recover the saved wallet purchase status and output. May return SSH access secrets; never echo secrets to shared transcripts or logs." : "Terminate the saved wallet purchase and trigger verified provider cleanup.", { purchaseId: z.string() }, async ({ purchaseId }) => ({ content: [{ type: "text", text: JSON.stringify(await (await machine()).action(purchaseId, action2)) }] }));
+  return server;
+}
+function buildServer(call) {
+  return registerTools(new McpServer({ name: "ukiyo", version: "0.2.1" }), call);
+}
+
+// apps/mcp/src/main.ts
+await buildServer(createApiCall()).connect(new StdioServerTransport());