@agentkv/cli 0.1.0

package/dist/chunk-34AG6FLC.js

@@ -0,0 +1,720 @@
+#!/usr/bin/env node
+
+// src/keystore.ts
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { generateAccountKey, isAccountKeyFormat } from "@agentkv/client";
+import { bytesToHex } from "viem";
+import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
+var POSIX = process.platform !== "win32";
+var KEY_RE = /^0x[0-9a-fA-F]{64}$/;
+function agentkvDir(env = process.env) {
+  const override = env.AGENTKV_HOME?.trim();
+  return override ? override : join(homedir(), ".agentkv");
+}
+function walletPath(env = process.env) {
+  return join(agentkvDir(env), "wallet.json");
+}
+function accountPath(env = process.env) {
+  return join(agentkvDir(env), "account.json");
+}
+function ensureDir(env) {
+  const dir = agentkvDir(env);
+  mkdirSync(dir, { recursive: true, mode: POSIX ? 448 : void 0 });
+  if (POSIX) {
+    try {
+      chmodSync(dir, 448);
+    } catch {
+    }
+  }
+}
+function writeKeystoreFile(file, body) {
+  writeFileSync(file, `${JSON.stringify(body, null, 2)}
+`, { mode: 384, flag: "wx" });
+  if (POSIX) {
+    try {
+      chmodSync(file, 384);
+    } catch {
+    }
+  }
+}
+function readKey(file) {
+  try {
+    const j = JSON.parse(readFileSync(file, "utf8"));
+    return typeof j.privateKey === "string" && KEY_RE.test(j.privateKey) ? j.privateKey : null;
+  } catch {
+    return null;
+  }
+}
+function peekStoredWallet(env = process.env) {
+  const file = walletPath(env);
+  const key = readKey(file);
+  return key ? { address: privateKeyToAccount(key).address, path: file } : null;
+}
+function getOrCreateStoredWallet(env = process.env) {
+  const file = walletPath(env);
+  const existing = readKey(file);
+  if (existing) {
+    return {
+      privateKey: existing,
+      address: privateKeyToAccount(existing).address,
+      path: file,
+      created: false
+    };
+  }
+  ensureDir(env);
+  const privateKey = generatePrivateKey();
+  const address = privateKeyToAccount(privateKey).address;
+  try {
+    writeKeystoreFile(file, { address, privateKey });
+  } catch (e) {
+    if (e?.code === "EEXIST") {
+      const k = readKey(file);
+      if (k)
+        return {
+          privateKey: k,
+          address: privateKeyToAccount(k).address,
+          path: file,
+          created: false
+        };
+    }
+    throw e;
+  }
+  return { privateKey, address, path: file, created: true };
+}
+var ENC_RE = /^0x[0-9a-fA-F]{64}$/;
+function peekStoredAccount(env = process.env) {
+  const file = accountPath(env);
+  let raw;
+  try {
+    raw = readFileSync(file, "utf8");
+  } catch (e) {
+    if (e?.code === "ENOENT") return null;
+    throw e;
+  }
+  let j;
+  try {
+    j = JSON.parse(raw);
+  } catch {
+    throw new Error(`${file} is not valid JSON`);
+  }
+  if (!isAccountKeyFormat(j.accountKey)) {
+    throw new Error(
+      `${file} has a missing or malformed accountKey (expected ak_<64 lowercase hex>)`
+    );
+  }
+  if (typeof j.encryptionKey !== "string" || !ENC_RE.test(j.encryptionKey)) {
+    throw new Error(
+      `${file} has a missing or malformed encryptionKey (expected 0x followed by 64 hex chars)`
+    );
+  }
+  return { accountKey: j.accountKey, encryptionKey: j.encryptionKey, path: file };
+}
+function createStoredAccount(env = process.env) {
+  const file = accountPath(env);
+  ensureDir(env);
+  const accountKey = generateAccountKey();
+  const encryptionKey = bytesToHex(crypto.getRandomValues(new Uint8Array(32)));
+  writeKeystoreFile(file, { accountKey, encryptionKey });
+  return { accountKey, encryptionKey, path: file };
+}
+
+// src/config.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
+import { AgentKV, AgentKVError, isAccountKeyFormat as isAccountKeyFormat2 } from "@agentkv/client";
+import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
+
+// src/awal.ts
+import { execFile } from "child_process";
+var AWAL_SPEC = "awal@2.12.0";
+var AK_RE = /^ak_[0-9a-f]{64}$/;
+var AK_REDACT = /ak_[0-9a-f]{64}/g;
+var TIMEOUT_MS = 12e4;
+var defaultExec = (cmd, args, opts) => new Promise((resolve, reject) => {
+  execFile(cmd, args, { timeout: opts.timeoutMs, windowsHide: true }, (err, stdout) => {
+    if (err) reject(err);
+    else resolve({ stdout: String(stdout) });
+  });
+});
+function redact(text) {
+  return text.replace(AK_REDACT, "ak_\u2026");
+}
+function awalTopoffPayer(exec = defaultExec) {
+  return async (req) => {
+    if (!AK_RE.test(req.accountKey)) {
+      throw new Error("awal top-off: invalid account key format");
+    }
+    let url;
+    try {
+      url = new URL(req.depositUrl);
+    } catch {
+      throw new Error("awal top-off: depositUrl is not a valid URL");
+    }
+    if (url.protocol !== "https:" && url.protocol !== "http:") {
+      throw new Error("awal top-off: depositUrl must be an http(s) URL");
+    }
+    const pathname = url.pathname.replace(/^\/v1(?=\/)/, "");
+    if (pathname !== "/account/deposit") {
+      throw new Error("awal top-off: refusing to pay a non-deposit route");
+    }
+    if (!Number.isInteger(req.maxAmountAtomic) || req.maxAmountAtomic <= 0) {
+      throw new Error("awal top-off: maxAmountAtomic must be a positive integer");
+    }
+    const args = [
+      "-y",
+      AWAL_SPEC,
+      "x402",
+      "pay",
+      url.toString(),
+      "-X",
+      "POST",
+      "-h",
+      JSON.stringify({ Authorization: `Bearer ${req.accountKey}` }),
+      "--max-amount",
+      String(req.maxAmountAtomic),
+      "--json"
+    ];
+    let stdout;
+    try {
+      ({ stdout } = await exec("npx", args, { timeoutMs: TIMEOUT_MS }));
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      throw new Error(`awal payment failed: ${redact(msg)}`);
+    }
+    let out;
+    try {
+      const jsonStart = stdout.indexOf("{");
+      out = JSON.parse(stdout.slice(jsonStart === -1 ? stdout.length : jsonStart));
+    } catch {
+      throw new Error("awal top-off: could not confirm settlement (unparseable awal output)");
+    }
+    if (out.error) {
+      throw new Error(`awal top-off failed: ${redact(String(out.error))}`);
+    }
+  };
+}
+
+// src/awalInline.ts
+import { execFile as execFile2 } from "child_process";
+var BEARER_RE = /^Bearer ak_[0-9a-f]{64}$/;
+var AK_REDACT2 = /ak_[0-9a-f]{64}/g;
+var TIMEOUT_MS2 = 12e4;
+var defaultExec2 = (cmd, args, opts) => new Promise((resolve, reject) => {
+  execFile2(cmd, args, { timeout: opts.timeoutMs, windowsHide: true }, (err, stdout) => {
+    if (err) reject(err);
+    else resolve({ stdout: String(stdout) });
+  });
+});
+function redact2(text) {
+  return text.replace(AK_REDACT2, "ak_\u2026");
+}
+function awalInlinePayer(exec = defaultExec2) {
+  return async (req) => {
+    const bearer = req.headers.Authorization;
+    if (typeof bearer !== "string" || !BEARER_RE.test(bearer)) {
+      throw new Error("awal inline pay: missing or malformed Authorization bearer");
+    }
+    let url;
+    try {
+      url = new URL(req.url);
+    } catch {
+      throw new Error("awal inline pay: url is not a valid URL");
+    }
+    if (url.protocol !== "https:" && url.protocol !== "http:") {
+      throw new Error("awal inline pay: url must be an http(s) URL");
+    }
+    const pathname = url.pathname.replace(/^\/v1(?=\/)/, "");
+    if (!pathname.startsWith("/kv/")) {
+      throw new Error("awal inline pay: refusing to pay a non-/kv/ route");
+    }
+    if (!Number.isInteger(req.maxAmountAtomic) || req.maxAmountAtomic <= 0) {
+      throw new Error("awal inline pay: maxAmountAtomic must be a positive integer");
+    }
+    if (req.method !== "POST" && req.method !== "GET") {
+      throw new Error("awal inline pay: method must be POST or GET");
+    }
+    const args = [
+      "-y",
+      AWAL_SPEC,
+      "x402",
+      "pay",
+      url.toString(),
+      "-X",
+      req.method,
+      ...req.method === "POST" && req.body != null ? ["-d", req.body] : [],
+      "-h",
+      JSON.stringify(req.headers),
+      "--max-amount",
+      String(req.maxAmountAtomic),
+      "--json"
+    ];
+    let stdout;
+    try {
+      ({ stdout } = await exec("npx", args, { timeoutMs: TIMEOUT_MS2 }));
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      throw new Error(`awal inline pay failed: ${redact2(msg)}`);
+    }
+    let parsed;
+    try {
+      const jsonStart = stdout.indexOf("{");
+      parsed = JSON.parse(stdout.slice(jsonStart === -1 ? stdout.length : jsonStart));
+    } catch {
+      throw new Error("awal inline pay: could not parse awal --json output");
+    }
+    if (typeof parsed !== "object" || parsed === null) {
+      throw new Error("awal inline pay: could not parse awal --json output");
+    }
+    if ("success" in parsed && parsed.success === false) {
+      const failure = parsed;
+      const message = failure.error?.message ?? failure.error?.code ?? "unknown awal error";
+      throw new Error(`awal inline pay failed: ${redact2(message)}`);
+    }
+    if ("error" in parsed && parsed.error) {
+      throw new Error(
+        `awal inline pay failed: ${redact2(String(parsed.error))}`
+      );
+    }
+    const ok = parsed;
+    if (typeof ok.status !== "number") {
+      throw new Error("awal inline pay: unrecognized awal --json output (missing status)");
+    }
+    return {
+      status: ok.status,
+      // Re-stringify: awal already parses the body as JSON, but the SDK does its own
+      // JSON.parse(body) on whatever this hook returns.
+      body: JSON.stringify(ok.data ?? null),
+      headers: ok.headers ?? {}
+    };
+  };
+}
+
+// src/config.ts
+var DEFAULT_ENDPOINT = "https://api.agentx402.ai";
+function readConfigFile(env = process.env) {
+  try {
+    const parsed = JSON.parse(
+      readFileSync2(join2(agentkvDir(env), "config.json"), "utf8")
+    );
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function resolveConfig(flags, env, readFile = () => null) {
+  const file = readFile() ?? {};
+  const endpoint = flags.endpoint ?? envStr(env.AGENTKV_ENDPOINT) ?? file.endpoint ?? DEFAULT_ENDPOINT;
+  return {
+    endpoint,
+    network: flags.network ?? envStr(env.AGENTKV_NETWORK) ?? file.network ?? "eip155:8453",
+    // Per-operation cap (throws on a single op above this).
+    maxSpendUsd: flags.maxSpendUsd ?? numOrThrow(env.AGENTKV_MAX_SPEND_USD, "AGENTKV_MAX_SPEND_USD") ?? file.maxSpendUsd,
+    // Cumulative, instance-lifetime cap — env-only, opt-in. Kept SEPARATE from the
+    // per-op cap: the MCP server is one long-lived client, so coupling them would turn
+    // a per-op ceiling into a lifetime budget that eventually blocks every op.
+    maxSessionSpendUsd: numOrThrow(
+      env.AGENTKV_MAX_SESSION_SPEND_USD,
+      "AGENTKV_MAX_SESSION_SPEND_USD"
+    ),
+    // secrets: env ONLY — never flags or file
+    privateKey: envStr(env.AGENTKV_PRIVATE_KEY),
+    encryptionKey: envStr(env.AGENTKV_ENCRYPTION_KEY),
+    accountKey: envStr(env.AGENTKV_ACCOUNT_KEY),
+    // Onramp: flag > env > file > default, matching the precedence used above. The provider
+    // is a string id resolved at use-time (getOnrampProvider) so config never imports the
+    // provider classes — adding a provider doesn't touch this file.
+    onrampProvider: flags.onrampProvider ?? envStr(env.AGENTKV_ONRAMP_PROVIDER) ?? file.onrampProvider ?? "coinbase",
+    // Provider config bag. Currently just Coinbase's appId; new keys go here without
+    // changing the command. appId is non-secret (a public CDP project id) so it may come
+    // from flag/env/file.
+    onrampConfig: {
+      appId: flags.onrampAppId ?? envStr(env.AGENTKV_ONRAMP_APP_ID) ?? file.onrampAppId
+    },
+    // Account-key auto top-off: env-only. Validated at client construction
+    // (clientFromConfig), where the auth mode is known.
+    topoff: envStr(env.AGENTKV_TOPOFF),
+    prepayWatermarkUsd: numOrThrow(env.AGENTKV_PREPAY_WATERMARK, "AGENTKV_PREPAY_WATERMARK"),
+    prepayTopoffUsd: numOrThrow(env.AGENTKV_PREPAY_TOPOFF, "AGENTKV_PREPAY_TOPOFF"),
+    // Inline pay-per-op transport: env-only, account-key mode only (validated at
+    // client construction, same as `topoff`, where the auth mode is known).
+    inline: envStr(env.AGENTKV_INLINE)
+  };
+}
+function envStr(s) {
+  if (s === void 0) return void 0;
+  const t = s.trim();
+  return t === "" ? void 0 : t;
+}
+function numOrThrow(s, name) {
+  const v = envStr(s);
+  if (v === void 0) return void 0;
+  const n = Number(v);
+  if (!Number.isFinite(n) || n < 0) {
+    throw new Error(`${name} must be a non-negative number (got ${JSON.stringify(v)})`);
+  }
+  return n;
+}
+function privateKeySigner(pk) {
+  return privateKeyToAccount2(pk);
+}
+function clientFromConfig(cfg, opts) {
+  const base = {
+    endpoint: cfg.endpoint,
+    network: cfg.network,
+    maxSpendUsd: cfg.maxSpendUsd,
+    maxSessionSpendUsd: cfg.maxSessionSpendUsd
+  };
+  let stored = null;
+  if (!cfg.accountKey && !cfg.privateKey) {
+    try {
+      stored = peekStoredAccount(opts?.env);
+    } catch (e) {
+      throw new AgentKVError(
+        `account.json is corrupt: ${e instanceof Error ? e.message : String(e)}; fix or remove it (or set AGENTKV_ACCOUNT_KEY / AGENTKV_PRIVATE_KEY explicitly)`,
+        "invalid_config",
+        0
+      );
+    }
+  }
+  const accountKey = cfg.accountKey ?? (cfg.privateKey ? void 0 : stored?.accountKey);
+  if (accountKey) {
+    if (!isAccountKeyFormat2(accountKey)) {
+      throw new Error(
+        "AGENTKV_ACCOUNT_KEY must be of the form ak_<64 lowercase hex> (run 'agentkv account new' to mint one)"
+      );
+    }
+    const encryptionKey = cfg.accountKey ? cfg.encryptionKey : stored?.encryptionKey;
+    if (!encryptionKey) {
+      throw new Error(
+        cfg.accountKey ? "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)"
+      );
+    }
+    if (cfg.topoff !== void 0 && cfg.topoff !== "awal") {
+      throw new AgentKVError(
+        `AGENTKV_TOPOFF: unrecognized value ${JSON.stringify(cfg.topoff)} (only "awal" is supported)`,
+        "invalid_config",
+        0
+      );
+    }
+    if (cfg.topoff === void 0 && (cfg.prepayWatermarkUsd !== void 0 || cfg.prepayTopoffUsd !== void 0)) {
+      throw new AgentKVError(
+        "AGENTKV_PREPAY_WATERMARK/AGENTKV_PREPAY_TOPOFF require AGENTKV_TOPOFF=awal",
+        "invalid_config",
+        0
+      );
+    }
+    if (cfg.inline !== void 0 && cfg.inline !== "awal") {
+      throw new AgentKVError(
+        `AGENTKV_INLINE: unrecognized value ${JSON.stringify(cfg.inline)} (only "awal" is supported)`,
+        "invalid_config",
+        0
+      );
+    }
+    const opInlinePayer = cfg.inline === "awal" ? awalInlinePayer() : void 0;
+    if (cfg.topoff === "awal") {
+      return new AgentKV({
+        ...base,
+        accountKey,
+        encryptionKey,
+        prepay: {
+          watermark: cfg.prepayWatermarkUsd ?? 0.5,
+          topoff: cfg.prepayTopoffUsd ?? 1
+        },
+        topoffPayer: awalTopoffPayer(),
+        ...opInlinePayer ? { opInlinePayer } : {}
+      });
+    }
+    return new AgentKV({
+      ...base,
+      accountKey,
+      encryptionKey,
+      ...opInlinePayer ? { opInlinePayer } : {}
+    });
+  }
+  if (cfg.topoff !== void 0 || cfg.prepayWatermarkUsd !== void 0 || cfg.prepayTopoffUsd !== void 0 || cfg.inline !== void 0) {
+    throw new AgentKVError(
+      "AGENTKV_TOPOFF / AGENTKV_PREPAY_* / AGENTKV_INLINE apply to account-key mode only (wallet mode pays its own top-offs)",
+      "invalid_config",
+      0
+    );
+  }
+  let privateKey = cfg.privateKey;
+  if (!privateKey) {
+    const w = getOrCreateStoredWallet(opts?.env);
+    privateKey = w.privateKey;
+    if (w.created) {
+      opts?.notify?.(
+        `created a new wallet ${w.address} (saved to ${w.path}). It is your namespace and holds your funds \u2014 fund it, then back it up. View it any time with: agentkv wallet show`
+      );
+    }
+  }
+  return cfg.encryptionKey ? new AgentKV({
+    ...base,
+    signer: privateKeySigner(privateKey),
+    encryptionKey: cfg.encryptionKey
+  }) : new AgentKV({ ...base, privateKey });
+}
+
+// src/onramp.ts
+function coinbaseNetworkName(network) {
+  const n = network.trim().toLowerCase();
+  if (n === "base" || n === "eip155:8453" || n === "8453") {
+    return "base";
+  }
+  if (n === "eip155:84532" || n === "84532") {
+    throw new Error(
+      `Coinbase Onramp supports Base mainnet only; no onramp is available for the configured testnet network (${network}). Fund a testnet account from a testnet faucet + a signing wallet instead.`
+    );
+  }
+  throw new Error(
+    `coinbase onramp supports Base only; got network ${JSON.stringify(network)}. AgentKV uses Base (eip155:8453) \u2014 set AGENTKV_NETWORK accordingly.`
+  );
+}
+var CoinbaseOnramp = class {
+  id = "coinbase";
+  name = "Coinbase Onramp";
+  buildUrl(opts) {
+    const appId = opts.config.appId?.trim();
+    if (!appId) {
+      throw new Error(
+        "coinbase onramp requires a CDP project id \u2014 set AGENTKV_ONRAMP_APP_ID (or --onramp-app-id) to the App/Project ID from https://portal.cdp.coinbase.com (Onramp \u2192 your project)."
+      );
+    }
+    const networkName = coinbaseNetworkName(opts.network);
+    const url = new URL("https://pay.coinbase.com/buy/select-asset");
+    url.searchParams.set("appId", appId);
+    url.searchParams.set("addresses", JSON.stringify({ [opts.address]: [networkName] }));
+    url.searchParams.set("defaultNetwork", networkName);
+    url.searchParams.set("defaultAsset", "USDC");
+    url.searchParams.set("assets", JSON.stringify(["USDC"]));
+    if (opts.amountUsd !== void 0 && Number.isFinite(opts.amountUsd) && opts.amountUsd > 0) {
+      const cents = Math.round(opts.amountUsd * 100 * (1 + Number.EPSILON));
+      if (cents === 0) {
+        throw new Error(
+          `amount ${opts.amountUsd} is below the $0.01 minimum an onramp can pre-fill; use an amount of at least $0.01.`
+        );
+      }
+      url.searchParams.set("presetFiatAmount", (cents / 100).toString());
+    }
+    return url.toString();
+  }
+};
+var PROVIDERS = {
+  coinbase: new CoinbaseOnramp()
+};
+function getOnrampProvider(id) {
+  const provider = PROVIDERS[id];
+  if (!provider) {
+    const known = Object.keys(PROVIDERS).sort().join(", ");
+    throw new Error(`unknown onramp provider ${JSON.stringify(id)}; known providers: ${known}`);
+  }
+  return provider;
+}
+
+// src/secrets.ts
+import { spawn } from "child_process";
+import {
+  closeSync,
+  fchmodSync,
+  lstatSync,
+  mkdtempSync,
+  openSync,
+  readFileSync as readFileSync3,
+  realpathSync,
+  writeSync
+} from "fs";
+import { tmpdir } from "os";
+import { join as join3, resolve as resolvePath, sep } from "path";
+var MAX_SECRET_BYTES = 1024 * 1024;
+var SENSITIVE_ENV = [
+  "AGENTKV_PRIVATE_KEY",
+  "AGENTKV_ENCRYPTION_KEY",
+  "AGENTKV_ACCOUNT_KEY",
+  "AGENTKV_PAYER_KEY"
+  // funded external-payer key (account fund / --from-key) — holds real USDC
+];
+var SENSITIVE_ENV_PATTERN = /^AGENTKV_.*(PRIVATE_KEY|PAYER_KEY|ENCRYPTION_KEY|MNEMONIC|SEED_PHRASE)$/i;
+function isSensitiveEnvName(name) {
+  return SENSITIVE_ENV.includes(name) || SENSITIVE_ENV_PATTERN.test(name);
+}
+function scrubSensitiveEnv(env = process.env) {
+  for (const k of Object.keys(env)) {
+    if (isSensitiveEnvName(k)) delete env[k];
+  }
+}
+function readEnvSecret(envVar) {
+  if (isSensitiveEnvName(envVar)) {
+    return {
+      ok: false,
+      error: `refusing to read protected key material from ${envVar}`,
+      code: "forbidden_env"
+    };
+  }
+  const value = process.env[envVar];
+  if (value === void 0 || value === "") {
+    return { ok: false, error: `env var ${envVar} is unset or empty`, code: "env_unset" };
+  }
+  return { ok: true, value };
+}
+function readFileSecret(path, opts = {}) {
+  const isPseudoFs = (p) => /^(\/proc|\/sys)(\/|$)/.test(p);
+  const pseudoFsRefusal = {
+    ok: false,
+    error: "refusing to read from a pseudo-filesystem path",
+    code: "forbidden_path"
+  };
+  if (isPseudoFs(path)) return pseudoFsRefusal;
+  let resolved;
+  try {
+    resolved = realpathSync(path);
+  } catch {
+    return { ok: false, error: "could not read file", code: "read_failed" };
+  }
+  if (isPseudoFs(resolved)) return pseudoFsRefusal;
+  const within = (child, parent) => child === parent || child.startsWith(parent.endsWith(sep) ? parent : parent + sep);
+  const keystore = agentkvDir(process.env);
+  let keystoreReal = resolvePath(keystore);
+  try {
+    keystoreReal = realpathSync(keystore);
+  } catch {
+  }
+  if (within(resolved, keystoreReal) || within(resolved, resolvePath(keystore))) {
+    return {
+      ok: false,
+      error: "refusing to read from the AgentKV keystore directory",
+      code: "forbidden_path"
+    };
+  }
+  let st;
+  try {
+    st = lstatSync(resolved);
+  } catch {
+    return { ok: false, error: "could not read file", code: "read_failed" };
+  }
+  if (!st.isFile()) {
+    return { ok: false, error: "not a regular file", code: "not_regular_file" };
+  }
+  if (st.size > MAX_SECRET_BYTES) {
+    return { ok: false, error: "file too large for a secret", code: "file_too_large" };
+  }
+  let value;
+  try {
+    value = readFileSync3(resolved, "utf8");
+  } catch {
+    return { ok: false, error: "could not read file", code: "read_failed" };
+  }
+  if (opts.trim !== false) value = value.replace(/\r?\n$/, "");
+  return { ok: true, value };
+}
+function writeSecretFile(value, dest) {
+  const path = dest ?? join3(mkdtempSync(join3(tmpdir(), "agentkv-")), "value");
+  const fd = openSync(path, "wx", 384);
+  try {
+    if (process.platform !== "win32") fchmodSync(fd, 384);
+    writeSync(fd, value, null, "utf8");
+  } finally {
+    closeSync(fd);
+  }
+  return { path, bytes: Buffer.byteLength(value, "utf8") };
+}
+var HIJACK_ENV = /^(LD_|DYLD_|PYTHON|PERL5?|RUBY(OPT|LIB)|NODE_OPTIONS$|NODE_PATH$|NODE_EXTRA_CA_CERTS$|BASH_ENV$|BASH_FUNC_|ENV$|IFS$|PATH$|CDPATH$|GCONV_PATH$|LOCPATH$|NLSPATH$|MALLOC_|PROMPT_COMMAND$|PS4$|GIT_SSH|GIT_PROXY_COMMAND$|GIT_EXTERNAL_DIFF$|GIT_CONFIG|GIT_SSL_CAINFO$|GIT_SSL_NO_VERIFY$|SSL_CERT|.*CA_BUNDLE$|CLASSPATH$|_?JAVA_OPTIONS$|JDK_JAVA_OPTIONS$|JAVA_TOOL_OPTIONS$|COR(ECLR)?_PROFILER$|DOTNET_STARTUP_HOOKS$|WINEDLLOVERRIDES$|PAGER$|EDITOR$|BROWSER$|.*_PROXY$)/i;
+var ENV_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function forbiddenEnvKey(keys) {
+  return keys.find((k) => !ENV_NAME.test(k) || HIJACK_ENV.test(k)) ?? null;
+}
+function runWithSecret(opts) {
+  const cap = opts.capBytes ?? 64 * 1024;
+  const timeoutMs = opts.timeoutMs && opts.timeoutMs > 0 ? opts.timeoutMs : 12e4;
+  return new Promise((resolve, reject) => {
+    const bad = forbiddenEnvKey([opts.envVar, ...Object.keys(opts.extraEnv ?? {})]);
+    if (bad) {
+      reject(new Error(`refusing to set process-hijack env var: ${bad}`));
+      return;
+    }
+    const inherited = { ...process.env };
+    for (const k of Object.keys(inherited)) {
+      if (isSensitiveEnvName(k)) inherited[k] = void 0;
+    }
+    const child = spawn(opts.command, opts.args ?? [], {
+      cwd: opts.cwd,
+      env: { ...inherited, ...opts.extraEnv, [opts.envVar]: opts.secret },
+      shell: false,
+      timeout: timeoutMs,
+      killSignal: "SIGKILL",
+      // the built-in timeout sends a SIGTERM a child can ignore — escalate
+      stdio: ["ignore", "pipe", "pipe"]
+      // no stdin: stdin-reading commands get EOF, don't hang
+    });
+    const outChunks = [];
+    const errChunks = [];
+    let outBytes = 0;
+    let errBytes = 0;
+    let truncated = false;
+    let settled = false;
+    const finalize = (code) => ({
+      exit_code: code,
+      stdout: Buffer.concat(outChunks).subarray(0, cap).toString("utf8"),
+      stderr: Buffer.concat(errChunks).subarray(0, cap).toString("utf8"),
+      truncated
+    });
+    const done = (cb) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(hard);
+      cb();
+    };
+    const hard = setTimeout(() => {
+      try {
+        child.kill("SIGKILL");
+      } catch {
+      }
+      truncated = true;
+      done(() => resolve(finalize(null)));
+    }, timeoutMs + 5e3);
+    child.stdout?.on("data", (d) => {
+      if (outBytes >= cap) {
+        truncated = true;
+        return;
+      }
+      outChunks.push(d);
+      outBytes += d.length;
+      if (outBytes > cap) truncated = true;
+    });
+    child.stderr?.on("data", (d) => {
+      if (errBytes >= cap) {
+        truncated = true;
+        return;
+      }
+      errChunks.push(d);
+      errBytes += d.length;
+      if (errBytes > cap) truncated = true;
+    });
+    child.on("error", (e) => done(() => reject(e)));
+    child.on("close", (code) => done(() => resolve(finalize(code))));
+  });
+}
+
+// src/version.ts
+var VERSION = "0.1.0";
+
+export {
+  agentkvDir,
+  accountPath,
+  peekStoredWallet,
+  getOrCreateStoredWallet,
+  peekStoredAccount,
+  createStoredAccount,
+  readConfigFile,
+  resolveConfig,
+  clientFromConfig,
+  getOnrampProvider,
+  scrubSensitiveEnv,
+  readEnvSecret,
+  readFileSecret,
+  writeSecretFile,
+  forbiddenEnvKey,
+  runWithSecret,
+  VERSION
+};