@ukiyocompute/cli 0.0.0-stage → 0.3.1

package/dist/library.js

@@ -0,0 +1,1077 @@
+#!/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/cli/src/main.ts
+import { readFile as readFile3 } from "node:fs/promises";
+
+// 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/main.ts
+import { Command } from "commander";
+import { randomUUID as randomUUID3 } from "node:crypto";
+
+// 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}.`;
+}
+function dollarsToMinor(value) {
+  if (!/^\d+(\.\d{1,2})?$/.test(value.trim())) throw new ApiError(0, "INVALID_BUDGET", `Budget must be a dollar amount such as 20 or 19.99, received "${value}".`, null);
+  const [whole, fraction = ""] = value.trim().split(".");
+  const minor = Number(whole) * 100 + Number(fraction.padEnd(2, "0"));
+  if (!Number.isSafeInteger(minor)) throw new ApiError(0, "INVALID_BUDGET", "Amount exceeds safe integer precision.", null);
+  return minor;
+}
+
+// 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 connectAgent(setupCode, baseUrl = DEFAULT_API_URL, fetcher = fetch) {
+  const apiUrl = apiOrigin(baseUrl);
+  if (!/^uks_[A-Za-z0-9_-]{43}$/.test(setupCode)) throw new Error("Invalid setup code. Ask the owner for a fresh Connect an agent code.");
+  if (process.env.UKIYO_API_TOKEN) throw new Error("Unset UKIYO_API_TOKEN before connecting. Only the scoped agent credential should be used.");
+  ensureCredentialDirectory();
+  const fd = openPrivateFile(filename(), constants2.O_WRONLY, true);
+  let stored = false;
+  try {
+    const response = await fetcher(`${apiUrl}/api/v1/agent-setups/exchange`, {
+      method: "POST",
+      redirect: "error",
+      signal: AbortSignal.timeout(15e3),
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ setupCode })
+    });
+    const body = await response.json();
+    if (!response.ok) throw new ApiError(response.status, body?.error?.code ?? "CONNECT_FAILED", body?.error?.message ?? "Connection failed.", body);
+    if (body?.data?.key?.kind !== "AGENT" || !/^uk_[a-f0-9]{12}\.[A-Za-z0-9_-]{32}$/.test(body?.data?.token ?? "") || JSON.stringify([...body?.data?.key?.scopes ?? []].sort()) !== JSON.stringify(["manage", "read", "rent"])) throw new Error("Server did not return the expected scoped agent credential.");
+    writeFileSync(fd, JSON.stringify({ apiUrl, token: body.data.token, keyId: body.data.key.id }) + "\n", { flush: true });
+    fsyncSync(fd);
+    stored = true;
+    return { key: body.data.key, path: filename() };
+  } catch (error) {
+    if (error instanceof ApiError) throw error;
+    throw new Error(`${error instanceof Error ? error.message : "Connection failed."} If the code was consumed, ask the owner to revoke the agent token and create a new setup code.`);
+  } finally {
+    closeSync2(fd);
+    if (!stored) unlinkSync(filename());
+  }
+}
+async function connectExistingAccount(printUrl, baseUrl = DEFAULT_API_URL, fetcher = fetch) {
+  const apiUrl = apiOrigin(baseUrl);
+  if (process.env.UKIYO_API_TOKEN || savedCredential(apiUrl)) throw new Error("Already authenticated. Use a fresh HOME for an additional agent; do not replace an existing identity.");
+  const response = await fetcher(`${apiUrl}/api/v1/agent-authorizations`, { method: "POST", redirect: "error", signal: AbortSignal.timeout(15e3) });
+  const body = await response.json();
+  if (!response.ok) throw new ApiError(response.status, body?.error?.code ?? "CONNECT_FAILED", body?.error?.message ?? "Could not start authorization.", body);
+  const session = body.data;
+  const approval = new URL(session.approvalUrl);
+  if (approval.origin !== apiUrl || !/^\/connect\/[a-f0-9]{48}$/.test(approval.pathname)) throw new Error("Unexpected approval URL.");
+  printUrl(approval.href);
+  const deadline = Math.min(Date.now() + 6e5, Date.parse(session.expiresAt));
+  while (Date.now() < deadline) {
+    try {
+      const result = await connectAgent(session.setupCode, apiUrl, fetcher);
+      const token = savedCredential(apiUrl);
+      const me = await fetcher(`${apiUrl}/api/v1/me`, { headers: { authorization: `Bearer ${token}` }, redirect: "error", signal: AbortSignal.timeout(15e3) });
+      if (!me.ok || (await me.json())?.data?.key?.id !== result.key.id) throw new Error("Credential saved; verification failed. Retry ukiyo me.");
+      return result;
+    } catch (error) {
+      if (!(error instanceof Error) || !error.message.startsWith("Waiting for account-owner approval.")) throw error;
+      await new Promise((resolve3) => setTimeout(resolve3, 2e3));
+    }
+  }
+  throw new Error("Authorization expired. Run ukiyo connect again.");
+}
+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/ssh.ts
+import { execFile } from "node:child_process";
+import { constants as constants3, closeSync as closeSync3, mkdtempSync, unlinkSync as unlinkSync2, rmdirSync, writeFileSync as writeFileSync2 } from "node:fs";
+import { resolve as resolve2, join as join4 } from "node:path";
+
+// 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/cli/src/ssh.ts
+async function executeSsh(id, access, command, timeout = 60, runner = execFile) {
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9.:-]*$/.test(access.host) || !/^[a-zA-Z0-9_][a-zA-Z0-9_-]*$/.test(access.username) || !Number.isInteger(access.port) || access.port < 1 || access.port > 65535 || typeof access.privateKey !== "string" || !access.privateKey.includes("PRIVATE KEY") || !/^[a-zA-Z0-9-]+$/.test(id) || !command.length || command.some((arg) => arg.includes("\0")) || !Number.isSafeInteger(timeout) || timeout < 1 || timeout > 3600) throw new Error("Invalid SSH connection, command, or timeout.");
+  const directory2 = credentialDirectory();
+  validateStoragePath(directory2, true);
+  const knownHosts = join4(directory2, "known_hosts");
+  let fd;
+  try {
+    fd = openPrivateFile(knownHosts, constants3.O_RDWR, true);
+  } catch (error) {
+    if (error.code !== "EEXIST") throw error;
+    fd = openPrivateFile(knownHosts, constants3.O_RDWR);
+  }
+  closeSync3(fd);
+  const temp = mkdtempSync(join4(directory2, "ssh-"));
+  const keyFile = join4(temp, "identity");
+  try {
+    if (isWindows()) windowsAcl(temp, "protect");
+    validateStoragePath(temp, true);
+    const keyFd = openPrivateFile(keyFile, constants3.O_WRONLY, true);
+    try {
+      writeFileSync2(keyFd, access.privateKey);
+    } finally {
+      closeSync3(keyFd);
+    }
+    const remote = command.map((arg) => `'${arg.replaceAll("'", "'\\''")}'`).join(" ");
+    const args = [
+      "-F",
+      isWindows() ? "NUL" : "/dev/null",
+      "-T",
+      "-i",
+      keyFile,
+      "-p",
+      String(access.port),
+      "-o",
+      "BatchMode=yes",
+      "-o",
+      "IdentitiesOnly=yes",
+      "-o",
+      "ConnectTimeout=15",
+      "-o",
+      "StrictHostKeyChecking=accept-new",
+      "-o",
+      `HostKeyAlias=ukiyo-${id}`,
+      "-o",
+      `UserKnownHostsFile="${(isWindows() ? knownHosts.replaceAll("\\", "/") : knownHosts.replaceAll("\\", "\\\\")).replaceAll('"', '\\"')}"`,
+      `${access.username}@${access.host}`,
+      remote
+    ];
+    const env = { PATH: process.env.PATH };
+    if (isWindows()) {
+      for (const name of ["SystemRoot", "WINDIR", "USERPROFILE", "LOCALAPPDATA", "TEMP", "TMP"]) if (process.env[name]) env[name] = process.env[name];
+    }
+    return await new Promise((resolve3, reject) => runner("ssh", args, { timeout: timeout * 1e3, maxBuffer: 4 * 1024 * 1024, env, encoding: "utf8", windowsHide: true }, (error, stdout, stderr) => {
+      if (error && typeof error.code !== "number") {
+        reject(new Error(error.killed ? "SSH command timed out." : "SSH transport failed. Check SSH availability and the deployment state."));
+        return;
+      }
+      resolve3({ exitCode: error?.code ?? 0, stdout: redact(String(stdout), [access.privateKey, process.env.UKIYO_API_TOKEN ?? ""]), stderr: redact(String(stderr), [access.privateKey, process.env.UKIYO_API_TOKEN ?? ""]) });
+    }));
+  } finally {
+    try {
+      try {
+        unlinkSync2(keyFile);
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+    } finally {
+      rmdirSync(temp);
+    }
+  }
+}
+function saveSshKey(path, access) {
+  if (!/^[a-zA-Z0-9][a-zA-Z0-9.:-]*$/.test(access.host) || !/^[a-zA-Z0-9_][a-zA-Z0-9_-]*$/.test(access.username) || !Number.isInteger(access.port) || access.port < 1 || access.port > 65535 || !access.privateKey?.includes("PRIVATE KEY")) throw new Error("Invalid SSH connection.");
+  const keyPath = resolve2(path);
+  const fd = openPrivateFile(keyPath, constants3.O_WRONLY, true);
+  try {
+    writeFileSync2(fd, access.privateKey);
+  } catch (error) {
+    unlinkSync2(keyPath);
+    throw error;
+  } finally {
+    closeSync3(fd);
+  }
+  const quoted = isWindows() ? "'" + keyPath.replaceAll("'", "''") + "'" : "'" + keyPath.replaceAll("'", "'\\''") + "'";
+  return {
+    deploymentId: access.deploymentId,
+    rentalId: access.rentalId,
+    host: access.host,
+    port: access.port,
+    username: access.username,
+    keyPath,
+    sshCommand: `ssh -i ${quoted} -p ${access.port} -o IdentitiesOnly=yes ${access.username}@${access.host}`
+  };
+}
+
+// apps/cli/src/wait.ts
+function timeoutSeconds(value) {
+  const seconds = Number(value);
+  if (!Number.isSafeInteger(seconds) || seconds < 1 || seconds > 3600) throw new ApiError(0, "INVALID_USAGE", "Timeout must be 1\u20133600 seconds.", null);
+  return seconds;
+}
+async function beforeDeadline(read, deadline, context) {
+  const expired = () => {
+    const error = new ApiError(0, "WAIT_TIMEOUT", "Wait ended; inspect the known resource ID. For a write, retry only with the same Idempotency-Key and original parameters; never create a replacement rental.", null);
+    error.context = { ...context };
+    return error;
+  };
+  const remaining = deadline - Date.now();
+  if (remaining <= 0) throw expired();
+  const controller = new AbortController();
+  let timer;
+  try {
+    const value = await Promise.race([read(controller.signal), new Promise((_, reject) => {
+      timer = setTimeout(() => {
+        controller.abort();
+        reject(expired());
+      }, remaining);
+    })]);
+    if (Date.now() >= deadline) throw expired();
+    return value;
+  } catch (error) {
+    if (Date.now() >= deadline) throw expired();
+    throw error;
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+async function waitFor(read, done, seconds, context, deadline = Date.now() + seconds * 1e3) {
+  let latest;
+  for (; ; ) {
+    try {
+      latest = await beforeDeadline(read, deadline, { ...context, ...latest ? { resource: latest } : {} });
+    } catch (error) {
+      if (error instanceof ApiError) error.context = { ...context, ...error.context };
+      throw error;
+    }
+    if (latest?.rentalId) context.rentalId = latest.rentalId;
+    if (latest?.deploymentId) context.deploymentId = latest.deploymentId;
+    if (done(latest)) return latest;
+    await new Promise((resolve3) => setTimeout(resolve3, Math.max(0, Math.min(1e3, deadline - Date.now()))));
+  }
+}
+
+// apps/cli/src/main.ts
+function filteredOffers(value, gpu, count) {
+  const normalize = (name) => name.toUpperCase().replace(/NVIDIA|AMD/g, "").replace(/[^A-Z0-9]/g, "");
+  if (count !== void 0 && (!Number.isSafeInteger(Number(count)) || Number(count) < 1)) throw new ApiError(0, "INVALID_USAGE", "GPU count must be a positive integer.", null);
+  if (!Array.isArray(value)) throw new ApiError(0, "INVALID_RESPONSE", "Expected an offer list from the API.", null);
+  return value.filter((offer) => (!gpu || normalize(offer.name) === normalize(gpu)) && (count === void 0 || offer.gpuCount === Number(count)));
+}
+function contextError(error, context) {
+  const failure = error instanceof ApiError ? error : new ApiError(0, "CLI_ERROR", error.message, null);
+  failure.context = { ...context, ...failure.context };
+  throw failure;
+}
+function buildProgram(options = {}) {
+  const out = options.out ?? console.log;
+  const client = () => {
+    if (options.client) return options.client;
+    const baseUrl = apiOrigin(process.env.UKIYO_API_URL);
+    const token = process.env.UKIYO_API_TOKEN ?? savedCredential(baseUrl);
+    return new UkiyoClient({ baseUrl, ...token ? { token } : {} });
+  };
+  const print = (value) => out(JSON.stringify(safeOutput(value), null, 2));
+  const program = new Command().name("ukiyo").description("Manage Ukiyo compute through the public API").version("0.3.1").configureOutput({ writeErr: () => {
+  } }).exitOverride();
+  const machine = program.command("machine").description("Wallet-paid compute with no prior Ukiyo account; requires local signer config and explicit spend caps");
+  const machineClient = () => {
+    if (!process.env.UKIYO_MACHINE_CONFIG) throw new Error("Set UKIYO_MACHINE_CONFIG to a private local wallet/cap configuration file");
+    return loadMachineClient(process.env.UKIYO_MACHINE_CONFIG);
+  };
+  machine.command("buy").requiredOption("--request <path>", "JSON compute request including current Terms and Privacy acceptance").requiredOption("--purchase-id <id>", "stable local id; reuse for retries").option("--service-credit", "spend this chain-qualified wallet\u2019s existing service credit").action(async (opts) => print(await (await machineClient()).purchase(opts.purchaseId, JSON.parse(await readFile3(opts.request, "utf8")), !!opts.serviceCredit)));
+  for (const action of ["status", "terminate"]) machine.command(action).requiredOption("--purchase-id <id>").action(async (opts) => print(await (await machineClient()).action(opts.purchaseId, action)));
+  program.command("auth").description("Explain API token authentication").action(() => out([
+    "New agent: ukiyo signup --json (no account, email, browser or Telegram required).",
+    "Existing human-owned account: ukiyo connect, then ask its owner to approve the displayed URL.",
+    "Fund once: ukiyo balance --json; ukiyo topup link --amount 5 --json.",
+    "Ukiyo authenticates with a scoped API token.",
+    "",
+    "No owner credential is needed by the CLI/agent. Do not copy an owner token into its environment.",
+    "",
+    "Optional: export UKIYO_API_URL to target a different environment.",
+    "signup/connect store only the scoped agent token in ~/.ukiyo/credentials.json (0600). Never give an agent an owner token."
+  ].join("\n")));
+  program.command("connect [setup-code]").option("--json").description("Attach to an existing owner account using a short-lived approval session").action(async (setupCode) => {
+    const result = setupCode ? await connectAgent(setupCode, process.env.UKIYO_API_URL) : await connectExistingAccount(console.error, process.env.UKIYO_API_URL);
+    print({ connected: true, key: result.key, credentialFile: result.path });
+  });
+  program.command("signup").description("Create a new headless account and scoped agent credential; no free credits").option("--json").option("--max-per-rental <usd>", "per-rental spending cap", "5").option("--budget <usd>", "total net spending cap", "500").option("--max-concurrent <count>", "concurrent rental cap", "1").option("--accept-terms <version>", "explicitly agree to the reviewed current version from GET /api/v1/terms; never inferred").addHelpText("after", "\nReview https://u-kiyo.ai/terms/ and https://u-kiyo.ai/privacy/. An authorized agent may agree once at signup; no per-rental approval is required.").action(async (opts) => print(await signupAgent({ maxPerRentalMinor: dollarsToMinor(opts.maxPerRental), budgetLimitMinor: dollarsToMinor(opts.budget), maxConcurrentDeployments: Number(opts.maxConcurrent) }, process.env.UKIYO_API_URL, void 0, opts.acceptTerms)));
+  program.command("me").option("--json").action(async () => print(await client().me()));
+  program.command("balance").option("--json").action(async () => {
+    const account = await client().me();
+    print({ ...account.balance, key: account.key });
+  });
+  const topup = program.command("topup").description("Fund your own compute-credit balance");
+  topup.command("link").requiredOption("--amount <usd>").option("--json").option("--idempotency-key <key>", "reuse this key after a timeout").action(async (opts) => {
+    const key = opts.idempotencyKey ?? randomUUID3();
+    try {
+      print({ ...await client().topup(dollarsToMinor(opts.amount), key), idempotencyKey: key });
+    } catch (error) {
+      contextError(error, { idempotencyKey: key });
+    }
+  });
+  topup.command("rails").requiredOption("--amount <usd>").option("--method <rail>", "base, solana or tempo").option("--idempotency-key <key>", "stable top-up intent; reuse the returned key and amount on every retry").option("--plain", "print the unpaid payment challenge and stop; do not sign").option("--json").description("Authorize current Terms and fund with configured wallet; read https://u-kiyo.ai/terms/ first").action(async (opts) => {
+    if (opts.method && !["base", "solana", "tempo"].includes(opts.method)) throw new ApiError(0, "INVALID_USAGE", "Choose base, solana or tempo", null);
+    const key = opts.idempotencyKey ?? randomUUID3();
+    try {
+      print({ ...await client().topupRails(dollarsToMinor(opts.amount), key, opts.method, !!opts.plain), idempotencyKey: key });
+    } catch (error) {
+      contextError(error, { idempotencyKey: key });
+    }
+  });
+  topup.command("status").requiredOption("--topup-id <id>").option("--json").description("Inspect funding; pending means do not pay again").action(async (opts) => print(await client().topupStatus(opts.topupId)));
+  program.command("rent").option("--offer <id>").option("--gpu <name>").option("--count <count>").option("--budget <usd>", "required for fixed-prepaid accounts; optional for account-balance billing").option("--max-hourly-price <usd>", "GPU/count accepted hourly ceiling; reuse the same ceiling on retries").option("--idempotency-key <key>", "unique per intended rental; reuse with original parameters on retries").option("--json").option("--wait").option("--timeout <seconds>", "maximum status wait", "600").action(async (opts) => {
+    const seconds = timeoutSeconds(opts.timeout);
+    const deadline = Date.now() + seconds * 1e3;
+    const budget = opts.budget === void 0 ? void 0 : dollarsToMinor(opts.budget);
+    if (Boolean(opts.offer) === Boolean(opts.gpu) || opts.offer && (opts.count || opts.maxHourlyPrice)) throw new ApiError(0, "INVALID_USAGE", "Choose --offer OR --gpu with optional --count and hourly ceiling.", null);
+    const api = client();
+    if (budget === void 0) {
+      const account = await (opts.wait ? beforeDeadline((signal) => api.me(signal), deadline, {}) : api.me());
+      if (account.billing?.model !== "ACCOUNT_BALANCE" || account.billing.budgetRequired !== false) {
+        throw new ApiError(0, "INVALID_USAGE", "--budget is required for this account. Budget-free rentals require account-balance billing.", null);
+      }
+    }
+    const budgetFields = budget === void 0 ? {} : { budgetMinor: budget };
+    let intent;
+    if (opts.gpu) {
+      const count = opts.count ?? "1";
+      if (![1, 2, 4, 8].includes(Number(count))) throw new ApiError(0, "INVALID_USAGE", "Supported GPU counts are 1, 2, 4 or 8.", null);
+      intent = {
+        gpuModel: opts.gpu,
+        gpuCount: Number(count),
+        ...budgetFields,
+        ...opts.maxHourlyPrice === void 0 ? {} : { maxHourlyPriceMinor: dollarsToMinor(opts.maxHourlyPrice) }
+      };
+    }
+    const idempotencyKey = opts.idempotencyKey ?? randomUUID3();
+    const context = { ...intent ?? { offerId: opts.offer, ...budgetFields }, idempotencyKey };
+    try {
+      const create = (signal) => intent ? api.rentGpu(intent, idempotencyKey, signal) : api.rent(opts.offer, budget, idempotencyKey, signal);
+      const rental = await (opts.wait ? beforeDeadline(create, deadline, context) : create());
+      Object.assign(context, { rentalId: rental.rentalId, deploymentId: rental.deploymentId });
+      const result = opts.wait && !["ACTIVE", "FAILED", "TERMINATED"].includes(rental.status) ? await waitFor((signal) => api.rental(rental.rentalId, signal), (value) => ["ACTIVE", "FAILED", "TERMINATED"].includes(value.status), seconds, context, deadline) : rental;
+      print({ ...result, ...context });
+      if (opts.wait && result.status !== "ACTIVE") process.exitCode = 1;
+    } catch (error) {
+      contextError(error, context);
+    }
+  });
+  program.command("rental <id>").option("--json").option("--wait", "wait for ACTIVE or a final failure").option("--timeout <seconds>", "maximum wait", "600").action(async (id, opts) => {
+    const seconds = timeoutSeconds(opts.timeout);
+    const api = client();
+    const value = opts.wait ? await waitFor((signal) => api.rental(id, signal), (value2) => ["ACTIVE", "FAILED", "TERMINATED"].includes(value2.status), seconds, { rentalId: id }) : await api.rental(id);
+    print(value);
+    if (opts.wait && value.status !== "ACTIVE") process.exitCode = 1;
+  });
+  program.command("exec <id> <command...>").option("--json").option("--timeout <seconds>", "command timeout", "60").description("Execute a command over authenticated SSH (first host key is pinned locally)").action(async (id, command, opts) => {
+    const seconds = timeoutSeconds(opts.timeout);
+    const access = await client().credentials(id);
+    const result = await executeSsh(access.deploymentId ?? id, access, command, seconds);
+    print({ deploymentId: access.deploymentId ?? id, rentalId: access.rentalId, ...result });
+    if (result.exitCode) process.exitCode = 1;
+  });
+  program.command("offers").option("--json").option("--gpu <name>").option("--count <count>").description("List available compute").action(async (opts) => print(filteredOffers(await client().offers(), opts.gpu, opts.count)));
+  program.command("list").option("--json").description("List your deployments").action(async () => print(await client().deployments()));
+  program.command("status <id>").option("--json").description("Show one deployment").action(async (id) => print(await client().deployment(id)));
+  program.command("credentials <id>").option("--json").option("--save-key <path>", "save a private SSH key securely without printing it").option("--reveal", "explicitly print the private key; audited and unsafe for shared transcripts").description("Audited SSH connection metadata; private keys are redacted by default. Prefer exec or --save-key.").action(async (id, opts) => {
+    if (opts.saveKey && opts.reveal) throw new ApiError(0, "INVALID_USAGE", "Choose --save-key or --reveal, not both.", null);
+    const access = await client().credentials(id);
+    if (opts.saveKey) print(saveSshKey(opts.saveKey, access));
+    else if (opts.reveal) {
+      console.error("WARNING: credential reveal is audited. This output contains a private key; do not share or log it.");
+      out(JSON.stringify(access, null, 2));
+    } else print(access);
+  });
+  program.command("deploy").description("Rent an offer").requiredOption("--offer <id>").requiredOption("--budget <usd>", "budget in dollars, e.g. 20 or 19.99").action(async (opts) => print(await client().checkout(opts.offer, dollarsToMinor(opts.budget), randomUUID3())));
+  program.command("terminate <id>").option("--json").option("--wait").option("--timeout <seconds>", "maximum termination wait", "600").description("Terminate a deployment. This is irreversible.").option("--yes", "skip the confirmation prompt").action(async (id, opts) => {
+    const seconds = timeoutSeconds(opts.timeout);
+    if (!opts.yes) throw new ApiError(0, "CONFIRMATION_REQUIRED", `Terminating ${id} is irreversible and destroys anything on the instance. Re-run with --yes to confirm.`, null);
+    const api = client();
+    try {
+      const deadline = Date.now() + seconds * 1e3;
+      const accepted = await (opts.wait ? beforeDeadline((signal) => api.terminate(id, signal), deadline, { deploymentId: id }) : api.terminate(id));
+      const value = opts.wait ? await waitFor((signal) => api.deployment(id, signal), (value2) => value2.status === "TERMINATED", seconds, { deploymentId: id, ...accepted }, deadline) : accepted;
+      print({ deploymentId: id, ...value });
+    } catch (error) {
+      contextError(error, { deploymentId: id });
+    }
+  });
+  return program;
+}
+async function run(argv = process.argv) {
+  try {
+    await buildProgram().parseAsync(argv);
+  } catch (error) {
+    const commander = error?.code?.startsWith?.("commander.");
+    if (commander && error.exitCode === 0) return;
+    const api = error instanceof ApiError ? error : void 0;
+    process.exitCode = api?.code === "WAIT_TIMEOUT" ? 3 : commander || ["INVALID_USAGE", "INVALID_BUDGET", "CONFIRMATION_REQUIRED"].includes(api?.code ?? "") ? 2 : 1;
+    const result = safeOutput({ error: { code: api?.code ?? (commander ? "INVALID_USAGE" : "CLI_ERROR"), status: api?.status ?? 0, message: error.message, requestId: api?.requestId ?? null }, ...api?.context });
+    if (argv.slice(0, argv.indexOf("--") < 0 ? void 0 : argv.indexOf("--")).includes("--json")) console.log(JSON.stringify(result));
+    else console.error(JSON.stringify(result));
+  }
+}
+export {
+  buildProgram,
+  run
+};