run402 4.93.2 → 4.95.0

package/lib/allowance.mjs

@@ -1,355 +0,0 @@
-import { readAllowance, saveAllowance, allowanceFile } from "./config.mjs";
-import { getSdk } from "./sdk.mjs";
-import { reportSdkError, fail } from "./sdk-errors.mjs";
-import { assertKnownFlags, flagValue, normalizeArgv, parseIntegerFlag, positionalArgs, failUnknownSubcommand } from "./argparse.mjs";
-
-const HELP = `run402 allowance — Manage your agent allowance
-
-Usage:
-  run402 allowance <subcommand>
-
-Subcommands:
-  status    Show allowance address, network, rail, and funding status
-  create    Generate a new allowance and save it locally
-  fund      Request test funds from the faucet (Base Sepolia or Tempo)
-  balance   Show on-chain balances and Run402 billing balance
-  export    Print the allowance address as JSON (useful for scripting)
-  checkout  Create an org balance checkout session (--amount <usd_micros>)
-  history   View billing transaction history (--limit <n>)
-
-Notes:
-  - Agent allowance is stored locally at ~/.config/run402/allowance.json
-  - The allowance works on any EVM chain (Base for x402, Tempo for MPP)
-  - Use 'run402 init' for x402 or 'run402 init mpp' for MPP rail
-
-Examples:
-  run402 allowance create
-  run402 allowance status
-  run402 allowance fund
-  run402 allowance export
-  run402 allowance balance
-  run402 allowance checkout --amount 5000000
-  run402 allowance history --limit 10
-`;
-
-const SUB_HELP = {
-  checkout: `run402 allowance checkout — Create an org balance checkout session
-
-Usage:
-  run402 allowance checkout --amount <usd_micros>
-
-Options:
-  --amount <n>        Amount in USD micros (required; e.g. 5000000 for $5)
-
-Examples:
-  run402 allowance checkout --amount 5000000
-  run402 allowance checkout --amount 10000000
-`,
-  history: `run402 allowance history — View billing transaction history
-
-Usage:
-  run402 allowance history [--limit <n>]
-
-Options:
-  --limit <n>         Max entries to return (default: 20)
-
-Examples:
-  run402 allowance history
-  run402 allowance history --limit 10
-`,
-};
-
-const USDC_ABI = [{ name: "balanceOf", type: "function", stateMutability: "view", inputs: [{ name: "account", type: "address" }], outputs: [{ name: "", type: "uint256" }] }];
-const USDC_MAINNET = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-const USDC_SEPOLIA = "0x036CbD53842c5426634e7929541eC2318f3dCF7e";
-const PATH_USD = "0x20c0000000000000000000000000000000000000";
-const TEMPO_RPC = "https://rpc.moderato.tempo.xyz/";
-
-async function loadDeps() {
-  const { generatePrivateKey, privateKeyToAccount } = await import("viem/accounts");
-  const { createPublicClient, http, defineChain } = await import("viem");
-  const { base, baseSepolia } = await import("viem/chains");
-  const tempoModerato = defineChain({
-    id: 42431,
-    name: "Tempo Moderato",
-    nativeCurrency: { name: "pathUSD", symbol: "pathUSD", decimals: 6 },
-    rpcUrls: { default: { http: [TEMPO_RPC] } },
-  });
-  return { generatePrivateKey, privateKeyToAccount, createPublicClient, http, base, baseSepolia, tempoModerato };
-}
-
-async function status() {
-  try {
-    const data = await getSdk().allowance.status();
-    if (!data.configured) {
-      console.log(JSON.stringify({ wallet: null, hint: "Run: run402 allowance create" }));
-      return;
-    }
-    const w = readAllowance();
-    // The Lightning allowance (mpp-lightning-over-nwc): public facts plus a
-    // best-effort balance read over NWC; the pairing secret never prints.
-    const { describeLightning, readLightningBalance } = await import("./lightning-wallet.mjs");
-    const lightning = w?.lightning ? describeLightning(w, null, await readLightningBalance(w)) : null;
-    console.log(JSON.stringify({
-      wallet: {
-        address: data.address,
-        created: data.created,
-        configured: data.configured,
-        // `faucet_used` is named for what it is: an on-disk marker that
-        // tracks faucet invocation, not pay-readiness. For a true "can this
-        // account pay right now" check, use `run402 allowance balance`.
-        faucet_used: !!data.faucet_used,
-        rail: data.rail ?? w?.rail ?? "x402",
-        path: data.path ?? allowanceFile(),
-      },
-      ...(lightning ? { lightning } : {}),
-    }));
-  } catch (err) {
-    reportSdkError(err);
-  }
-}
-
-async function create() {
-  try {
-    const result = await getSdk().allowance.create();
-    console.log(JSON.stringify({
-      address: result.address,
-      path: result.path ?? allowanceFile(),
-      created: true,
-    }));
-  } catch (err) {
-    const msg = (err instanceof Error) ? err.message : String(err);
-    if (/already exists/i.test(msg)) {
-      fail({
-        code: "ALLOWANCE_EXISTS",
-        message: "Agent allowance already exists.",
-        hint: "Use 'status' to check it.",
-      });
-    }
-    reportSdkError(err);
-  }
-}
-
-async function fund() {
-  const w = readAllowance();
-  if (!w) {
-    fail({
-      code: "NO_ALLOWANCE",
-      message: "No agent allowance.",
-      hint: "Run: run402 allowance create",
-    });
-  }
-
-  if (w.rail === "mpp") {
-    // Tempo Moderato faucet — instant, no polling needed
-    const { createPublicClient, http, tempoModerato } = await loadDeps();
-    const client = createPublicClient({ chain: tempoModerato, transport: http() });
-    const before = await readUsdcBalance(client, PATH_USD, w.address).catch(() => 0);
-
-    const res = await fetch(TEMPO_RPC, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ jsonrpc: "2.0", method: "tempo_fundAddress", params: [w.address], id: 1 }),
-    });
-    const data = await res.json();
-    if (data.error) {
-      fail({
-        code: "FAUCET_FAILED",
-        message: data.error.message || "Tempo faucet failed",
-        details: { rail: "mpp" },
-      });
-    }
-
-    // Re-read balance once (instant confirmation)
-    const now = await readUsdcBalance(client, PATH_USD, w.address).catch(() => before);
-    saveAllowance({ ...w, funded: true, lastFaucet: new Date().toISOString() });
-    console.log(JSON.stringify({
-      address: w.address,
-      rail: "mpp",
-      onchain: {
-        "tempo-moderato_pathusd_micros": now,
-      },
-    }, null, 2));
-    return;
-  }
-
-  // Default: Base Sepolia faucet (existing behavior)
-  const { createPublicClient, http, baseSepolia } = await loadDeps();
-  const client = createPublicClient({ chain: baseSepolia, transport: http() });
-  const before = await readUsdcBalance(client, USDC_SEPOLIA, w.address).catch(() => 0);
-
-  let data;
-  try {
-    data = await getSdk().allowance.faucet(w.address);
-  } catch (err) {
-    reportSdkError(err);
-  }
-
-  const MAX_WAIT = 30;
-  for (let i = 0; i < MAX_WAIT; i++) {
-    await new Promise(r => setTimeout(r, 1000));
-    const now = await readUsdcBalance(client, USDC_SEPOLIA, w.address).catch(() => before);
-    if (now > before) {
-      saveAllowance({ ...w, funded: true, lastFaucet: new Date().toISOString() });
-      console.log(JSON.stringify({
-        address: w.address,
-        rail: w.rail || "x402",
-        onchain: {
-          "base-sepolia_usd_micros": now,
-        },
-      }, null, 2));
-      return;
-    }
-  }
-
-  saveAllowance({ ...w, funded: true, lastFaucet: new Date().toISOString() });
-  console.log(JSON.stringify({ ...data, balance_confirmed: false, hint: "Faucet request sent but on-chain balance not yet confirmed" }));
-}
-
-async function readUsdcBalance(client, usdc, address) {
-  const raw = await client.readContract({ address: usdc, abi: USDC_ABI, functionName: "balanceOf", args: [address] });
-  return Number(raw);
-}
-
-async function balance() {
-  const w = readAllowance();
-  if (!w) {
-    fail({
-      code: "NO_ALLOWANCE",
-      message: "No agent allowance.",
-      hint: "Run: run402 allowance create",
-    });
-  }
-
-  const { createPublicClient, http, base, baseSepolia, tempoModerato } = await loadDeps();
-  const mainnetClient = createPublicClient({ chain: base, transport: http() });
-  const sepoliaClient = createPublicClient({ chain: baseSepolia, transport: http() });
-  const tempoClient = createPublicClient({ chain: tempoModerato, transport: http() });
-
-  const [mainnetUsdc, sepoliaUsdc, tempoPathUsd, billingRes] = await Promise.all([
-    readUsdcBalance(mainnetClient, USDC_MAINNET, w.address).catch(() => null),
-    readUsdcBalance(sepoliaClient, USDC_SEPOLIA, w.address).catch(() => null),
-    readUsdcBalance(tempoClient, PATH_USD, w.address).catch(() => null),
-    getSdk().billing.checkBalance(w.address).catch(() => null),
-  ]);
-
-  console.log(JSON.stringify({
-    address: w.address,
-    rail: w.rail || "x402",
-    onchain: {
-      "base-mainnet_usd_micros": mainnetUsdc,
-      "base-sepolia_usd_micros": sepoliaUsdc,
-      "tempo-moderato_pathusd_micros": tempoPathUsd,
-    },
-    run402: billingRes ? { balance_usd_micros: billingRes.available_usd_micros } : "no organization",
-  }, null, 2));
-}
-
-async function exportAddr(args = []) {
-  const parsedArgs = normalizeArgv(args);
-  assertKnownFlags(parsedArgs, [], []);
-  const bare = positionalArgs(parsedArgs, []);
-  if (bare.length > 0) {
-    fail({
-      code: "BAD_USAGE",
-      message: `Unexpected argument for allowance export: ${bare[0]}`,
-      details: { argument: bare[0] },
-    });
-  }
-  try {
-    const address = await getSdk().allowance.export();
-    console.log(JSON.stringify({ address }));
-  } catch {
-    fail({ code: "NO_ALLOWANCE", message: "No agent allowance." });
-  }
-}
-
-async function checkout(args) {
-  const w = readAllowance();
-  if (!w) {
-    fail({
-      code: "NO_ALLOWANCE",
-      message: "No agent allowance.",
-      hint: "Run: run402 allowance create",
-    });
-  }
-  const parsedArgs = normalizeArgv(args);
-  assertKnownFlags(parsedArgs, ["--amount", "--help", "-h"], ["--amount"]);
-  const bare = positionalArgs(parsedArgs, ["--amount"]);
-  if (bare.length > 0) {
-    fail({
-      code: "BAD_USAGE",
-      message: `Unexpected argument for allowance checkout: ${bare[0]}`,
-      details: { argument: bare[0] },
-    });
-  }
-  const amountRaw = flagValue(parsedArgs, "--amount");
-  if (amountRaw === null) {
-    fail({
-      code: "BAD_USAGE",
-      message: "Missing --amount <usd_micros>",
-      hint: "e.g. --amount 5000000 for $5",
-    });
-  }
-  const amount = parseIntegerFlag("--amount", amountRaw, { min: 1 });
-  try {
-    const org = await getSdk().billing.lookupOrganization(w.address);
-    const data = await getSdk().billing.createCheckout(org.org_id, {
-      product: "balance_topup",
-      amountUsdMicros: amount,
-    });
-    console.log(JSON.stringify(data, null, 2));
-  } catch (err) {
-    reportSdkError(err);
-  }
-}
-
-async function history(args) {
-  const w = readAllowance();
-  if (!w) {
-    fail({
-      code: "NO_ALLOWANCE",
-      message: "No agent allowance.",
-      hint: "Run: run402 allowance create",
-    });
-  }
-  const parsedArgs = normalizeArgv(args);
-  assertKnownFlags(parsedArgs, ["--limit", "--help", "-h"], ["--limit"]);
-  const bare = positionalArgs(parsedArgs, ["--limit"]);
-  if (bare.length > 0) {
-    fail({
-      code: "BAD_USAGE",
-      message: `Unexpected argument for allowance history: ${bare[0]}`,
-      details: { argument: bare[0] },
-    });
-  }
-  const limit = parseIntegerFlag("--limit", flagValue(parsedArgs, "--limit"), { min: 1, def: 20 });
-  try {
-    const data = await getSdk().billing.history(w.address, limit);
-    console.log(JSON.stringify(data, null, 2));
-  } catch (err) {
-    reportSdkError(err);
-  }
-}
-
-export async function run(sub, args) {
-  if (!sub || sub === '--help' || sub === '-h') {
-    console.log(HELP);
-    process.exit(0);
-  }
-  if (Array.isArray(args) && (args.includes("--help") || args.includes("-h"))) {
-    console.log(SUB_HELP[sub] || HELP);
-    process.exit(0);
-  }
-  switch (sub) {
-    case "status":  await status(); break;
-    case "create":  await create(); break;
-    case "fund":    await fund(); break;
-    case "balance": await balance(); break;
-    case "export":   await exportAddr(args); break;
-    case "checkout": await checkout(args); break;
-    case "history":  await history(args); break;
-    default:
-      failUnknownSubcommand("allowance", sub);
-  }
-}

package/lib/cloud.mjs

@@ -1,256 +0,0 @@
-import { mkdirSync, writeFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-
-import { getSdk } from "./sdk.mjs";
-import { fail, reportSdkError } from "./sdk-errors.mjs";
-import { assertAllowedValue, assertKnownFlags, flagValue, hasHelp, normalizeArgv, parseIntegerFlag, positionalArgs, resolveProjectSelector, failUnknownSubcommand } from "./argparse.mjs";
-
-const HELP = `run402 cloud — Run402 Cloud portability commands
-
-Usage:
-  run402 cloud archives create [--project <id>] [options]
-  run402 cloud archives download <archive-id> --output <file> [--project <id>] [--json]
-  run402 cloud archives status <archive-id> [--project <id>] [--json]
-
-Legacy (still supported): a leading prj_... positional selects the project,
-e.g. run402 cloud archives download <project-id> <archive-id> --output <file>.
---project defaults to the active project.
-
-Canonical agent path:
-  run402 cloud archives create prj_... \\
-    --scope portable-runtime-v1 --auth stubs --consistency pause-writes \\
-    --wait --output ./project.r402ar --json
-
-Options for create:
-  --scope <scope>          Archive scope. v1 supports portable-runtime-v1.
-  --auth <mode>            Auth export mode: stubs (default) or none.
-  --consistency <mode>     pause-writes (default) or cloud_write_pause_v1.
-  --idempotency-key <key>  Retry-safe creation key.
-  --wait                   Poll until the archive is ready.
-  --output <file>          Save archive bytes. Implies --wait.
-  --poll-interval <ms>     Poll interval while waiting (default 1000).
-  --timeout <ms>           Wait timeout (default 600000).
-  --json                   Emit final JSON on stdout.
-  --json-stream            Emit NDJSON progress events on stdout.
-`;
-
-const FLAG_VALUES = [
-  "--project",
-  "--scope",
-  "--auth",
-  "--consistency",
-  "--idempotency-key",
-  "--output",
-  "--poll-interval",
-  "--timeout",
-];
-const FLAGS = new Set([
-  ...FLAG_VALUES,
-  "--wait",
-  "--json",
-  "--json-stream",
-  "--help",
-  "-h",
-]);
-
-export async function run(sub, args = []) {
-  const all = [sub, ...args].filter(Boolean);
-  if (hasHelp(all)) {
-    console.log(HELP);
-    return;
-  }
-  if (sub !== "archives") {
-    failUnknownSubcommand("cloud", sub, {
-      next_actions: [{ type: "run_command", command: "run402 cloud archives --help" }],
-    });
-  }
-  const action = args[0];
-  const rest = args.slice(1);
-  if (action === "create") return create(rest);
-  if (action === "download") return download(rest);
-  if (action === "status") return status(rest);
-  failUnknownSubcommand("cloud archives", action, {
-    next_actions: [{ type: "run_command", command: "run402 cloud archives --help" }],
-  });
-}
-
-async function create(rawArgs) {
-  const args = normalizeArgv(rawArgs);
-  assertKnownFlags(args, [...FLAGS], FLAG_VALUES);
-  const { projectId, rest } = resolveProjectSelector(args, { valueFlags: FLAG_VALUES });
-  const extraPos = positionalArgs(rest, FLAG_VALUES);
-  if (extraPos.length > 0) {
-    fail({ code: "BAD_USAGE", message: `Unexpected argument for cloud archives create: ${extraPos[0]}` });
-  }
-  const scope = flagValue(args, "--scope") ?? "portable-runtime-v1";
-  const auth = flagValue(args, "--auth") ?? "stubs";
-  const consistency = flagValue(args, "--consistency") ?? "pause-writes";
-  assertAllowedValue(scope, ["portable-runtime-v1"], "--scope");
-  assertAllowedValue(auth, ["stubs", "none"], "--auth");
-  assertAllowedValue(consistency, ["pause-writes", "cloud_write_pause_v1"], "--consistency");
-
-  const output = flagValue(args, "--output");
-  const wait = args.includes("--wait") || Boolean(output);
-  const jsonStream = args.includes("--json-stream");
-  const idempotencyKey = flagValue(args, "--idempotency-key") ?? undefined;
-  const pollIntervalMs = parseIntegerFlag("--poll-interval", flagValue(args, "--poll-interval"), { min: 100, def: 1000 });
-  const timeoutMs = parseIntegerFlag("--timeout", flagValue(args, "--timeout"), { min: 1000, def: 600000 });
-  const emit = (event) => {
-    if (jsonStream) console.log(JSON.stringify(event));
-  };
-
-  try {
-    const sdk = getSdk();
-    const created = await sdk.archives.create(projectId, {
-      scope,
-      auth,
-      consistency,
-      idempotencyKey,
-    });
-    emit(progressEvent("archive_export_created", "create", projectId, created));
-
-    let archive = created;
-    let outputPath = null;
-    let bytesWritten = 0;
-    if (wait) {
-      archive = created.status === "ready"
-        ? created
-        : await sdk.archives.wait(projectId, created.archive_id, {
-            pollIntervalMs,
-            timeoutMs,
-            onProgress: emit,
-          });
-      if (archive.status !== "ready") {
-        const result = finalCreateResult({ projectId, created, archive, outputPath, bytesWritten });
-        printJson(result, jsonStream);
-        process.exit(1);
-      }
-      if (output) {
-        const download = await sdk.archives.download(projectId, archive.archive_id);
-        outputPath = resolve(output);
-        mkdirSync(dirname(outputPath), { recursive: true });
-        writeFileSync(outputPath, download.bytes);
-        bytesWritten = download.bytes.byteLength;
-        emit({
-          ...progressEvent("archive_export_downloaded", "download", projectId, archive),
-          context: { output_path: outputPath, bytes_written: bytesWritten },
-        });
-      }
-    }
-
-    const result = finalCreateResult({ projectId, created, archive, outputPath, bytesWritten });
-    if (jsonStream) {
-      console.log(JSON.stringify({
-        event: "archive_export_complete",
-        stage: "complete",
-        resource_type: "project_archive",
-        resource_id: archive.archive_id,
-        project_id: projectId,
-        status: archive.status === "ready" ? "complete" : archive.status,
-        completed_units: archive.status === "ready" ? 1 : 0,
-        total_units: 1,
-        code: null,
-        message: archive.status === "ready" ? "Archive export complete." : "Archive export did not complete.",
-        next_action: archive.next_action,
-        retryable: false,
-        result,
-      }));
-    } else {
-      console.log(JSON.stringify(result, null, 2));
-    }
-    if (archive.status !== "ready") process.exit(1);
-  } catch (err) {
-    reportSdkError(err);
-  }
-}
-
-async function download(rawArgs) {
-  const args = normalizeArgv(rawArgs);
-  assertKnownFlags(args, ["--project", "--output", "--json", "--help", "-h"], ["--project", "--output"]);
-  const { projectId, rest } = resolveProjectSelector(args, { valueFlags: ["--project", "--output"] });
-  const pos = positionalArgs(rest, ["--project", "--output"]);
-  const [archiveId] = pos;
-  const output = flagValue(args, "--output");
-  if (!archiveId || pos.length > 1 || !output) {
-    fail({ code: "BAD_USAGE", message: "Usage: run402 cloud archives download <archive-id> --output <file> [--project <id>] [--json]" });
-  }
-  try {
-    const download = await getSdk().archives.download(projectId, archiveId);
-    const outputPath = resolve(output);
-    mkdirSync(dirname(outputPath), { recursive: true });
-    writeFileSync(outputPath, download.bytes);
-    console.log(JSON.stringify({
-      ok: true,
-      project_id: projectId,
-      archive_id: archiveId,
-      output_path: outputPath,
-      bytes_written: download.bytes.byteLength,
-      sha256: download.archive.sha256,
-      verify_command: `run402 archives verify ${JSON.stringify(outputPath)} --json`,
-      import_command: `run402 core projects import ${JSON.stringify(outputPath)} --name imported-project --env-file ./required.env --json`,
-      archive: download.archive,
-    }, null, 2));
-  } catch (err) {
-    reportSdkError(err);
-  }
-}
-
-async function status(rawArgs) {
-  const args = normalizeArgv(rawArgs);
-  assertKnownFlags(args, ["--project", "--json", "--help", "-h"], ["--project"]);
-  const { projectId, rest } = resolveProjectSelector(args, { valueFlags: ["--project"] });
-  const pos = positionalArgs(rest, ["--project"]);
-  const [archiveId] = pos;
-  if (!archiveId || pos.length > 1) {
-    fail({ code: "BAD_USAGE", message: "Usage: run402 cloud archives status <archive-id> [--project <id>] [--json]" });
-  }
-  try {
-    const archive = await getSdk().archives.get(projectId, archiveId);
-    console.log(JSON.stringify({ archive }, null, 2));
-  } catch (err) {
-    reportSdkError(err);
-  }
-}
-
-function finalCreateResult({ projectId, created, archive, outputPath, bytesWritten }) {
-  return {
-    ok: archive.status === "ready",
-    project_id: projectId,
-    archive_id: archive.archive_id,
-    operation_id: archive.operation_id,
-    created_archive_id: created.archive_id,
-    archive_status: archive.status,
-    output_path: outputPath,
-    bytes_written: bytesWritten,
-    sha256: archive.sha256,
-    byte_count: archive.byte_count,
-    expires_at: archive.expires_at,
-    verify_command: outputPath ? `run402 archives verify ${JSON.stringify(outputPath)} --json` : null,
-    import_command: outputPath ? `run402 core projects import ${JSON.stringify(outputPath)} --name imported-project --env-file ./required.env --json` : null,
-    next_action: archive.next_action,
-    portability_report: archive.portability_report,
-    export_report: archive.export_report,
-    archive,
-  };
-}
-
-function progressEvent(event, stage, projectId, archive) {
-  return {
-    event,
-    stage,
-    resource_type: "project_archive",
-    resource_id: archive.archive_id,
-    project_id: projectId,
-    status: archive.status,
-    completed_units: archive.status === "ready" || archive.status === "failed" || archive.status === "expired" ? 1 : 0,
-    total_units: 1,
-    code: archive.status === "failed" ? archive.error?.code ?? "ARCHIVE_EXPORT_FAILED" : null,
-    message: `Archive export status: ${archive.status}`,
-    next_action: archive.next_action,
-    retryable: archive.status === "running",
-  };
-}
-
-function printJson(result, alreadyStreamed) {
-  if (!alreadyStreamed) console.log(JSON.stringify(result, null, 2));
-}