@agentkv/cli 0.1.0

package/dist/cli.js

@@ -0,0 +1,679 @@
+#!/usr/bin/env node
+import {
+  VERSION,
+  accountPath,
+  agentkvDir,
+  clientFromConfig,
+  createStoredAccount,
+  getOnrampProvider,
+  getOrCreateStoredWallet,
+  peekStoredAccount,
+  peekStoredWallet,
+  readConfigFile,
+  readEnvSecret,
+  readFileSecret,
+  resolveConfig,
+  writeSecretFile
+} from "./chunk-34AG6FLC.js";
+
+// src/cli.ts
+import { mkdirSync, realpathSync, writeFileSync } from "fs";
+import { join } from "path";
+import { fileURLToPath } from "url";
+import { AgentKVError, SpendCapError } from "@agentkv/client";
+
+// src/args.ts
+var UsageError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UsageError";
+  }
+};
+var KNOWN_FLAGS = /* @__PURE__ */ new Set([
+  "endpoint",
+  "network",
+  "max-spend-usd",
+  "ttl-days",
+  "strict-ttl",
+  "pretty",
+  "json",
+  "reveal",
+  "out",
+  "file",
+  "from-key",
+  "from-env",
+  "cursor",
+  "limit",
+  "idempotency-key",
+  "onramp-app-id",
+  "onramp-provider"
+]);
+function parseFlags(args) {
+  const flags = {};
+  const positionals = [];
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a.startsWith("--")) {
+      const key = a.slice(2);
+      if (!KNOWN_FLAGS.has(key)) {
+        throw new UsageError(`unknown flag --${key}`);
+      }
+      const boolish = ["strict-ttl", "pretty", "json", "reveal"].includes(key);
+      const val = boolish ? true : args[++i];
+      if (!boolish && (val === void 0 || val === "" || val.startsWith("--"))) {
+        throw new UsageError(`flag --${key} requires a value`);
+      }
+      if (key.endsWith("usd") || key === "ttl-days") {
+        const n = Number(val);
+        if (!Number.isFinite(n) || n < 0) {
+          throw new UsageError(
+            `flag --${key} must be a non-negative number (got ${JSON.stringify(val)})`
+          );
+        }
+        flags[camel(key)] = n;
+      } else {
+        flags[camel(key)] = val;
+      }
+    } else positionals.push(a);
+  }
+  return { flags, positionals };
+}
+var camel = (s) => s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+
+// src/commands/account.ts
+import { AgentKV, isAccountKeyFormat } from "@agentkv/client";
+import { privateKeyToAccount } from "viem/accounts";
+
+// src/output.ts
+var EXIT = { OK: 0, GENERIC: 1, USAGE: 2, PAYMENT: 3, NOT_FOUND: 4 };
+function printJson(w, value) {
+  w(`${JSON.stringify(value, null, 2)}
+`);
+}
+function printError(w, code, message, hint) {
+  w(`${JSON.stringify({ error: message, code, ...hint ? { hint } : {} })}
+`);
+}
+
+// src/commands/account.ts
+var PAYER_KEY_RE = /^0x[0-9a-fA-F]{64}$/;
+function resolvePayerKey(flags, env) {
+  const explicit = (typeof flags.fromKey === "string" ? flags.fromKey.trim() : "") || env.AGENTKV_PAYER_KEY?.trim() || env.AGENTKV_PRIVATE_KEY?.trim() || "";
+  if (explicit) {
+    if (!PAYER_KEY_RE.test(explicit)) {
+      throw new Error(
+        "payer key must be a 0x-prefixed 32-byte hex private key (from --from-key / AGENTKV_PAYER_KEY / AGENTKV_PRIVATE_KEY)"
+      );
+    }
+    return explicit;
+  }
+  if (peekStoredWallet(env)) return getOrCreateStoredWallet(env).privateKey;
+  return void 0;
+}
+async function runAccount(args, io) {
+  const sub = args[0];
+  const env = io.env ?? process.env;
+  const { flags, positionals } = parseFlags(args);
+  const cfg = resolveConfig(flags, env, () => readConfigFile(env));
+  if (sub === "new") {
+    let acct;
+    try {
+      acct = createStoredAccount(env);
+    } catch (e) {
+      if (e?.code === "EEXIST") {
+        printError(
+          io.stderr,
+          "account_exists",
+          // accountPath (not peekStoredAccount) so a present-but-CORRUPT file — which now
+          // throws from peek — still yields a clean "already exists" message, not a crash.
+          `an account already exists at ${accountPath(env)}; delete it first to replace it`
+        );
+        return EXIT.GENERIC;
+      }
+      throw e;
+    }
+    printJson(io.stdout, {
+      accountKey: acct.accountKey,
+      encryptionKey: acct.encryptionKey,
+      path: acct.path,
+      note: `Back up these \u2014 they are UNRECOVERABLE (the server stores only a hash of the account key). Fund this account by depositing >=$1 to ${cfg.endpoint}/account/deposit from a wallet that can sign (e.g. awal). To buy USDC with a card for such a signing wallet, run \`agentkv fund\`.`
+    });
+    return EXIT.OK;
+  }
+  if (sub === "show") {
+    const reveal = args.includes("--reveal");
+    const envAccountKey = cfg.accountKey;
+    if (envAccountKey !== void 0 && !isAccountKeyFormat(envAccountKey)) {
+      printError(
+        io.stderr,
+        "invalid_config",
+        "AGENTKV_ACCOUNT_KEY must be of the form ak_<64 lowercase hex> (run 'agentkv account new' to mint one)"
+      );
+      return EXIT.GENERIC;
+    }
+    const envAccount = envAccountKey ? { accountKey: envAccountKey, encryptionKey: cfg.encryptionKey } : null;
+    const stored = envAccount ? null : peekStoredAccount(env);
+    if (!envAccount && !stored) {
+      printJson(io.stdout, {
+        configured: false,
+        note: "No account yet \u2014 run 'agentkv account new' to mint one (account-key mode is opt-in)."
+      });
+      return EXIT.OK;
+    }
+    if (reveal) {
+      if (envAccount) {
+        printJson(io.stdout, {
+          source: "AGENTKV_ACCOUNT_KEY env",
+          accountKey: envAccount.accountKey,
+          encryptionKey: envAccount.encryptionKey ?? null,
+          note: "These come from the environment (AGENTKV_ACCOUNT_KEY / AGENTKV_ENCRYPTION_KEY)."
+        });
+        return EXIT.OK;
+      }
+      printJson(io.stdout, {
+        source: "local account file",
+        path: stored.path,
+        accountKey: stored.accountKey,
+        encryptionKey: stored.encryptionKey,
+        note: "These are unrecoverable secrets \u2014 store them somewhere safe."
+      });
+      return EXIT.OK;
+    }
+    const acctKey = envAccount?.accountKey ?? stored?.accountKey;
+    const encKey = envAccount?.encryptionKey ?? stored?.encryptionKey;
+    let balance;
+    let balanceError;
+    try {
+      const balanceClient = io.client ?? (acctKey && encKey ? new AgentKV({
+        accountKey: acctKey,
+        encryptionKey: encKey,
+        endpoint: cfg.endpoint,
+        network: cfg.network
+      }) : void 0);
+      if (balanceClient) {
+        balance = await balanceClient.balance();
+      }
+    } catch (e) {
+      balanceError = e instanceof Error ? e.message : String(e);
+    }
+    if (envAccount) {
+      printJson(io.stdout, {
+        configured: true,
+        source: "AGENTKV_ACCOUNT_KEY env",
+        note: "Account configured from the environment (AGENTKV_ACCOUNT_KEY). Its account key + encryption key are unrecoverable \u2014 back them up. Use --reveal to print them.",
+        ...balance !== void 0 ? { balance } : {},
+        ...balanceError ? { balanceError } : {}
+      });
+      return EXIT.OK;
+    }
+    printJson(io.stdout, {
+      source: "local account file",
+      path: stored.path,
+      note: "Back up this file \u2014 its account key + encryption key are unrecoverable. Use --reveal to print them.",
+      ...balance !== void 0 ? { balance } : {},
+      ...balanceError ? { balanceError } : {}
+    });
+    return EXIT.OK;
+  }
+  if (sub === "fund") {
+    const usd = Number(positionals[1]);
+    if (!Number.isInteger(usd) || usd < 1) {
+      printError(
+        io.stderr,
+        "usage",
+        "account fund requires <usd> as a whole number of US dollars >= 1"
+      );
+      return EXIT.USAGE;
+    }
+    const envAccountKey = cfg.accountKey;
+    if (envAccountKey !== void 0 && !isAccountKeyFormat(envAccountKey)) {
+      printError(
+        io.stderr,
+        "invalid_config",
+        "AGENTKV_ACCOUNT_KEY must be of the form ak_<64 lowercase hex> (run 'agentkv account new' to mint one)"
+      );
+      return EXIT.GENERIC;
+    }
+    const envAccount = envAccountKey ? { accountKey: envAccountKey, encryptionKey: cfg.encryptionKey } : null;
+    const stored = envAccount ? null : peekStoredAccount(env);
+    const acctKey = envAccount?.accountKey ?? stored?.accountKey;
+    const encKey = envAccount?.encryptionKey ?? stored?.encryptionKey;
+    if (!acctKey) {
+      printError(
+        io.stderr,
+        "no_account",
+        "no account configured; run 'agentkv account new' or set AGENTKV_ACCOUNT_KEY (+ AGENTKV_ENCRYPTION_KEY)"
+      );
+      return EXIT.GENERIC;
+    }
+    let payerKey;
+    try {
+      payerKey = resolvePayerKey(flags, env);
+    } catch (e) {
+      printError(io.stderr, "invalid_payer", e instanceof Error ? e.message : String(e));
+      return EXIT.USAGE;
+    }
+    if (!payerKey) {
+      printError(
+        io.stderr,
+        "no_payer",
+        "no payer wallet; pass --from-key <0xhex> or set AGENTKV_PAYER_KEY (or AGENTKV_PRIVATE_KEY)"
+      );
+      return EXIT.GENERIC;
+    }
+    const payer = privateKeyToAccount(payerKey);
+    let client = io.client;
+    if (!io.client) {
+      if (!encKey) {
+        printError(
+          io.stderr,
+          "invalid_config",
+          envAccount ? "account-key mode (AGENTKV_ACCOUNT_KEY) requires AGENTKV_ENCRYPTION_KEY (the local 32-byte AES key)" : "account.json is missing or has a malformed encryptionKey (the local 32-byte AES key)"
+        );
+        return EXIT.GENERIC;
+      }
+      client = new AgentKV({
+        accountKey: acctKey,
+        encryptionKey: encKey,
+        endpoint: cfg.endpoint,
+        network: cfg.network
+      });
+    }
+    const result = await client.fundAccount(payer, usd);
+    printJson(io.stdout, result);
+    return EXIT.OK;
+  }
+  printError(
+    io.stderr,
+    "usage",
+    "account new | account show [--reveal] | account fund <usd> [--from-key <0xhex>]"
+  );
+  return EXIT.USAGE;
+}
+
+// src/commands/credits.ts
+async function runCredits(cmd, args, io) {
+  if (cmd === "balance") {
+    printJson(io.stdout, { balance: await io.client.balance() });
+    return EXIT.OK;
+  }
+  const { positionals } = parseFlags(args);
+  const usd = Number(positionals[0]);
+  if (!Number.isFinite(usd) || usd < 1 || usd * 1e6 !== Math.round(usd * 1e6)) {
+    printError(
+      io.stderr,
+      "usage",
+      "deposit requires <usd> >= 1 (a whole number of atomic USDC units)"
+    );
+    return EXIT.USAGE;
+  }
+  printJson(io.stdout, await io.client.deposit(usd));
+  return EXIT.OK;
+}
+
+// src/commands/fund.ts
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+var KEY_RE = /^0x[0-9a-fA-F]{64}$/;
+function runFund(args, io) {
+  const env = io.env ?? process.env;
+  const { flags, positionals } = parseFlags(args);
+  let amountUsd;
+  if (positionals.length > 0) {
+    const n = Number(positionals[0]);
+    if (!Number.isFinite(n) || n <= 0) {
+      printError(
+        io.stderr,
+        "usage",
+        `amount must be a positive number (got ${JSON.stringify(positionals[0])})`
+      );
+      return EXIT.USAGE;
+    }
+    amountUsd = n;
+  }
+  const cfg = resolveConfig(flags, env, () => readConfigFile(env));
+  const providerId = cfg.onrampProvider ?? "coinbase";
+  const onrampConfig = cfg.onrampConfig ?? {};
+  let address;
+  const envKey = env.AGENTKV_PRIVATE_KEY?.trim();
+  if (envKey) {
+    if (!KEY_RE.test(envKey)) {
+      printError(
+        io.stderr,
+        "invalid_config",
+        "AGENTKV_PRIVATE_KEY is set but malformed (expected 0x followed by 64 hex chars)"
+      );
+      return EXIT.GENERIC;
+    }
+    address = privateKeyToAccount2(envKey).address;
+  } else {
+    address = peekStoredWallet(env)?.address;
+  }
+  if (!address) {
+    const account = peekStoredAccount(env);
+    const inAccountMode = !!(env.AGENTKV_ACCOUNT_KEY?.trim() || account);
+    if (inAccountMode) {
+      printJson(io.stdout, {
+        provider: providerId,
+        url: null,
+        address: null,
+        note: `Account-key mode has no single wallet to onramp into. Account credits are funded by depositing USDC to ${cfg.endpoint}/account/deposit from a wallet that can sign (e.g. awal). An onramp can fund such a signing wallet: fund a wallet first (e.g. send USDC to it, or set AGENTKV_PRIVATE_KEY and re-run \`agentkv fund\`), then deposit to the account.`
+      });
+      return EXIT.OK;
+    }
+    printJson(io.stdout, {
+      provider: providerId,
+      url: null,
+      address: null,
+      note: "No wallet yet \u2014 one is auto-provisioned on the first paid op (e.g. `agentkv balance`), or set AGENTKV_PRIVATE_KEY to use your own. Provision/configure a wallet, then re-run `agentkv fund` for a funding URL."
+    });
+    return EXIT.OK;
+  }
+  let provider;
+  try {
+    provider = getOnrampProvider(providerId);
+  } catch (e) {
+    printError(io.stderr, "unknown_provider", e instanceof Error ? e.message : String(e));
+    return EXIT.USAGE;
+  }
+  let url;
+  try {
+    url = provider.buildUrl({ address, network: cfg.network, amountUsd, config: onrampConfig });
+  } catch (e) {
+    printError(io.stderr, "onramp_config", e instanceof Error ? e.message : String(e));
+    return EXIT.GENERIC;
+  }
+  printJson(io.stdout, {
+    provider: provider.id,
+    url,
+    address,
+    ...amountUsd !== void 0 ? { amountUsd } : {},
+    note: `Open this URL to buy USDC with a card and deliver it to ${address} on Base via ${provider.name}.`
+  });
+  return EXIT.OK;
+}
+
+// src/commands/kv.ts
+import { readFileSync } from "fs";
+async function runKv(cmd, args, io) {
+  const { flags, positionals } = parseFlags(args);
+  const key = positionals[0];
+  if (!key) {
+    printError(io.stderr, "usage", `${cmd} requires <key>`);
+    return EXIT.USAGE;
+  }
+  if (cmd === "delete") {
+    const bad = ["out", "fromEnv", "file"].find((f) => f in flags);
+    if (bad) {
+      const flag = bad === "fromEnv" ? "from-env" : bad;
+      printError(io.stderr, "usage", `--${flag} is not valid for delete`);
+      return EXIT.USAGE;
+    }
+    printJson(io.stdout, await io.client.delete(key));
+    return EXIT.OK;
+  }
+  if (cmd === "get") {
+    const v = await io.client.get(
+      key,
+      flags.idempotencyKey ? { idempotencyKey: flags.idempotencyKey } : {}
+    );
+    if (v === null) {
+      printJson(io.stdout, flags.out ? { found: false } : null);
+      return EXIT.NOT_FOUND;
+    }
+    if (flags.out) {
+      const text = typeof v === "string" ? v : JSON.stringify(v);
+      let written;
+      try {
+        written = writeSecretFile(text, flags.out);
+      } catch {
+        printError(
+          io.stderr,
+          "write_failed",
+          "could not write --out file (choose a fresh path that does not already exist)"
+        );
+        return EXIT.USAGE;
+      }
+      printJson(io.stdout, { found: true, path: written.path, bytes: written.bytes });
+      return EXIT.OK;
+    }
+    printJson(io.stdout, v);
+    return EXIT.OK;
+  }
+  let value;
+  if (flags.fromEnv) {
+    const r = readEnvSecret(flags.fromEnv);
+    if (!r.ok) {
+      printError(io.stderr, r.code, r.error);
+      return EXIT.USAGE;
+    }
+    value = r.value;
+  } else {
+    let raw;
+    if (positionals[1] !== void 0) {
+      raw = positionals[1];
+    } else if (flags.file) {
+      const r = readFileSecret(flags.file, { trim: false });
+      if (!r.ok) {
+        printError(io.stderr, r.code, r.error);
+        return EXIT.USAGE;
+      }
+      raw = r.value;
+    } else {
+      raw = readFileSync(0, "utf8");
+    }
+    try {
+      value = JSON.parse(raw);
+    } catch {
+      printError(
+        io.stderr,
+        "invalid_value",
+        "value must be valid JSON",
+        `examples: '"a string"'  42  '{"k":"v"}'`
+      );
+      return EXIT.USAGE;
+    }
+  }
+  const opts = {};
+  if (flags.ttlDays !== void 0) opts.ttlDays = flags.ttlDays;
+  if (flags.strictTtl) opts.strictTtl = true;
+  if (flags.idempotencyKey) opts.idempotencyKey = flags.idempotencyKey;
+  printJson(io.stdout, await io.client.set(key, value, opts));
+  return EXIT.OK;
+}
+async function runListKeys(args, io) {
+  const { flags } = parseFlags(args);
+  const limit = flags.limit !== void 0 ? Number(flags.limit) : void 0;
+  const onePage = flags.cursor !== void 0;
+  const keys = [];
+  let cursor = flags.cursor ?? null;
+  do {
+    const res = await io.client.listKeys(cursor ? { cursor, limit } : { limit });
+    keys.push(...res.keys);
+    cursor = res.cursor;
+  } while (cursor && !onePage);
+  printJson(io.stdout, { keys: keys.sort(), count: keys.length, cursor: onePage ? cursor : null });
+  return EXIT.OK;
+}
+
+// src/commands/wallet.ts
+import { generatePrivateKey, privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
+var KEY_RE2 = /^0x[0-9a-fA-F]{64}$/;
+function runWallet(args, io) {
+  const sub = args[0];
+  if (sub === "new") {
+    const privateKey = generatePrivateKey();
+    printJson(io.stdout, {
+      address: privateKeyToAccount3(privateKey).address,
+      privateKey,
+      note: "Optional: set AGENTKV_PRIVATE_KEY to this to manage your own key. Otherwise AgentKV mints + manages a local wallet on first use."
+    });
+    return EXIT.OK;
+  }
+  if (sub === "show") {
+    const env = io.env ?? process.env;
+    const envKey = env.AGENTKV_PRIVATE_KEY?.trim();
+    if (envKey) {
+      if (!KEY_RE2.test(envKey)) {
+        printError(
+          io.stderr,
+          "invalid_config",
+          "AGENTKV_PRIVATE_KEY is set but malformed (expected 0x followed by 64 hex chars)"
+        );
+        return EXIT.GENERIC;
+      }
+      printJson(io.stdout, {
+        address: privateKeyToAccount3(envKey).address,
+        source: "env (AGENTKV_PRIVATE_KEY)"
+      });
+      return EXIT.OK;
+    }
+    const stored = peekStoredWallet(env);
+    if (stored) {
+      printJson(io.stdout, {
+        address: stored.address,
+        source: "local keystore",
+        path: stored.path,
+        note: "Back up this file \u2014 it is your namespace and holds your funds."
+      });
+      return EXIT.OK;
+    }
+    printJson(io.stdout, {
+      address: null,
+      note: "No wallet yet \u2014 one is created automatically on first use (set / get / deposit / \u2026)."
+    });
+    return EXIT.OK;
+  }
+  printError(io.stderr, "usage", "wallet new | wallet show");
+  return EXIT.USAGE;
+}
+
+// src/cli.ts
+var HELP = `agentkv \u2014 encrypted, x402-paid key-value store (v${VERSION})
+
+Usage: agentkv <command> [options]
+
+Commands:
+  set <key> <json>        Encrypt and store a value
+  get <key>               Fetch and decrypt a value
+  delete <key>            Delete a value
+  list-keys               List stored key names
+  balance                 Show prepaid credit balance
+  deposit <usd>           Buy credits (>= $1) with USDC via x402
+  wallet new|show         Manage the local signing wallet
+  account new|show|fund   Manage an account-key (ak_) namespace
+  fund                    Print a card->USDC onramp URL
+  config                  Read/write local defaults
+  mcp                     Run the MCP server (stdio)
+
+Global options:
+  --endpoint <url>        API endpoint (default https://api.agentx402.ai)
+  --network <caip2>       eip155:8453 (default) or eip155:84532
+  --max-spend-usd <n>     Per-operation spend cap (USD)
+  --json | --pretty       Output format
+  -h, --help              Show this help
+  -V, --version           Show the CLI version
+
+Docs: https://github.com/agentx402-ai/agentkv
+`;
+async function runCli(argv, deps = {}) {
+  const stdout = deps.stdout ?? ((s) => process.stdout.write(s));
+  const stderr = deps.stderr ?? ((s) => process.stderr.write(s));
+  const [cmd, ...rest] = argv;
+  if (cmd === void 0 || cmd === "-h" || cmd === "--help" || cmd === "help") {
+    stdout(HELP);
+    return EXIT.OK;
+  }
+  if (cmd === "-V" || cmd === "--version" || cmd === "version") {
+    stdout(`${VERSION}
+`);
+    return EXIT.OK;
+  }
+  try {
+    const env = deps.env ?? process.env;
+    if (cmd === "wallet") return runWallet(rest, { stdout, stderr, env });
+    if (cmd === "fund") return runFund(rest, { stdout, stderr, env });
+    if (cmd === "config") return runConfig(rest, { stdout, stderr, env });
+    if (cmd === "account") {
+      return await runAccount(rest, { client: deps.client, stdout, stderr, env });
+    }
+    if (cmd === "mcp") {
+      const { startMcp } = await import("./mcp-MINXA6WX.js");
+      await startMcp({ env: deps.env, client: deps.client });
+      return EXIT.OK;
+    }
+    const KV_COMMANDS = /* @__PURE__ */ new Set(["set", "get", "delete", "list-keys", "balance", "deposit"]);
+    if (!KV_COMMANDS.has(cmd)) {
+      printError(
+        stderr,
+        "usage",
+        `unknown command: ${cmd ?? "(none)"}`,
+        "commands: set get delete list-keys deposit balance wallet account fund config mcp (run `agentkv --help`)"
+      );
+      return EXIT.USAGE;
+    }
+    const client = deps.client ?? clientFromConfig(
+      resolveConfig(parseFlags(rest).flags, env, () => readConfigFile(env)),
+      {
+        env,
+        // Auto-provision notice -> stderr, so it never pollutes JSON stdout.
+        notify: (m) => stderr(`agentkv: ${m}
+`)
+      }
+    );
+    if (cmd === "set" || cmd === "get" || cmd === "delete")
+      return await runKv(cmd, rest, { client, stdout, stderr });
+    if (cmd === "list-keys") return await runListKeys(rest, { client, stdout, stderr });
+    return await runCredits(cmd, rest, { client, stdout, stderr });
+  } catch (e) {
+    return mapError(e, stderr);
+  }
+}
+function mapError(e, stderr) {
+  if (e instanceof SpendCapError) {
+    printError(stderr, e.code, e.message);
+    return EXIT.PAYMENT;
+  }
+  if (e instanceof AgentKVError) {
+    printError(stderr, e.code, e.message);
+    if (e.status === 404) return EXIT.NOT_FOUND;
+    if (e.status === 402) return EXIT.PAYMENT;
+    return EXIT.GENERIC;
+  }
+  if (e instanceof UsageError) {
+    printError(stderr, "usage", e.message);
+    return EXIT.USAGE;
+  }
+  printError(stderr, "error", e instanceof Error ? e.message : String(e));
+  return EXIT.GENERIC;
+}
+function runConfig(args, io) {
+  const env = io.env ?? process.env;
+  const { flags } = parseFlags(args);
+  const dir = agentkvDir(env);
+  mkdirSync(dir, { recursive: true });
+  const existing = readConfigFile(env) ?? {};
+  const merged = { ...existing };
+  if (flags.endpoint) merged.endpoint = flags.endpoint;
+  if (flags.network) merged.network = flags.network;
+  if (flags.maxSpendUsd !== void 0) merged.maxSpendUsd = flags.maxSpendUsd;
+  const path = join(dir, "config.json");
+  writeFileSync(path, JSON.stringify(merged, null, 2));
+  printJson(io.stdout, { ok: true, path, ...merged });
+  return EXIT.OK;
+}
+function isMainModule() {
+  const argv1 = process.argv[1];
+  if (!argv1) return false;
+  try {
+    return realpathSync(argv1) === fileURLToPath(import.meta.url);
+  } catch {
+    return false;
+  }
+}
+if (isMainModule()) {
+  runCli(process.argv.slice(2)).then((code) => process.exit(code));
+}
+export {
+  parseFlags,
+  runCli
+};