@vapi-network/core 0.5.0 → 0.8.0

package/dist/secrets.js

@@ -2212,7 +2212,7 @@ function weierstrass(curveDef) {
   function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
     if (["recovered", "canonical"].some((k) => k in opts))
       throw new Error("sign() legacy options not supported");
-    const { hash: hash2, randomBytes: randomBytes3 } = CURVE;
+    const { hash: hash2, randomBytes: randomBytes5 } = CURVE;
     let { lowS, prehash, extraEntropy: ent } = opts;
     if (lowS == null)
       lowS = true;
@@ -2224,7 +2224,7 @@ function weierstrass(curveDef) {
     const d = normPrivateKeyToScalar(privateKey);
     const seedArgs = [int2octets(d), int2octets(h1int)];
     if (ent != null && ent !== false) {
-      const e2 = ent === true ? randomBytes3(Fp.BYTES) : ent;
+      const e2 = ent === true ? randomBytes5(Fp.BYTES) : ent;
       seedArgs.push(ensureBytes("extraEntropy", e2));
     }
     const seed = concatBytes2(...seedArgs);
@@ -2793,16 +2793,16 @@ function hexToBytes3(hex_, opts = {}) {
     assertSize(hex3, { size: opts.size });
     hex3 = pad(hex3, { dir: "right", size: opts.size });
   }
-  let hexString = hex3.slice(2);
-  if (hexString.length % 2)
-    hexString = `0${hexString}`;
-  const length = hexString.length / 2;
+  let hexString2 = hex3.slice(2);
+  if (hexString2.length % 2)
+    hexString2 = `0${hexString2}`;
+  const length = hexString2.length / 2;
   const bytes = new Uint8Array(length);
   for (let index = 0, j = 0; index < length; index++) {
-    const nibbleLeft = charCodeToBase16(hexString.charCodeAt(j++));
-    const nibbleRight = charCodeToBase16(hexString.charCodeAt(j++));
+    const nibbleLeft = charCodeToBase16(hexString2.charCodeAt(j++));
+    const nibbleRight = charCodeToBase16(hexString2.charCodeAt(j++));
     if (nibbleLeft === void 0 || nibbleRight === void 0) {
-      throw new BaseError(`Invalid byte sequence ("${hexString[j - 2]}${hexString[j - 1]}" in "${hexString}").`);
+      throw new BaseError(`Invalid byte sequence ("${hexString2[j - 2]}${hexString2[j - 1]}" in "${hexString2}").`);
     }
     bytes[index] = nibbleLeft * 16 + nibbleRight;
   }
@@ -4273,9 +4273,9 @@ var init_stringify = __esm({
 });
 
 // src/keystore.ts
-import { createCipheriv, createDecipheriv, randomBytes as randomBytes2, scrypt } from "node:crypto";
-import { mkdir as mkdir2, readFile as readFile2, rename as rename2, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname2 } from "node:path";
+import { createCipheriv, createDecipheriv, randomBytes as randomBytes3, scrypt } from "node:crypto";
+import { mkdir as mkdir3, readFile as readFile3, rename as rename3, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname3 } from "node:path";
 
 // ../../node_modules/.pnpm/@solana+errors@5.5.1_typescript@6.0.3/node_modules/@solana/errors/dist/index.node.mjs
 var SOLANA_ERROR__BLOCK_HEIGHT_EXCEEDED = 1;
@@ -46542,13 +46542,232 @@ function date4(params) {
 
 // src/config.ts
 import { constants } from "node:fs";
-import { copyFile, mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
+import { copyFile, mkdir as mkdir2, readFile as readFile2, rename as rename2, stat as stat2, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, join as join2 } from "node:path";
+import { dirname as dirname2, join as join3 } from "node:path";
 
 // ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/index.js
 init_getAddress();
 
+// src/atomic-file.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { link, mkdir, open as open2, readdir, readFile, rename, stat, unlink } from "node:fs/promises";
+import { basename, dirname, join as join2 } from "node:path";
+var DEFAULT_LOCK_TIMEOUT_MS = 2e3;
+var LOCK_RETRY_MS = 20;
+var LOCK_STALE_AFTER_MS = 12e4;
+var LOCK_HEARTBEAT_MS = 3e4;
+var atomicFileTestHooks;
+var FileLockedError = class extends Error {
+  constructor(message = "Timed out waiting for the file lock.") {
+    super(message);
+    this.name = "FileLockedError";
+  }
+};
+async function withFileLock(lockPath, fn, options = {}) {
+  await mkdir(dirname(lockPath), { recursive: true, mode: 448 });
+  const deadline = Date.now() + (options.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS);
+  const ownerRecord = {
+    pid: process.pid,
+    token: randomBytes2(16).toString("hex")
+  };
+  const owner = JSON.stringify(ownerRecord);
+  const releasedOwner = JSON.stringify({ ...ownerRecord, released: true });
+  let handle;
+  while (handle === void 0) {
+    await atomicFileTestHooks?.beforeLockAttempt?.(lockPath);
+    try {
+      const candidate = await open2(lockPath, "wx", 384);
+      try {
+        await candidate.writeFile(owner, "utf8");
+        await candidate.sync();
+        await atomicFileTestHooks?.afterLockCreate?.(lockPath);
+        if (await lockTakeoverInProgress(lockPath)) {
+          await candidate.close();
+          await removeOwnedLock(lockPath, [owner]);
+          await removeAbandonedLockTombs(lockPath);
+          if (Date.now() >= deadline) {
+            throw new FileLockedError(options.lockedMessage);
+          }
+          await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS));
+          continue;
+        }
+        handle = candidate;
+      } catch (error61) {
+        await candidate.close().catch(() => void 0);
+        await removeOwnedLock(lockPath, [owner]).catch(() => void 0);
+        throw error61;
+      }
+    } catch (error61) {
+      if (!hasCode(error61, "EEXIST")) throw error61;
+      await removeStaleLock(lockPath);
+      if (Date.now() >= deadline) {
+        throw new FileLockedError(options.lockedMessage);
+      }
+      await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS));
+    }
+  }
+  const ownedHandle = handle;
+  const heartbeat = setInterval(() => {
+    const time3 = /* @__PURE__ */ new Date();
+    void ownedHandle.utimes(time3, time3).catch(() => void 0);
+  }, LOCK_HEARTBEAT_MS);
+  heartbeat.unref();
+  try {
+    return await fn();
+  } finally {
+    clearInterval(heartbeat);
+    try {
+      await markLockReleased(ownedHandle, releasedOwner);
+    } finally {
+      try {
+        await ownedHandle.close();
+      } finally {
+        await removeOwnedLock(lockPath, [owner, releasedOwner]);
+      }
+    }
+  }
+}
+async function removeStaleLock(path) {
+  try {
+    const owner = await readFile(path, "utf8");
+    if (lockOwnerReleased(owner)) {
+      await removeOwnedLock(path, [owner]);
+      return;
+    }
+    const metadata = await stat(path);
+    if (Date.now() - metadata.mtimeMs <= LOCK_STALE_AFTER_MS) return;
+    const pid = lockOwnerPid(owner);
+    if (pid !== void 0 && processIsAlive(pid)) return;
+    await atomicFileTestHooks?.beforeStaleLockBreak?.(path);
+    await removeOwnedLock(path, [owner]);
+  } catch (error61) {
+    if (!hasCode(error61, "ENOENT")) throw error61;
+  }
+}
+async function removeOwnedLock(path, owners) {
+  const tombPath = `${path}.stale.${randomBytes2(16).toString("hex")}`;
+  try {
+    await rename(path, tombPath);
+  } catch (error61) {
+    if (hasCode(error61, "ENOENT")) {
+      await removeOwnedTombs(path, owners);
+      const currentOwner = await readFile(path, "utf8").catch(() => void 0);
+      if (currentOwner !== void 0 && owners.includes(currentOwner)) {
+        await removeOwnedLock(path, owners);
+      }
+      return;
+    }
+    throw error61;
+  }
+  let pendingError;
+  try {
+    const renamedOwner = await readFile(tombPath, "utf8");
+    if (!owners.includes(renamedOwner) && !lockOwnerReleased(renamedOwner)) {
+      await atomicFileTestHooks?.afterMismatchedLockRename?.(path);
+      const currentOwner = await readFile(tombPath, "utf8");
+      if (!lockOwnerReleased(currentOwner)) await restoreRenamedLock(path, tombPath);
+      await atomicFileTestHooks?.afterMismatchedLockRestore?.(path);
+    }
+  } catch (error61) {
+    pendingError = error61;
+  }
+  try {
+    await unlink(tombPath);
+  } catch (error61) {
+    if (!hasCode(error61, "ENOENT") && pendingError === void 0) {
+      pendingError = error61;
+    }
+  }
+  if (pendingError !== void 0) throw pendingError;
+}
+async function lockTakeoverInProgress(path) {
+  const prefix = `${basename(path)}.stale.`;
+  return (await readdir(dirname(path))).some((entry) => entry.startsWith(prefix));
+}
+async function removeAbandonedLockTombs(path) {
+  const directory = dirname(path);
+  const prefix = `${basename(path)}.stale.`;
+  for (const entry of await readdir(directory)) {
+    if (!entry.startsWith(prefix)) continue;
+    const tombPath = join2(directory, entry);
+    const [metadata, owner] = await Promise.all([
+      stat(tombPath).catch(() => void 0),
+      readFile(tombPath, "utf8").catch(() => void 0)
+    ]);
+    if (metadata === void 0 || owner === void 0) continue;
+    const pid = lockOwnerPid(owner);
+    const abandoned = lockOwnerReleased(owner) || Date.now() - metadata.mtimeMs > LOCK_STALE_AFTER_MS && (pid === void 0 || !processIsAlive(pid));
+    if (!abandoned) continue;
+    await unlink(tombPath).catch((error61) => {
+      if (!hasCode(error61, "ENOENT")) throw error61;
+    });
+  }
+}
+async function removeOwnedTombs(path, owners) {
+  const directory = dirname(path);
+  const prefix = `${basename(path)}.stale.`;
+  for (const entry of await readdir(directory)) {
+    if (!entry.startsWith(prefix)) continue;
+    const tombPath = join2(directory, entry);
+    const owner = await readFile(tombPath, "utf8").catch(() => void 0);
+    if (owner === void 0 || !owners.includes(owner)) continue;
+    await unlink(tombPath).catch((error61) => {
+      if (!hasCode(error61, "ENOENT")) throw error61;
+    });
+  }
+}
+async function restoreRenamedLock(path, tombPath) {
+  while (true) {
+    try {
+      await link(tombPath, path);
+      return;
+    } catch (error61) {
+      if (hasCode(error61, "ENOENT")) return;
+      if (!hasCode(error61, "EEXIST")) throw error61;
+      await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS));
+    }
+  }
+}
+async function markLockReleased(handle, owner) {
+  const contents = Buffer.from(owner, "utf8");
+  await handle.write(contents, 0, contents.length, 0);
+  await handle.truncate(contents.length);
+  await handle.sync();
+}
+function lockOwnerPid(owner) {
+  try {
+    const value = JSON.parse(owner);
+    if (typeof value !== "object" || value === null) return void 0;
+    const pid = Reflect.get(value, "pid");
+    return typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function lockOwnerReleased(owner) {
+  try {
+    const value = JSON.parse(owner);
+    return typeof value === "object" && value !== null && Reflect.get(value, "released") === true;
+  } catch {
+    return false;
+  }
+}
+function processIsAlive(pid) {
+  if (atomicFileTestHooks?.isProcessAlive !== void 0) {
+    return atomicFileTestHooks.isProcessAlive(pid);
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error61) {
+    return hasCode(error61, "EPERM");
+  }
+}
+function hasCode(error61, code) {
+  return error61 instanceof Error && "code" in error61 && error61.code === code;
+}
+
 // src/x402-networks.ts
 var BASE_MAINNET_CAIP2 = "eip155:8453";
 var ARC_MAINNET_CAIP2 = "eip155:5042";
@@ -46592,6 +46811,205 @@ var BROWSER_ENABLED_X402_NETWORK_CONFIG = Object.freeze({
   [ARC_TESTNET_CAIP2]: browserNetwork(arcTestnetUsdc)
 });
 
+// src/net-guard.ts
+import { lookup as dnsLookup } from "node:dns/promises";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { isIP } from "node:net";
+import { Readable } from "node:stream";
+var defaultLookup = async (hostname3) => {
+  const addresses = await dnsLookup(hostname3, { all: true });
+  return addresses.map(({ address }) => address);
+};
+async function assertPublicUrl(url2, options) {
+  if (url2.username || url2.password) {
+    throw guardError(url2);
+  }
+  if (url2.protocol !== "http:" && url2.protocol !== "https:") {
+    throw guardError(url2);
+  }
+  if (options.allowPrivateNetwork) {
+    return;
+  }
+  const hostname3 = normalizeHostname(url2.hostname);
+  const lowercaseHostname = hostname3.toLowerCase();
+  if (!lowercaseHostname || lowercaseHostname === "localhost" || lowercaseHostname.endsWith(".localhost") || lowercaseHostname.endsWith(".local") || lowercaseHostname.endsWith(".internal")) {
+    throw guardError(url2);
+  }
+  if (isIP(hostname3)) {
+    if (isNonPublicAddress(hostname3)) {
+      throw guardError(url2);
+    }
+    return;
+  }
+  let addresses;
+  try {
+    addresses = await withTimeout(
+      (options.lookup ?? defaultLookup)(hostname3),
+      options.timeoutMs ?? 5e3
+    );
+  } catch {
+    throw guardError(url2);
+  }
+  if (addresses.length === 0 || addresses.some(isNonPublicAddress)) {
+    throw guardError(url2);
+  }
+}
+function createPublicFetch(options) {
+  const lookupFn = options.lookup ?? defaultLookup;
+  return (async (input2, init) => {
+    const url2 = new URL(input2 instanceof Request ? input2.url : input2);
+    await assertPublicUrl(url2, {
+      allowPrivateNetwork: options.allowPrivateNetwork,
+      lookup: lookupFn,
+      timeoutMs: 5e3
+    });
+    const normalized = new Request(input2, init);
+    const bytes = normalized.body ? Buffer.from(await normalized.arrayBuffer()) : null;
+    return await new Promise((resolve, reject) => {
+      const requestOptions = {
+        method: normalized.method,
+        headers: Object.fromEntries(normalized.headers),
+        signal: normalized.signal,
+        ...options.allowPrivateNetwork ? {} : { lookup: pinnedLookup(lookupFn) }
+      };
+      const onResponse = (incoming) => {
+        try {
+          const headers = new Headers();
+          for (const [name, value] of Object.entries(incoming.headers)) {
+            if (Array.isArray(value)) {
+              for (const item of value) headers.append(name, item);
+            } else if (value !== void 0) {
+              headers.set(name, value);
+            }
+          }
+          const status = incoming.statusCode ?? 500;
+          const bodyForbidden = normalized.method === "HEAD" || [204, 205, 304].includes(status);
+          if (bodyForbidden) incoming.resume();
+          const response = new Response(
+            bodyForbidden ? null : Readable.toWeb(incoming),
+            { status, statusText: incoming.statusMessage, headers }
+          );
+          Object.defineProperty(response, "url", { value: url2.toString() });
+          resolve(response);
+        } catch (error61) {
+          incoming.destroy();
+          reject(error61);
+        }
+      };
+      const request = url2.protocol === "https:" ? httpsRequest(url2, requestOptions, onResponse) : httpRequest(url2, requestOptions, onResponse);
+      request.on("error", reject);
+      if (bytes) request.write(bytes);
+      request.end();
+    });
+  });
+}
+function pinnedLookup(lookup) {
+  return (hostname3, dnsOptions, callback) => {
+    void lookup(normalizeHostname(hostname3)).then((addresses) => {
+      if (addresses.length === 0 || addresses.some(isNonPublicAddress)) {
+        callback(guardError(new URL(`https://${hostname3}`)), "");
+        return;
+      }
+      const address = addresses[0];
+      const family = isIP(address);
+      callback(
+        null,
+        dnsOptions.all ? [{ address, family }] : address,
+        dnsOptions.all ? void 0 : family
+      );
+    }).catch(
+      (error61) => callback(error61 instanceof Error ? error61 : new Error("DNS lookup failed."), "")
+    );
+  };
+}
+async function withTimeout(operation, timeoutMs) {
+  let timeout;
+  try {
+    return await Promise.race([
+      operation,
+      new Promise((_resolve, reject) => {
+        timeout = setTimeout(() => reject(new Error("DNS lookup timed out.")), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+function normalizeHostname(hostname3) {
+  const unbracketed = hostname3.startsWith("[") && hostname3.endsWith("]") ? hostname3.slice(1, -1) : hostname3;
+  return unbracketed.endsWith(".") ? unbracketed.slice(0, -1) : unbracketed;
+}
+function isNonPublicAddress(address) {
+  const normalized = normalizeHostname(address);
+  const version3 = isIP(normalized);
+  if (version3 === 4) {
+    return isNonPublicIpv4(parseIpv4(normalized));
+  }
+  if (version3 === 6) {
+    return isNonPublicIpv6(parseIpv6(normalized));
+  }
+  return true;
+}
+function parseIpv4(address) {
+  const octets = address.split(".").map(Number);
+  return [octets[0], octets[1], octets[2], octets[3]];
+}
+function isNonPublicIpv4([first, second, third]) {
+  return first === 0 || first === 10 || first === 100 && second >= 64 && second <= 127 || first === 127 || first === 169 && second === 254 || first === 172 && second >= 16 && second <= 31 || first === 192 && second === 0 && (third === 0 || third === 2) || first === 192 && second === 168 || first === 198 && second >= 18 && second <= 19 || first === 198 && second === 51 && third === 100 || first === 203 && second === 0 && third === 113 || first >= 224;
+}
+function parseIpv6(address) {
+  let normalized = address.toLowerCase();
+  const lastColon = normalized.lastIndexOf(":");
+  const dottedTail = normalized.slice(lastColon + 1);
+  if (dottedTail.includes(".")) {
+    const [first, second, third, fourth] = parseIpv4(dottedTail);
+    normalized = `${normalized.slice(0, lastColon + 1)}${(first << 8 | second).toString(16)}:${(third << 8 | fourth).toString(16)}`;
+  }
+  const halves = normalized.split("::");
+  const left = halves[0] ? halves[0].split(":").map(parseHex) : [];
+  const right = halves[1] ? halves[1].split(":").map(parseHex) : [];
+  const omittedCount = 8 - left.length - right.length;
+  return halves.length === 2 ? [...left, ...Array.from({ length: omittedCount }, () => 0), ...right] : left;
+}
+function parseHex(value) {
+  return Number.parseInt(value, 16);
+}
+function isNonPublicIpv6(hextets) {
+  if (hextets.slice(0, 5).every((hextet) => hextet === 0) && hextets[5] === 65535) {
+    const embeddedIpv4 = [
+      hextets[6] >> 8,
+      hextets[6] & 255,
+      hextets[7] >> 8,
+      hextets[7] & 255
+    ];
+    return isNonPublicIpv4(embeddedIpv4);
+  }
+  if (hextets.slice(0, 6).every((hextet) => hextet === 0)) {
+    const compatibleIpv4 = [
+      hextets[6] >> 8,
+      hextets[6] & 255,
+      hextets[7] >> 8,
+      hextets[7] & 255
+    ];
+    if (isNonPublicIpv4(compatibleIpv4)) return true;
+  }
+  const isUnspecified = hextets.every((hextet) => hextet === 0);
+  const isLoopback = hextets.slice(0, 7).every((hextet) => hextet === 0) && hextets[7] === 1;
+  const first = hextets[0];
+  const isUniqueLocal = first >= 64512 && first <= 65023;
+  const isLinkLocal = first >= 65152 && first <= 65215;
+  const isSiteLocal = first >= 65216 && first <= 65279;
+  const isMulticast = first >= 65280;
+  const isDocumentation = first === 8193 && hextets[1] === 3512;
+  return isUnspecified || isLoopback || isUniqueLocal || isLinkLocal || isSiteLocal || isMulticast || isDocumentation;
+}
+function guardError(url2) {
+  return new Error(
+    `URL hostname ${JSON.stringify(url2.hostname)} is not allowed; private or internal destinations require allowPrivateNetwork true in the vAPI config.`
+  );
+}
+
 // src/networks.ts
 var NETWORKS = {
   [BASE_MAINNET_CAIP2]: {
@@ -46601,7 +47019,8 @@ var NETWORKS = {
     usdc: CANONICAL_X402_USDC_NETWORKS[BASE_MAINNET_CAIP2].usdc,
     gasToken: "ETH",
     rpcEnv: "BASE_RPC_URL",
-    publicRpcUrl: "https://mainnet.base.org"
+    publicRpcUrl: "https://mainnet.base.org",
+    explorerUrl: "https://basescan.org"
   },
   [ARC_MAINNET_CAIP2]: {
     family: "evm",
@@ -46666,6 +47085,10 @@ function isSupportedPaymentNetwork(network) {
 var DEFAULT_REGISTRY_URL = "https://api.vapinetwork.ai";
 var DEFAULT_DISCOVERY_URL = `${DEFAULT_REGISTRY_URL}/api/call/services`;
 var DEFAULT_MARKETPLACE_DISCOVERY_URL = `${DEFAULT_REGISTRY_URL}/api/call/discovery`;
+var DEFAULT_SPEND_CAPS = {
+  perCallAtomic: "100000",
+  perDayAtomic: "1000000"
+};
 var atomicString = external_exports.string().regex(/^\d+$/, "Expected non-negative atomic units.");
 var spendCapsSchema = external_exports.object({
   perCallAtomic: atomicString,
@@ -46696,7 +47119,8 @@ var configSchema = external_exports.object({
       }).optional()
     })
   ),
-  spendCaps: spendCapsSchema
+  spendCaps: spendCapsSchema,
+  device: external_exports.string().regex(/^[a-z0-9][a-z0-9-]{0,31}$/).optional()
 }).superRefine((config2, context) => {
   for (const [network, configured] of Object.entries(config2.networks)) {
     if (isSolanaNetwork(network)) {
@@ -46727,22 +47151,22 @@ var configSchema = external_exports.object({
     }
   }
 });
-function getVapiPaths(directory = process.env.VAPI_HOME?.trim() || join2(homedir(), ".vapi")) {
+function getVapiPaths(directory = process.env.VAPI_HOME?.trim() || join3(homedir(), ".vapi")) {
   return {
     directory,
-    agentsDir: join2(directory, "agents"),
-    config: join2(directory, "config.json"),
-    keystore: join2(directory, "keystore.json"),
-    receipts: join2(directory, "receipts.jsonl"),
-    searches: join2(directory, "searches.jsonl"),
-    ledger: join2(directory, "spend-ledger.json")
+    agentsDir: join3(directory, "agents"),
+    config: join3(directory, "config.json"),
+    keystore: join3(directory, "keystore.json"),
+    receipts: join3(directory, "receipts.jsonl"),
+    searches: join3(directory, "searches.jsonl"),
+    ledger: join3(directory, "spend-ledger.json")
   };
 }
 async function migrateLegacyVapiHome(options = {}) {
   const target = getVapiPaths(options.targetDirectory);
-  const legacyDirectory = options.legacyDirectory ?? join2(homedir(), ".vapi", "agent-cash");
+  const legacyDirectory = options.legacyDirectory ?? join3(homedir(), ".vapi", "agent-cash");
   if (legacyDirectory === target.directory || !await pathExists(legacyDirectory)) return [];
-  await mkdir(target.directory, { recursive: true, mode: 448 });
+  await mkdir2(target.directory, { recursive: true, mode: 448 });
   const copied = [];
   for (const filename of [
     "config.json",
@@ -46751,10 +47175,17 @@ async function migrateLegacyVapiHome(options = {}) {
     "searches.jsonl",
     "spend-ledger.json"
   ]) {
-    const source = join2(legacyDirectory, filename);
-    const destination = join2(target.directory, filename);
+    const source = join3(legacyDirectory, filename);
+    const destination = join3(target.directory, filename);
     try {
-      await copyFile(source, destination, constants.COPYFILE_EXCL);
+      const copy = async () => await copyFile(source, destination, constants.COPYFILE_EXCL);
+      if (filename === "receipts.jsonl") {
+        await withFileLock(`${destination}.lock`, copy, {
+          lockedMessage: "The receipt journal is busy. Wait for the other vapi command to finish, then retry."
+        });
+      } else {
+        await copy();
+      }
       copied.push(destination);
     } catch (error61) {
       if (isMissingFile(error61) || isAlreadyExists(error61)) continue;
@@ -46770,7 +47201,7 @@ async function migrateLegacyVapiHome(options = {}) {
 }
 async function pathExists(path) {
   try {
-    await stat(path);
+    await stat2(path);
     return true;
   } catch (error61) {
     if (isMissingFile(error61)) return false;
@@ -46937,7 +47368,34 @@ var KeystoreError = class extends Error {
     this.name = "KeystoreError";
   }
 };
-async function deriveKey(passphrase, salt) {
+function encryptWithKey(key, plaintext) {
+  if (key.byteLength !== KEY_LENGTH) {
+    throw new Error(`Expected a ${KEY_LENGTH}-byte AES-256-GCM key.`);
+  }
+  const nonce = randomBytes3(12);
+  const cipher = createCipheriv("aes-256-gcm", key, nonce, {
+    authTagLength: AUTH_TAG_LENGTH
+  });
+  const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  return { nonce, ciphertext, tag: cipher.getAuthTag() };
+}
+function decryptWithKey(key, sealed) {
+  if (key.byteLength !== KEY_LENGTH) {
+    throw new Error(`Expected a ${KEY_LENGTH}-byte AES-256-GCM key.`);
+  }
+  if (sealed.nonce.byteLength !== 12) {
+    throw new Error("Expected a 12-byte AES-GCM nonce.");
+  }
+  if (sealed.tag.byteLength !== AUTH_TAG_LENGTH) {
+    throw new Error(`Expected a ${AUTH_TAG_LENGTH}-byte AES-GCM authentication tag.`);
+  }
+  const decipher = createDecipheriv("aes-256-gcm", key, sealed.nonce, {
+    authTagLength: AUTH_TAG_LENGTH
+  });
+  decipher.setAuthTag(sealed.tag);
+  return Buffer.concat([decipher.update(sealed.ciphertext), decipher.final()]);
+}
+async function deriveScryptKey(passphrase, salt) {
   return await new Promise((resolve, reject) => {
     scrypt(
       passphrase,
@@ -46998,17 +47456,15 @@ async function sealPlaintext(plaintext, passphrase) {
   if (passphrase.length === 0) {
     throw new KeystoreError("Keystore passphrase cannot be empty.");
   }
-  const salt = randomBytes2(32);
-  const iv = randomBytes2(12);
-  const key = await deriveKey(passphrase, salt);
+  const salt = randomBytes3(32);
+  const key = await deriveScryptKey(passphrase, salt);
   try {
-    const cipher = createCipheriv("aes-256-gcm", key, iv, { authTagLength: AUTH_TAG_LENGTH });
-    const ciphertext = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+    const sealed = encryptWithKey(key, Buffer.from(plaintext, "utf8"));
     return {
       cipher: "aes-256-gcm",
-      ciphertext: ciphertext.toString("base64"),
-      iv: iv.toString("base64"),
-      authTag: cipher.getAuthTag().toString("base64"),
+      ciphertext: sealed.ciphertext.toString("base64"),
+      iv: sealed.nonce.toString("base64"),
+      authTag: sealed.tag.toString("base64"),
       kdf: "scrypt",
       salt: salt.toString("base64"),
       kdfParams: {
@@ -47036,19 +47492,14 @@ async function decryptSecret(keystore, passphrase) {
   const iv = Buffer.from(parsed.crypto.iv, "base64");
   const authTag = Buffer.from(parsed.crypto.authTag, "base64");
   const ciphertext = Buffer.from(parsed.crypto.ciphertext, "base64");
-  const key = await deriveKey(passphrase, salt);
+  const key = await deriveScryptKey(passphrase, salt);
   let unlocked;
   try {
-    if (authTag.length !== AUTH_TAG_LENGTH) {
-      throw new Error(`Expected a ${AUTH_TAG_LENGTH}-byte AES-GCM authentication tag.`);
-    }
-    const decipher = createDecipheriv("aes-256-gcm", key, iv, {
-      authTagLength: AUTH_TAG_LENGTH
-    });
-    decipher.setAuthTag(authTag);
-    const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString(
-      "utf8"
-    );
+    const plaintext = decryptWithKey(key, {
+      nonce: iv,
+      ciphertext,
+      tag: authTag
+    }).toString("utf8");
     unlocked = parsed.version === 3 ? keysFromEntropy(parsed, plaintext) : {
       keys: parsed.version === 1 ? { evm: `0x${plaintext}` } : encryptedKeysSchema.parse(JSON.parse(plaintext)).keys
     };
@@ -47123,7 +47574,7 @@ async function refuseExistingKeystore(path) {
     await migrateLegacyVapiHome({ targetDirectory: getVapiPaths().directory });
   }
   try {
-    await stat2(path);
+    await stat3(path);
     throw new KeystoreError(
       `Keystore already exists at ${path}. Refusing to replace the local payment key.`
     );
@@ -47133,10 +47584,19 @@ async function refuseExistingKeystore(path) {
     }
   }
 }
+function validatePrivateKey(value) {
+  const normalized = value.trim().toLowerCase();
+  if (!/^0x[0-9a-f]{64}$/u.test(normalized)) {
+    throw new KeystoreError(
+      "A private key is 0x followed by 64 hexadecimal characters. Check for a missing character."
+    );
+  }
+  return normalized;
+}
 async function readStoredKeystore(path) {
   let raw;
   try {
-    raw = await readFile2(path, "utf8");
+    raw = await readFile3(path, "utf8");
   } catch (error61) {
     if (isMissingFile(error61)) {
       throw new KeystoreError(`No vAPI keystore found at ${path}. Run vapi init.`);
@@ -47209,8 +47669,8 @@ async function createSolanaSigner(seed) {
   }
 }
 async function writeKeystore(path, keystore, exclusive) {
-  await mkdir2(dirname2(path), { recursive: true, mode: 448 });
-  const temporaryPath = `${path}.${process.pid}.${randomBytes2(6).toString("hex")}.tmp`;
+  await mkdir3(dirname3(path), { recursive: true, mode: 448 });
+  const temporaryPath = `${path}.${process.pid}.${randomBytes3(6).toString("hex")}.tmp`;
   await writeFile2(temporaryPath, `${JSON.stringify(keystore, null, 2)}
 `, {
     encoding: "utf8",
@@ -47219,7 +47679,7 @@ async function writeKeystore(path, keystore, exclusive) {
   });
   if (exclusive) {
     try {
-      await stat2(path);
+      await stat3(path);
       throw new KeystoreError(
         `Keystore already exists at ${path}. Refusing to replace the local payment key.`
       );
@@ -47227,12 +47687,935 @@ async function writeKeystore(path, keystore, exclusive) {
       if (!isMissingFile(error61)) throw error61;
     }
   }
-  await rename2(temporaryPath, path);
+  await rename3(temporaryPath, path);
+}
+
+// src/vault.ts
+import { randomBytes as randomBytes4 } from "node:crypto";
+import { mkdir as mkdir4, open as open3, readFile as readFile4, rename as rename4, rm, stat as stat4, unlink as unlink2, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname4 } from "node:path";
+
+// src/wallet-name.ts
+var WALLET_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,31}$/;
+var walletNameSchema = external_exports.string().regex(
+  WALLET_NAME_PATTERN,
+  "A wallet name is 1 to 32 characters of lowercase letters, digits and dashes, starting with a letter or digit."
+);
+function isWalletName(value) {
+  return WALLET_NAME_PATTERN.test(value);
+}
+
+// src/vault.ts
+var VaultError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "VaultError";
+    this.code = code;
+  }
+};
+var SEALED_FIELD_PATTERN = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/u;
+var WRAPPED_KEY_PATTERN = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/u;
+var ADDRESS_PATTERN = /^0x[0-9a-fA-F]{40}$/u;
+var VAULT_LOCK_TIMEOUT_MS = 2e3;
+var STALE_VAULT_LOCK_MS = 3e4;
+var sealedFieldSchema = external_exports.string().regex(SEALED_FIELD_PATTERN);
+var addressSchema = external_exports.string().regex(ADDRESS_PATTERN);
+var accountFields = {
+  name: walletNameSchema,
+  address: addressSchema,
+  createdAt: external_exports.string()
+};
+var storedAccountSchema = external_exports.discriminatedUnion("kind", [
+  external_exports.object({
+    ...accountFields,
+    kind: external_exports.literal("derived"),
+    index: external_exports.number().int().nonnegative().refine(Number.isSafeInteger, "Derived account index must be a safe integer.")
+  }).strict(),
+  external_exports.object({
+    ...accountFields,
+    kind: external_exports.literal("imported"),
+    key: sealedFieldSchema
+  }).strict()
+]);
+var vaultFileSchema = external_exports.object({
+  version: external_exports.literal(2),
+  kdf: external_exports.literal("device-key"),
+  cipher: external_exports.literal("aes-256-gcm"),
+  phrase: sealedFieldSchema,
+  accounts: external_exports.array(storedAccountSchema),
+  nextDerivedIndex: external_exports.number().int().nonnegative().refine(Number.isSafeInteger, "Next derived account index must be a safe integer.").optional(),
+  protected: external_exports.boolean(),
+  wrappedKey: external_exports.string().regex(WRAPPED_KEY_PATTERN).optional()
+}).strict();
+var DeviceVault = class {
+  file;
+  path;
+  key;
+  balanceOf;
+  now;
+  constructor(options, file2) {
+    this.path = options.path;
+    this.key = options.key;
+    this.balanceOf = options.balanceOf;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.file = file2;
+  }
+  accounts() {
+    return this.file.accounts.map(copyAccount);
+  }
+  async deriveAccount(name) {
+    try {
+      return await this.update(async (file2) => {
+        assertAvailableName(file2, name);
+        const index = nextDerivedIndex(file2);
+        const plaintext = decryptField(this.key, file2.phrase);
+        let seed;
+        let address;
+        try {
+          seed = phraseToSeed(plaintext.toString("utf8"));
+          address = privateKeyToAccount(
+            deriveEvmPrivateKey(seed, `m/44'/60'/0'/0/${index}`)
+          ).address;
+        } finally {
+          seed?.fill(0);
+          plaintext.fill(0);
+        }
+        const account = {
+          name,
+          kind: "derived",
+          index,
+          address,
+          createdAt: this.now().toISOString()
+        };
+        file2.accounts.push(account);
+        file2.nextDerivedIndex = index + 1;
+        return copyAccount(account);
+      });
+    } catch (error61) {
+      throw asVaultError(error61, "corrupt", "Unable to derive a vault account.");
+    }
+  }
+  async importAccount(name, privateKey) {
+    try {
+      return await this.update(async (file2) => {
+        assertAvailableName(file2, name);
+        let validated;
+        let address;
+        try {
+          validated = validatePrivateKey(privateKey);
+          address = privateKeyToAccount(validated).address;
+        } catch (error61) {
+          throw new VaultError("bad_key", "The imported private key is not valid.", {
+            cause: error61
+          });
+        }
+        const plaintext = Buffer.from(validated.slice(2), "hex");
+        let account;
+        try {
+          account = {
+            name,
+            kind: "imported",
+            address,
+            key: sealField(this.key, plaintext),
+            createdAt: this.now().toISOString()
+          };
+        } finally {
+          plaintext.fill(0);
+        }
+        file2.accounts.push(account);
+        return copyAccount(account);
+      });
+    } catch (error61) {
+      throw asVaultError(error61, "corrupt", "Unable to import a vault account.");
+    }
+  }
+  async removeAccount(name) {
+    try {
+      await this.update(async (file2) => {
+        const account = file2.accounts.find((candidate) => candidate.name === name);
+        if (!account) {
+          throw new VaultError("not_found", "No vault account has that name.");
+        }
+        if (!this.balanceOf) {
+          throw new VaultError(
+            "has_balance",
+            "The account balance could not be verified, so the key was not removed."
+          );
+        }
+        if (await this.balanceOf(account.address) > 0n) {
+          throw new VaultError(
+            "has_balance",
+            "This account still has a balance. Run vapi sweep before removing it."
+          );
+        }
+        file2.nextDerivedIndex = nextDerivedIndex(file2);
+        const currentIndex = file2.accounts.findIndex((candidate) => candidate.name === name);
+        if (currentIndex === -1) {
+          throw new VaultError("not_found", "No vault account has that name.");
+        }
+        file2.accounts.splice(currentIndex, 1);
+      });
+    } catch (error61) {
+      throw asVaultError(error61, "corrupt", "Unable to remove the vault account.");
+    }
+  }
+  async rename(from, to) {
+    try {
+      await this.update(async (file2) => {
+        const account = file2.accounts.find((candidate) => candidate.name === from);
+        if (!account) {
+          throw new VaultError("not_found", "No vault account has that name.");
+        }
+        if (from === to) return;
+        assertAccountName(to);
+        if (file2.accounts.some((candidate) => candidate.name === to)) {
+          throw new VaultError("name_taken", "A vault account already has that name.");
+        }
+        account.name = to;
+      });
+    } catch (error61) {
+      throw asVaultError(error61, "corrupt", "Unable to rename the vault account.");
+    }
+  }
+  async signer(name) {
+    try {
+      const latest = await readVaultFile(this.path, this.key);
+      this.file = latest;
+      const stored = latest.accounts.find((account2) => account2.name === name);
+      if (!stored) {
+        throw new VaultError("not_found", "No vault account has that name.");
+      }
+      let account;
+      if (stored.kind === "derived") {
+        const plaintext = decryptField(this.key, latest.phrase);
+        let seed;
+        try {
+          seed = phraseToSeed(plaintext.toString("utf8"));
+          account = privateKeyToAccount(
+            deriveEvmPrivateKey(seed, `m/44'/60'/0'/0/${stored.index}`)
+          );
+        } finally {
+          seed?.fill(0);
+          plaintext.fill(0);
+        }
+      } else {
+        const plaintext = decryptField(this.key, stored.key);
+        try {
+          if (plaintext.byteLength !== 32) {
+            throw new VaultError("corrupt", "An imported vault key has the wrong length.");
+          }
+          const privateKey = `0x${plaintext.toString("hex")}`;
+          account = privateKeyToAccount(privateKey);
+        } finally {
+          plaintext.fill(0);
+        }
+      }
+      if (account.address.toLowerCase() !== stored.address.toLowerCase()) {
+        throw new VaultError("corrupt", "A vault key does not match its stored address.");
+      }
+      return account;
+    } catch (error61) {
+      throw asVaultError(error61, "corrupt", "Unable to open the vault account signer.");
+    }
+  }
+  async phrase() {
+    const latest = await readVaultFile(this.path, this.key);
+    this.file = latest;
+    const plaintext = decryptField(this.key, latest.phrase);
+    try {
+      try {
+        return validateRecoveryPhrase(plaintext.toString("utf8"));
+      } catch (error61) {
+        throw new VaultError("corrupt", "The vault recovery phrase is not valid.", {
+          cause: error61
+        });
+      }
+    } finally {
+      plaintext.fill(0);
+    }
+  }
+  async save() {
+    try {
+      await this.update(async () => void 0);
+    } catch (error61) {
+      throw asVaultError(error61, "corrupt", "Unable to save the vault.");
+    }
+  }
+  resealSecrets(file2) {
+    const phrase = decryptField(this.key, file2.phrase);
+    try {
+      const accounts = file2.accounts.map((account) => {
+        if (account.kind === "derived") return { ...account };
+        const privateKey = decryptField(this.key, account.key);
+        try {
+          if (privateKey.byteLength !== 32) {
+            throw new VaultError("corrupt", "An imported vault key has the wrong length.");
+          }
+          return { ...account, key: sealField(this.key, privateKey) };
+        } finally {
+          privateKey.fill(0);
+        }
+      });
+      return {
+        ...file2,
+        phrase: sealField(this.key, phrase),
+        accounts
+      };
+    } finally {
+      phrase.fill(0);
+    }
+  }
+  async update(operation) {
+    return await withVaultLock(this.path, async () => {
+      const latest = await readVaultFile(this.path, this.key);
+      const result = await operation(latest);
+      const rewritten = this.resealSecrets(latest);
+      await writeVaultFile(this.path, rewritten);
+      this.file = rewritten;
+      return result;
+    });
+  }
+};
+async function openVault(args) {
+  assertVaultKey(args.key);
+  return new DeviceVault(args, await readVaultFile(args.path, args.key));
+}
+async function exportVaultPhrase(args) {
+  return await (await openVault(args)).phrase();
+}
+async function exportVaultAccountKey(args) {
+  assertVaultKey(args.key);
+  try {
+    const file2 = await readVaultFile(args.path, args.key);
+    const account = file2.accounts.find((candidate) => candidate.name === args.name);
+    if (!account) {
+      throw new VaultError("not_found", "No vault account has that name.");
+    }
+    let privateKey;
+    if (account.kind === "derived") {
+      const plaintext = decryptField(args.key, file2.phrase);
+      let seed;
+      try {
+        seed = phraseToSeed(plaintext.toString("utf8"));
+        privateKey = deriveEvmPrivateKey(seed, `m/44'/60'/0'/0/${account.index}`);
+      } finally {
+        seed?.fill(0);
+        plaintext.fill(0);
+      }
+    } else {
+      const plaintext = decryptField(args.key, account.key);
+      try {
+        if (plaintext.byteLength !== 32) {
+          throw new VaultError("corrupt", "An imported vault key has the wrong length.");
+        }
+        privateKey = `0x${plaintext.toString("hex")}`;
+      } finally {
+        plaintext.fill(0);
+      }
+    }
+    if (privateKeyToAccount(privateKey).address.toLowerCase() !== account.address.toLowerCase()) {
+      throw new VaultError("corrupt", "A vault key does not match its stored address.");
+    }
+    return privateKey;
+  } catch (error61) {
+    throw asVaultError(error61, "corrupt", "Unable to export the vault account key.");
+  }
+}
+async function exportMemberKey(args) {
+  return await exportVaultAccountKey(args);
+}
+function assertVaultKey(key) {
+  if (key.byteLength !== 32) {
+    throw new VaultError("bad_key", "A device vault key must contain exactly 32 bytes.");
+  }
+}
+function assertAccountName(name) {
+  const parsed = walletNameSchema.safeParse(name);
+  if (!parsed.success) {
+    throw new VaultError("name_taken", "The vault account name is not valid.", {
+      cause: parsed.error
+    });
+  }
+}
+function assertAvailableName(file2, name) {
+  assertAccountName(name);
+  if (file2.accounts.some((account) => account.name === name)) {
+    throw new VaultError("name_taken", "A vault account already has that name.");
+  }
+}
+function nextDerivedIndex(file2) {
+  let next = file2.nextDerivedIndex ?? 0;
+  for (const account of file2.accounts) {
+    if (account.kind === "derived") next = Math.max(next, account.index + 1);
+  }
+  return next;
+}
+function copyAccount(account) {
+  if (account.kind === "derived") return { ...account };
+  return {
+    name: account.name,
+    kind: account.kind,
+    address: account.address,
+    createdAt: account.createdAt
+  };
+}
+function sealField(key, plaintext) {
+  const { nonce, ciphertext, tag } = encryptWithKey(key, plaintext);
+  return [nonce, ciphertext, tag].map((part) => part.toString("base64url")).join(".");
+}
+function openField(key, value) {
+  const [nonce = "", ciphertext = "", tag = ""] = value.split(".");
+  return decryptWithKey(key, {
+    nonce: Buffer.from(nonce, "base64url"),
+    ciphertext: Buffer.from(ciphertext, "base64url"),
+    tag: Buffer.from(tag, "base64url")
+  });
+}
+function decryptField(key, value) {
+  try {
+    return openField(key, value);
+  } catch (error61) {
+    throw new VaultError("bad_key", "Unable to decrypt the vault with this device key.", {
+      cause: error61
+    });
+  }
+}
+function decryptPhraseForOpen(key, phrase) {
+  try {
+    return openField(key, phrase);
+  } catch (error61) {
+    throw new VaultError("bad_key", "Unable to decrypt the vault with this device key.", {
+      cause: error61
+    });
+  }
+}
+function parseVaultFile(raw) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch (error61) {
+    throw new VaultError("corrupt", "The vault file is not valid JSON.", { cause: error61 });
+  }
+  const parsed = vaultFileSchema.safeParse(value);
+  if (!parsed.success) {
+    throw new VaultError("corrupt", "The vault file has an invalid structure.", {
+      cause: parsed.error
+    });
+  }
+  if (parsed.data.protected !== (parsed.data.wrappedKey !== void 0)) {
+    throw new VaultError("corrupt", "The vault protection metadata is inconsistent.");
+  }
+  const names = /* @__PURE__ */ new Set();
+  const indexes = /* @__PURE__ */ new Set();
+  for (const account of parsed.data.accounts) {
+    if (names.has(account.name)) {
+      throw new VaultError("corrupt", "The vault file contains duplicate account names.");
+    }
+    names.add(account.name);
+    if (account.kind === "derived") {
+      if (indexes.has(account.index)) {
+        throw new VaultError("corrupt", "The vault file contains duplicate derived indexes.");
+      }
+      indexes.add(account.index);
+    }
+  }
+  return parsed.data;
+}
+async function readVaultFile(path, key) {
+  const file2 = await readVaultFileUnlocked(path);
+  const plaintext = decryptPhraseForOpen(key, file2.phrase);
+  try {
+    try {
+      validateRecoveryPhrase(plaintext.toString("utf8"));
+    } catch (error61) {
+      throw new VaultError("corrupt", "The vault recovery phrase is not valid.", {
+        cause: error61
+      });
+    }
+  } finally {
+    plaintext.fill(0);
+  }
+  return file2;
+}
+async function readVaultFileUnlocked(path) {
+  let raw;
+  try {
+    raw = await readFile4(path, "utf8");
+  } catch (error61) {
+    if (isMissingFile2(error61)) {
+      throw new VaultError("not_found", "No vault file was found at the requested path.", {
+        cause: error61
+      });
+    }
+    throw new VaultError("corrupt", "Unable to read the vault file.", { cause: error61 });
+  }
+  return parseVaultFile(raw);
+}
+async function writeVaultFile(path, file2) {
+  await mkdir4(dirname4(path), { recursive: true, mode: 448 });
+  const temporaryPath = `${path}.${process.pid}.${randomBytes4(6).toString("hex")}.tmp`;
+  try {
+    await writeFile3(temporaryPath, `${JSON.stringify(file2, null, 2)}
+`, {
+      encoding: "utf8",
+      mode: 384,
+      flag: "wx"
+    });
+    await rename4(temporaryPath, path);
+  } catch (error61) {
+    await rm(temporaryPath, { force: true }).catch(() => void 0);
+    throw error61;
+  }
+}
+async function withVaultLock(path, operation) {
+  await mkdir4(dirname4(path), { recursive: true, mode: 448 });
+  const lockPath = `${path}.lock`;
+  const deadline = Date.now() + VAULT_LOCK_TIMEOUT_MS;
+  let handle;
+  while (!handle) {
+    try {
+      handle = await open3(lockPath, "wx", 384);
+    } catch (error61) {
+      if (!isExistingFile(error61)) throw error61;
+      await removeStaleVaultLock(lockPath);
+      if (Date.now() >= deadline) {
+        throw new VaultError("corrupt", "Timed out waiting for the vault lock.");
+      }
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+  }
+  try {
+    return await operation();
+  } finally {
+    await handle.close();
+    await unlink2(lockPath).catch(() => void 0);
+  }
+}
+async function removeStaleVaultLock(path) {
+  try {
+    const metadata = await stat4(path);
+    if (Date.now() - metadata.mtimeMs > STALE_VAULT_LOCK_MS) await unlink2(path);
+  } catch (error61) {
+    if (!isMissingFile2(error61)) throw error61;
+  }
+}
+function isMissingFile2(error61) {
+  return typeof error61 === "object" && error61 !== null && "code" in error61 && Reflect.get(error61, "code") === "ENOENT";
+}
+function isExistingFile(error61) {
+  return typeof error61 === "object" && error61 !== null && "code" in error61 && Reflect.get(error61, "code") === "EEXIST";
+}
+function asVaultError(error61, code, message) {
+  return error61 instanceof VaultError ? error61 : new VaultError(code, message, { cause: error61 });
+}
+
+// src/device.ts
+var DEVICE_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,31}$/;
+
+// src/agent-link.ts
+var DEFAULT_AGENT_SCOPES = ["mcp:call", "router.use"];
+var ALLOWED_AGENT_SCOPES = /* @__PURE__ */ new Set([...DEFAULT_AGENT_SCOPES, "call.publish"]);
+var publicFetch = createPublicFetch({ allowPrivateNetwork: false });
+var agentSecretAccounts = (wallet) => ({
+  tokens: `vapi.agent.${wallet}.tokens`,
+  routerStake: `vapi.agent.${wallet}.router.stake`,
+  routerBalance: `vapi.agent.${wallet}.router.balance`
+});
+
+// src/agent-profile.ts
+var DEFAULT_AGENT_TOOLS = ["call.search", "call.inspect", "call.pay"];
+var AGENT_GRANTS = ["read", "delegate", "allocate"];
+var agentProfileShape = {
+  version: external_exports.literal(1),
+  name: walletNameSchema,
+  wallet: external_exports.string(),
+  model: external_exports.string().min(1),
+  instructions: external_exports.string().max(2e4),
+  verifiedOnly: external_exports.boolean().default(true),
+  approveAboveUsd: external_exports.number().min(0).default(0.5),
+  maxSteps: external_exports.number().int().min(1).max(50).default(12),
+  paused: external_exports.boolean().default(false),
+  grants: external_exports.array(external_exports.enum(AGENT_GRANTS)).default([]),
+  createdAt: external_exports.string()
+};
+function createAgentProfileSchema(toolNames) {
+  if (toolNames.length === 0) {
+    throw new Error("Agent profiles require at least one registered tool.");
+  }
+  const tools = [...toolNames];
+  return external_exports.object({ ...agentProfileShape, tools: external_exports.array(external_exports.enum(tools)).default(tools) });
+}
+var agentProfileSchema = createAgentProfileSchema(DEFAULT_AGENT_TOOLS);
+
+// src/agent-run.ts
+var RUN_ID_PATTERN = /^run_[0-9a-f]{24}$/;
+var runRefSchema = external_exports.strictObject({
+  id: external_exports.string().regex(RUN_ID_PATTERN),
+  swarm: external_exports.string().optional(),
+  member: external_exports.string().optional(),
+  parentRunId: external_exports.string().optional()
+});
+
+// src/swarm.ts
+var SWARM_NAME_PATTERN = /^[a-z][a-z0-9-]{0,15}$/;
+var SWARM_ROLE_PATTERN = /^[a-z][a-z0-9]{0,7}$/;
+var atomicSchema = external_exports.string().regex(/^\d+$/);
+var addressSchema2 = external_exports.string().regex(/^0x[0-9a-fA-F]{40}$/);
+var capsSchema = external_exports.strictObject({ perCallAtomic: atomicSchema, perDayAtomic: atomicSchema });
+var movementIdSchema = external_exports.string().regex(/^mv_[A-Za-z0-9_-]{8,128}$/u);
+var amountUsdSchema = external_exports.string().regex(/^\d+\.\d{2}$/u);
+var setupFundingStatusSchema = external_exports.enum(["planned", "sent", "incomplete"]);
+var blockedFundingLegSchema = external_exports.strictObject({
+  to: external_exports.string().trim().min(1),
+  amountUsd: amountUsdSchema,
+  reason: external_exports.string().trim().min(1)
+});
+var setupFundingSchema = external_exports.strictObject({
+  amountUsd: amountUsdSchema,
+  from: walletNameSchema,
+  movementId: movementIdSchema.optional(),
+  status: setupFundingStatusSchema,
+  policy: external_exports.strictObject({
+    strategy: external_exports.enum(["targets", "even", "weights"]),
+    movementId: movementIdSchema.optional(),
+    status: setupFundingStatusSchema,
+    blocked: external_exports.array(blockedFundingLegSchema).optional()
+  }).optional()
+});
+var accountSteps = {
+  creating: external_exports.boolean().default(false),
+  created: external_exports.boolean(),
+  capped: external_exports.boolean(),
+  linked: external_exports.boolean()
+};
+var treasurySchema = external_exports.strictObject({
+  account: walletNameSchema,
+  // A planned account has no address until its vault derivation succeeds.
+  address: addressSchema2.optional(),
+  steps: external_exports.strictObject(accountSteps)
+}).refine(
+  (value) => !value.steps.created || value.address !== void 0,
+  "Created accounts require an address."
+);
+var memberSchema = external_exports.strictObject({
+  account: walletNameSchema,
+  address: addressSchema2.optional(),
+  role: external_exports.string().regex(SWARM_ROLE_PATTERN),
+  weight: external_exports.number().int().positive(),
+  targetAtomic: atomicSchema,
+  ceilingAtomic: atomicSchema.nullable(),
+  steps: external_exports.strictObject({ ...accountSteps, profiled: external_exports.boolean() })
+}).refine(
+  (value) => !value.steps.created || value.address !== void 0,
+  "Created accounts require an address."
+);
+var swarmFileSchema = external_exports.strictObject({
+  v: external_exports.literal(1),
+  name: external_exports.string().regex(SWARM_NAME_PATTERN),
+  device: external_exports.string().regex(DEVICE_NAME_PATTERN),
+  network: external_exports.enum([BASE_MAINNET_CAIP2, ARC_MAINNET_CAIP2]),
+  createdAt: external_exports.iso.datetime(),
+  treasury: treasurySchema,
+  members: external_exports.array(memberSchema),
+  setupFunding: setupFundingSchema.optional(),
+  policy: external_exports.strictObject({
+    strategy: external_exports.enum(["targets", "even", "weights"]),
+    treasuryCaps: capsSchema
+  })
+}).refine(
+  (value) => (/* @__PURE__ */ new Set([value.treasury.account, ...value.members.map((member) => member.account)])).size === value.members.length + 1,
+  "Swarm accounts must be unique."
+);
+
+// src/member-bundle.ts
+var MEMBER_BUNDLE_MAX_BYTES = 32 * 1024;
+var REMOTE_BLOCKED_GRANTS = /* @__PURE__ */ new Set([
+  "delegate",
+  "allocate"
+]);
+var BASE64URL_PATTERN = /^[A-Za-z0-9_-]+$/;
+var ADDRESS_PATTERN2 = /^0x[0-9a-fA-F]{40}$/;
+var PRIVATE_KEY_PATTERN = /^0x[0-9a-fA-F]{64}$/;
+var ATOMIC_PATTERN = /^\d+$/;
+var FORBIDDEN_CONFIG_KEYS = /* @__PURE__ */ new Set(["rpcUrl", "apiKey"]);
+var MemberBundleError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "MemberBundleError";
+  }
+  code;
+};
+var hexString = (pattern, message) => external_exports.custom((value) => typeof value === "string" && pattern.test(value), message);
+var linkSchema = external_exports.strictObject({
+  apiBase: external_exports.string(),
+  clientId: external_exports.string(),
+  owner: external_exports.custom((value) => typeof value === "string" && value.startsWith("0x")),
+  label: external_exports.string(),
+  scopes: external_exports.array(external_exports.string()),
+  linkedAt: external_exports.iso.datetime(),
+  routerBaseUrl: external_exports.string().optional()
+});
+var remoteTokensSchema = external_exports.strictObject({
+  accessToken: external_exports.string().min(1),
+  expiresAt: external_exports.number().finite(),
+  scopes: external_exports.array(external_exports.string()),
+  refreshable: external_exports.literal(false)
+});
+var storedTokensSchema = external_exports.object({
+  accessToken: external_exports.string().min(1),
+  refreshToken: external_exports.string().min(1),
+  expiresAt: external_exports.number().finite(),
+  scopes: external_exports.array(external_exports.string())
+});
+var credentialsSchema = external_exports.strictObject({
+  tokens: external_exports.string().min(1).refine(isRemoteTokens, "A member bundle carries a non-refreshable access token only."),
+  routerStake: external_exports.string().min(1).optional(),
+  routerBalance: external_exports.string().min(1).optional()
+});
+var remoteProfileSchema = agentProfileSchema.strict().refine((profile) => profile.grants.every((grant) => !REMOTE_BLOCKED_GRANTS.has(grant)), {
+  message: "A remote member never holds the delegate or allocate grant.",
+  path: ["grants"]
+});
+var credentialFreeUrl = external_exports.url().refine((value) => unsafeUrlPart(value) === void 0, {
+  message: "A member bundle URL never carries a user name, password, query or fragment."
+});
+var memberBundleConfigSchema = external_exports.unknown().refine((value) => !hasForbiddenConfigKey(value), {
+  message: "A member bundle never carries RPC URLs or API keys."
+}).pipe(
+  external_exports.strictObject({
+    discoveryUrl: credentialFreeUrl,
+    marketplaceDiscoveryUrl: credentialFreeUrl,
+    networks: external_exports.record(
+      external_exports.string().refine(isMemberBundleNetwork, {
+        message: "Expected a network with a public RPC default."
+      }),
+      external_exports.strictObject({ usdc: external_exports.string() })
+    ).refine(
+      (networks) => Object.entries(networks).every(
+        ([id, network]) => isMemberBundleNetwork(id) && network.usdc === NETWORKS[id].usdc
+      ),
+      { message: "Expected the canonical USDC token of each network." }
+    ).refine((networks) => Object.keys(networks).length === 1, {
+      message: "A member bundle carries exactly one network: the swarm's."
+    })
+  })
+);
+var memberBundleSchema = external_exports.strictObject({
+  v: external_exports.literal(1),
+  account: walletNameSchema,
+  address: hexString(ADDRESS_PATTERN2, "Expected a 20-byte 0x address."),
+  privateKey: hexString(PRIVATE_KEY_PATTERN, "Expected a 32-byte 0x private key."),
+  swarm: external_exports.string().regex(SWARM_NAME_PATTERN),
+  profile: remoteProfileSchema,
+  link: linkSchema,
+  credentials: credentialsSchema,
+  caps: external_exports.strictObject(spendCapsSchema.shape),
+  allowanceExpiresAt: external_exports.iso.datetime(),
+  ceilingAtomic: external_exports.string().regex(ATOMIC_PATTERN, "Expected non-negative atomic units."),
+  config: memberBundleConfigSchema,
+  runId: external_exports.string().regex(RUN_ID_PATTERN),
+  parentRunId: external_exports.string().regex(RUN_ID_PATTERN).optional()
+});
+function memberBundleConfig(owner, network) {
+  const discoveryUrl = safeDiscoveryUrl("discoveryUrl", owner.discoveryUrl);
+  const marketplaceDiscoveryUrl = safeDiscoveryUrl(
+    "marketplaceDiscoveryUrl",
+    owner.marketplaceDiscoveryUrl
+  );
+  if (!Object.hasOwn(owner.networks, network) || !isMemberBundleNetwork(network)) {
+    throw new MemberBundleError(
+      "unsupported_network",
+      `A member bundle runs on the swarm network ${network}, which must be enabled in this config and have a public RPC default.`
+    );
+  }
+  return {
+    discoveryUrl,
+    marketplaceDiscoveryUrl,
+    networks: { [network]: { usdc: NETWORKS[network].usdc } }
+  };
+}
+function headlessConfigFromBundle(config2) {
+  const networks = {};
+  for (const [id, network] of Object.entries(config2.networks)) {
+    if (!isMemberBundleNetwork(id) || network === void 0) continue;
+    networks[id] = { rpcUrl: NETWORKS[id].publicRpcUrl, usdc: network.usdc };
+  }
+  return configSchema.parse({
+    discoveryUrl: config2.discoveryUrl,
+    marketplaceDiscoveryUrl: config2.marketplaceDiscoveryUrl,
+    networks,
+    spendCaps: { ...DEFAULT_SPEND_CAPS }
+  });
+}
+function createMemberBundle(input2) {
+  const bundle = parseBundle({ ...input2, profile: withoutRemoteGrants(input2.profile), v: 1 });
+  assertKeyMatchesAddress(bundle);
+  const encoded = Buffer.from(JSON.stringify(bundle), "utf8").toString("base64url");
+  if (encoded.length > MEMBER_BUNDLE_MAX_BYTES) {
+    throw new MemberBundleError(
+      "too_large",
+      `The member bundle is larger than ${MEMBER_BUNDLE_MAX_BYTES} bytes.`
+    );
+  }
+  return encoded;
+}
+function openMemberBundle(text) {
+  if (typeof text !== "string") {
+    throw new MemberBundleError("invalid", "The member bundle is not a string.");
+  }
+  if (text.length > MEMBER_BUNDLE_MAX_BYTES) {
+    throw new MemberBundleError(
+      "too_large",
+      `The member bundle is larger than ${MEMBER_BUNDLE_MAX_BYTES} bytes.`
+    );
+  }
+  if (!BASE64URL_PATTERN.test(text)) {
+    throw new MemberBundleError("invalid", "The member bundle is not base64url text.");
+  }
+  let decoded;
+  try {
+    decoded = JSON.parse(Buffer.from(text, "base64url").toString("utf8"));
+  } catch {
+    throw new MemberBundleError("invalid", "The member bundle does not decode to JSON.");
+  }
+  const bundle = parseBundle(decoded);
+  assertKeyMatchesAddress(bundle);
+  return bundle;
+}
+async function readMemberCredentials(args) {
+  if (!isWalletName(args.account)) {
+    throw new MemberBundleError("invalid", "The member account name is not valid.");
+  }
+  const names = agentSecretAccounts(args.account);
+  const storedTokens = await args.secrets.get(names.tokens);
+  if (storedTokens === void 0 || storedTokens === "") {
+    throw new MemberBundleError(
+      "not_linked",
+      `The account ${args.account} is not linked to vAPI. Link it with vapi login first.`
+    );
+  }
+  const routerStake = await args.secrets.get(names.routerStake);
+  const routerBalance = await args.secrets.get(names.routerBalance);
+  const parsed = parseStoredTokens(storedTokens);
+  if (parsed === void 0) {
+    throw new MemberBundleError(
+      "not_linked",
+      `The account ${args.account}'s vAPI credentials cannot be exported safely. Run vapi login --account ${args.account} again.`
+    );
+  }
+  const tokens = JSON.stringify({
+    accessToken: parsed.accessToken,
+    expiresAt: parsed.expiresAt,
+    scopes: parsed.scopes,
+    refreshable: false
+  });
+  return {
+    tokens,
+    ...routerStake === void 0 || routerStake === "" ? {} : { routerStake },
+    ...routerBalance === void 0 || routerBalance === "" ? {} : { routerBalance }
+  };
+}
+function isRemoteTokens(value) {
+  try {
+    return remoteTokensSchema.safeParse(JSON.parse(value)).success;
+  } catch {
+    return false;
+  }
+}
+function parseStoredTokens(value) {
+  try {
+    const parsed = storedTokensSchema.safeParse(JSON.parse(value));
+    return parsed.success ? parsed.data : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function isMemberBundleNetwork(id) {
+  return Object.hasOwn(NETWORKS, id) && typeof NETWORKS[id].publicRpcUrl === "string";
+}
+function hasForbiddenConfigKey(value) {
+  if (Array.isArray(value)) return value.some(hasForbiddenConfigKey);
+  if (typeof value !== "object" || value === null) return false;
+  return Object.entries(value).some(
+    ([key, item]) => FORBIDDEN_CONFIG_KEYS.has(key) || hasForbiddenConfigKey(item)
+  );
+}
+function unsafeUrlPart(value) {
+  let url2;
+  try {
+    url2 = new URL(value);
+  } catch {
+    return "an unparseable value";
+  }
+  if (url2.username !== "" || url2.password !== "") return "a user name or password";
+  if (url2.search !== "" || value.includes("?")) return "a query string";
+  if (url2.hash !== "" || value.includes("#")) return "a fragment";
+  return void 0;
+}
+function safeDiscoveryUrl(field, value) {
+  const part = unsafeUrlPart(value);
+  if (part !== void 0) {
+    throw new MemberBundleError(
+      "unsafe_config",
+      `The owner config's ${field} has ${part}, which can carry a credential, so it never goes into a member bundle. Point ${field} at a plain URL (check VAPI_DISCOVERY_URL, VAPI_MARKETPLACE_DISCOVERY_URL and config.json).`
+    );
+  }
+  return value;
+}
+function withoutRemoteGrants(profile) {
+  if (typeof profile !== "object" || profile === null || !Array.isArray(profile.grants)) {
+    return profile;
+  }
+  return {
+    ...profile,
+    grants: profile.grants.filter((grant) => !REMOTE_BLOCKED_GRANTS.has(grant))
+  };
+}
+function parseBundle(value) {
+  const parsed = memberBundleSchema.safeParse(value);
+  if (!parsed.success) {
+    const fields = [
+      ...new Set(parsed.error.issues.map((issue2) => issue2.path.map(String).join(".") || "(root)"))
+    ];
+    throw new MemberBundleError(
+      "invalid",
+      `The member bundle is not valid (fields: ${fields.join(", ")}).`
+    );
+  }
+  return parsed.data;
+}
+function assertKeyMatchesAddress(bundle) {
+  let derived;
+  try {
+    derived = privateKeyToAccount(bundle.privateKey).address;
+  } catch {
+    throw new MemberBundleError("key_mismatch", "The member bundle's key is not a valid key.");
+  }
+  if (derived.toLowerCase() !== bundle.address.toLowerCase()) {
+    throw new MemberBundleError(
+      "key_mismatch",
+      "The member bundle's key does not match its address."
+    );
+  }
 }
 export {
+  MEMBER_BUNDLE_MAX_BYTES,
+  MemberBundleError,
   createKeystoreWithPhrase,
+  createMemberBundle,
   decryptPrivateKey,
   exportKeystoreKeys,
-  exportRecoveryPhrase
+  exportMemberKey,
+  exportRecoveryPhrase,
+  exportVaultAccountKey,
+  exportVaultPhrase,
+  headlessConfigFromBundle,
+  memberBundleConfig,
+  memberBundleConfigSchema,
+  memberBundleSchema,
+  openMemberBundle,
+  readMemberCredentials
 };
 //# sourceMappingURL=secrets.js.map