@hivemind-os/collective-daemon 0.2.0

package/dist/chunk-CJHYQ7RR.js

@@ -0,0 +1,656 @@
+import {
+  getDefaultIpcPath
+} from "./chunk-NXIFS427.js";
+
+// src/config.ts
+import { randomUUID } from "crypto";
+import * as fs from "fs";
+import * as fsPromises from "fs/promises";
+import { homedir } from "os";
+import { dirname, extname, join, resolve } from "path";
+import { isDeepStrictEqual } from "util";
+import {
+  PaymentRail,
+  NETWORK_PRESETS,
+  getNetworkPreset
+} from "@hivemind-os/collective-types";
+import yaml from "js-yaml";
+var LOG_LEVELS = /* @__PURE__ */ new Set(["debug", "info", "warn", "error"]);
+var configSaveLocks = /* @__PURE__ */ new Map();
+var configIo = {
+  mkdir: fsPromises.mkdir,
+  writeFile: fsPromises.writeFile,
+  rename: fsPromises.rename,
+  rm: fsPromises.rm
+};
+function getDefaultConfig() {
+  return buildDefaultConfig(resolve(homedir(), ".hivemind-os/collective"));
+}
+function getConfigPath(configPath) {
+  return resolve(expandHome(configPath ?? join(getEnvDataDir() ?? resolve(homedir(), ".hivemind-os/collective"), "config.yaml")));
+}
+function loadConfig(configPath) {
+  const resolvedConfigPath = getConfigPath(configPath);
+  const parsed = loadConfigFile(resolvedConfigPath);
+  const config = buildResolvedConfig(parsed);
+  validateConfig(config);
+  if (!fs.existsSync(resolvedConfigPath)) {
+    fs.mkdirSync(dirname(resolvedConfigPath), { recursive: true, mode: 448 });
+    writePrivateConfigFile(resolvedConfigPath, formatConfigContents(serializeConfig(config), resolvedConfigPath));
+  } else {
+    enforcePrivateFilePermissions(resolvedConfigPath);
+  }
+  return config;
+}
+async function saveConfig(config, configPath = getConfigPath()) {
+  const resolvedConfigPath = getConfigPath(configPath);
+  validateConfig(config);
+  await withConfigSaveLock(resolvedConfigPath, async () => {
+    const parsed = loadConfigFile(resolvedConfigPath);
+    const currentConfig = buildResolvedConfig(parsed);
+    const updates = collectConfigDiffs(serializeConfig(currentConfig), serializeConfig(config));
+    const nextParsed = applyConfigDiffs(parsed, updates);
+    await writePrivateConfigFileAtomic(
+      resolvedConfigPath,
+      formatConfigContents(nextParsed, resolvedConfigPath)
+    );
+  });
+  return resolvedConfigPath;
+}
+function writePrivateConfigFile(configPath, contents) {
+  fs.writeFileSync(configPath, contents, { encoding: "utf8", mode: 384 });
+  enforcePrivateFilePermissions(configPath);
+}
+async function writePrivateConfigFileAtomic(configPath, contents) {
+  const tempPath = `${configPath}.${process.pid}.${randomUUID()}.tmp`;
+  await configIo.mkdir(dirname(configPath), { recursive: true, mode: 448 });
+  try {
+    await configIo.writeFile(tempPath, contents, { encoding: "utf8", mode: 384 });
+    await configIo.rename(tempPath, configPath);
+    enforcePrivateFilePermissions(configPath);
+  } finally {
+    await configIo.rm(tempPath, { force: true }).catch(() => void 0);
+  }
+}
+function enforcePrivateFilePermissions(path) {
+  fs.chmodSync(path, 384);
+}
+function loadConfigFile(configPath) {
+  if (!fs.existsSync(configPath)) {
+    return {};
+  }
+  const loaded = yaml.load(fs.readFileSync(configPath, "utf8"));
+  return isRecord(loaded) ? loaded : {};
+}
+function buildResolvedConfig(parsed) {
+  const baseDataDir = normalizePath(
+    getEnvDataDir() ?? readString(getNestedValue(parsed, "daemon", "dataDir")) ?? resolve(homedir(), ".hivemind-os/collective")
+  );
+  const hasExplicitIpcPath = readString(getNestedValue(parsed, "daemon", "ipcPath")) !== void 0;
+  return applyEnvironmentOverrides(mergeConfig(buildDefaultConfig(baseDataDir), parsed), { hasExplicitIpcPath });
+}
+async function withConfigSaveLock(configPath, operation) {
+  const previous = configSaveLocks.get(configPath) ?? Promise.resolve();
+  let release;
+  const gate = new Promise((resolve2) => {
+    release = resolve2;
+  });
+  const chain = previous.catch(() => void 0).then(() => gate);
+  configSaveLocks.set(configPath, chain);
+  await previous.catch(() => void 0);
+  try {
+    return await operation();
+  } finally {
+    release();
+    if (configSaveLocks.get(configPath) === chain) {
+      configSaveLocks.delete(configPath);
+    }
+  }
+}
+function collectConfigDiffs(current, next, path = []) {
+  if (isRecord(current) && isRecord(next)) {
+    const diffs = [];
+    const keys = /* @__PURE__ */ new Set([...Object.keys(current), ...Object.keys(next)]);
+    for (const key of keys) {
+      const hasCurrent = Object.hasOwn(current, key);
+      const hasNext = Object.hasOwn(next, key);
+      if (!hasNext) {
+        diffs.push({ path: [...path, key], delete: true });
+        continue;
+      }
+      if (!hasCurrent) {
+        diffs.push({ path: [...path, key], value: structuredClone(next[key]) });
+        continue;
+      }
+      diffs.push(...collectConfigDiffs(current[key], next[key], [...path, key]));
+    }
+    return diffs;
+  }
+  return isDeepStrictEqual(current, next) ? [] : [{ path, value: structuredClone(next) }];
+}
+function applyConfigDiffs(parsed, diffs) {
+  const next = structuredClone(parsed);
+  for (const diff of diffs) {
+    if (diff.path.length === 0) {
+      return isRecord(diff.value) ? structuredClone(diff.value) : {};
+    }
+    if (diff.delete) {
+      deleteNestedValue(next, diff.path);
+      continue;
+    }
+    setNestedValue(next, diff.path, structuredClone(diff.value));
+  }
+  return next;
+}
+function setNestedValue(record, path, value) {
+  let current = record;
+  for (const segment of path.slice(0, -1)) {
+    const next = current[segment];
+    if (!isRecord(next)) {
+      current[segment] = {};
+    }
+    current = current[segment];
+  }
+  current[path[path.length - 1]] = value;
+}
+function deleteNestedValue(record, path) {
+  const parents = [];
+  let current = record;
+  for (const segment of path.slice(0, -1)) {
+    if (!current || !isRecord(current[segment])) {
+      return;
+    }
+    parents.push({ record: current, key: segment });
+    current = current[segment];
+  }
+  if (!current) {
+    return;
+  }
+  delete current[path[path.length - 1]];
+  for (let index = parents.length - 1; index >= 0; index -= 1) {
+    const parent = parents[index];
+    const child = parent.record[parent.key];
+    if (!isRecord(child) || Object.keys(child).length > 0) {
+      break;
+    }
+    delete parent.record[parent.key];
+  }
+}
+function formatConfigContents(config, configPath) {
+  if (extname(configPath).toLowerCase() === ".json") {
+    return `${JSON.stringify(config, null, 2)}
+`;
+  }
+  return yaml.dump(config, { lineWidth: 120 });
+}
+function buildDefaultConfig(dataDir) {
+  const resolvedDataDir = normalizePath(dataDir);
+  const defaultNetwork = NETWORK_PRESETS.testnet;
+  return {
+    network: {
+      rpcUrl: defaultNetwork.rpcUrl,
+      faucetUrl: defaultNetwork.faucetUrl,
+      packageId: defaultNetwork.packageId,
+      registryId: defaultNetwork.registryId
+    },
+    identity: {
+      dataDir: join(resolvedDataDir, "identity")
+    },
+    auth: {
+      mode: "ed25519",
+      portal: {
+        port: 19876
+      }
+    },
+    spending: {
+      defaultRail: PaymentRail.SUI_ESCROW,
+      limits: [{ amount: 1000000000n, interval: "day", currency: "MIST" }]
+    },
+    payment: {
+      preferredRail: "auto",
+      evm: {
+        enabled: false,
+        network: "base"
+      }
+    },
+    daemon: {
+      ipcPath: getDefaultIpcPath(resolvedDataDir),
+      dataDir: resolvedDataDir,
+      pidFile: join(resolvedDataDir, "daemon.pid"),
+      logLevel: "info"
+    },
+    relay: {
+      enabled: false,
+      endpoints: [],
+      autoConnect: true,
+      providerMode: false,
+      reconnectIntervalMs: 5e3,
+      heartbeatIntervalMs: 3e4
+    },
+    blobstore: {
+      mode: "filesystem",
+      filesystem: {
+        dataDir: join(resolvedDataDir, "blobs")
+      }
+    },
+    encryption: {
+      enabled: true,
+      requireEncryption: false
+    }
+  };
+}
+function mergeConfig(defaults, parsed) {
+  const network = isRecord(parsed.network) ? parsed.network : {};
+  const identity = isRecord(parsed.identity) ? parsed.identity : {};
+  const auth = isRecord(parsed.auth) ? parsed.auth : {};
+  const payment = isRecord(parsed.payment) ? parsed.payment : {};
+  const daemon = isRecord(parsed.daemon) ? parsed.daemon : {};
+  const relay = isRecord(parsed.relay) ? parsed.relay : {};
+  const blobstore = isRecord(parsed.blobstore) ? parsed.blobstore : {};
+  const encryption = isRecord(parsed.encryption) ? parsed.encryption : {};
+  const provider = isRecord(parsed.provider) ? parsed.provider : void 0;
+  return {
+    network: {
+      ...resolveNetworkFromConfig(network, defaults.network)
+    },
+    identity: {
+      dataDir: normalizePath(readString(identity.dataDir) ?? defaults.identity.dataDir)
+    },
+    auth: normalizeAuthConfig(auth, defaults.auth),
+    spending: normalizeSpendingPolicy(parsed.spending, defaults.spending),
+    payment: normalizePaymentConfig(payment, defaults.payment),
+    daemon: {
+      ipcPath: readString(daemon.ipcPath) ?? defaults.daemon.ipcPath,
+      dataDir: normalizePath(readString(daemon.dataDir) ?? defaults.daemon.dataDir),
+      pidFile: normalizePath(readString(daemon.pidFile) ?? defaults.daemon.pidFile),
+      logLevel: normalizeLogLevel(daemon.logLevel, defaults.daemon.logLevel),
+      logFile: readString(daemon.logFile) ? normalizePath(readString(daemon.logFile)) : void 0
+    },
+    relay: normalizeRelayConfig(relay, defaults.relay),
+    blobstore: normalizeBlobStoreConfig(blobstore, defaults.blobstore),
+    encryption: normalizeEncryptionConfig(encryption, defaults.encryption),
+    provider: normalizeProviderConfig(provider)
+  };
+}
+function applyEnvironmentOverrides(config, options = { hasExplicitIpcPath: false }) {
+  const envDataDir = getEnvDataDir();
+  const withDataDir = envDataDir ? {
+    ...config,
+    identity: { dataDir: join(envDataDir, "identity") },
+    daemon: {
+      ...config.daemon,
+      dataDir: envDataDir,
+      pidFile: join(envDataDir, "daemon.pid"),
+      ipcPath: options.hasExplicitIpcPath ? config.daemon.ipcPath : getDefaultIpcPath(envDataDir)
+    },
+    blobstore: applyBlobStoreDataDirOverride(config.blobstore, join(envDataDir, "blobs"))
+  } : config;
+  return {
+    ...withDataDir,
+    network: {
+      ...withDataDir.network,
+      ...resolveNetworkEnvOverrides(withDataDir.network)
+    },
+    daemon: {
+      ...withDataDir.daemon,
+      logLevel: normalizeLogLevel(process.env.COLLECTIVE_LOG_LEVEL, withDataDir.daemon.logLevel)
+    }
+  };
+}
+function resolveNetworkEnvOverrides(base) {
+  const networkName = process.env.COLLECTIVE_NETWORK;
+  const preset = networkName ? getNetworkPreset(networkName) : void 0;
+  const merged = preset ? { ...base, ...preset } : base;
+  return {
+    rpcUrl: process.env.COLLECTIVE_RPC_URL ?? merged.rpcUrl,
+    faucetUrl: merged.faucetUrl,
+    packageId: process.env.COLLECTIVE_PACKAGE_ID ?? merged.packageId,
+    registryId: process.env.COLLECTIVE_REGISTRY_ID ?? merged.registryId
+  };
+}
+function normalizeAuthConfig(value, defaults) {
+  const google = isRecord(value.google) ? value.google : {};
+  const apple = isRecord(value.apple) ? value.apple : {};
+  const portal = isRecord(value.portal) ? value.portal : {};
+  return {
+    mode: value.mode === "zklogin" ? "zklogin" : defaults.mode,
+    google: readString(google.clientId) ? {
+      clientId: readString(google.clientId)
+    } : defaults.google,
+    apple: readString(apple.clientId) ? {
+      clientId: readString(apple.clientId)
+    } : defaults.apple,
+    portal: {
+      port: readPositiveInteger(portal.port, "auth.portal.port") ?? defaults.portal?.port ?? 19876
+    }
+  };
+}
+function normalizePaymentConfig(value, defaults) {
+  const evm = isRecord(value.evm) ? value.evm : {};
+  const preferredRail = readString(value.preferredRail);
+  const network = readString(evm.network);
+  return {
+    preferredRail: preferredRail === "sui" || preferredRail === "x402" || preferredRail === "auto" ? preferredRail : defaults.preferredRail,
+    evm: {
+      enabled: readBoolean(evm.enabled) ?? defaults.evm?.enabled ?? false,
+      network: network === "base" || network === "base-sepolia" || network === "localhost" ? network : defaults.evm?.network ?? "base",
+      rpcUrl: readString(evm.rpcUrl) ?? defaults.evm?.rpcUrl
+    }
+  };
+}
+function normalizeRelayConfig(value, defaults) {
+  const endpoints = Array.isArray(value.endpoints) ? value.endpoints.map((entry) => {
+    if (!isRecord(entry)) {
+      return null;
+    }
+    const url = readString(entry.url);
+    if (!url) {
+      return null;
+    }
+    const relayDid = readString(entry.relayDid);
+    return relayDid ? { url, relayDid } : { url };
+  }).filter((entry) => entry !== null) : defaults.endpoints;
+  return {
+    enabled: readBoolean(value.enabled) ?? defaults.enabled,
+    endpoints,
+    autoConnect: readBoolean(value.autoConnect) ?? defaults.autoConnect,
+    providerMode: readBoolean(value.providerMode) ?? defaults.providerMode,
+    reconnectIntervalMs: readPositiveInteger(value.reconnectIntervalMs, "relay.reconnectIntervalMs") ?? defaults.reconnectIntervalMs,
+    heartbeatIntervalMs: readPositiveInteger(value.heartbeatIntervalMs, "relay.heartbeatIntervalMs") ?? defaults.heartbeatIntervalMs
+  };
+}
+function normalizeEncryptionConfig(value, defaults) {
+  return {
+    enabled: readBoolean(value.enabled) ?? defaults.enabled,
+    requireEncryption: readBoolean(value.requireEncryption) ?? defaults.requireEncryption
+  };
+}
+function normalizeBlobStoreConfig(value, defaults) {
+  const blobstore = isRecord(value) ? value : {};
+  const filesystem = isRecord(blobstore.filesystem) ? blobstore.filesystem : {};
+  const walrus = isRecord(blobstore.walrus) ? blobstore.walrus : {};
+  const hybrid = isRecord(blobstore.hybrid) ? blobstore.hybrid : {};
+  const mode = normalizeBlobStoreMode(readString(blobstore.mode) ?? readString(blobstore.type) ?? defaults.mode);
+  const filesystemDataDir = readString(filesystem.dataDir) ?? readString(blobstore.baseDir) ?? defaults.filesystem?.dataDir;
+  const publisherUrl = readString(walrus.publisherUrl) ?? readString(blobstore.publisherUrl) ?? defaults.walrus?.publisherUrl;
+  const aggregatorUrl = readString(walrus.aggregatorUrl) ?? readString(blobstore.aggregatorUrl) ?? defaults.walrus?.aggregatorUrl;
+  return {
+    mode,
+    filesystem: filesystemDataDir ? {
+      dataDir: normalizePath(filesystemDataDir)
+    } : defaults.filesystem,
+    walrus: publisherUrl || aggregatorUrl || defaults.walrus ? {
+      publisherUrl: publisherUrl ?? "",
+      aggregatorUrl: aggregatorUrl ?? "",
+      epochs: readPositiveInteger(walrus.epochs, "blobstore.walrus.epochs") ?? defaults.walrus?.epochs,
+      maxBlobSize: readPositiveInteger(walrus.maxBlobSize, "blobstore.walrus.maxBlobSize") ?? defaults.walrus?.maxBlobSize,
+      retryAttempts: readPositiveInteger(walrus.retryAttempts, "blobstore.walrus.retryAttempts") ?? defaults.walrus?.retryAttempts,
+      retryDelayMs: readPositiveInteger(walrus.retryDelayMs, "blobstore.walrus.retryDelayMs") ?? defaults.walrus?.retryDelayMs,
+      timeoutMs: readPositiveInteger(walrus.timeoutMs, "blobstore.walrus.timeoutMs") ?? defaults.walrus?.timeoutMs
+    } : defaults.walrus,
+    hybrid: {
+      cacheLocally: readBoolean(hybrid.cacheLocally) ?? defaults.hybrid?.cacheLocally ?? true,
+      preferWalrus: readBoolean(hybrid.preferWalrus) ?? defaults.hybrid?.preferWalrus ?? true
+    }
+  };
+}
+function applyBlobStoreDataDirOverride(config, dataDir) {
+  if (config.mode !== "filesystem" && config.mode !== "hybrid") {
+    return config;
+  }
+  return {
+    ...config,
+    filesystem: {
+      dataDir
+    }
+  };
+}
+function normalizeBlobStoreMode(value) {
+  if (value === "filesystem" || value === "walrus" || value === "hybrid") {
+    return value;
+  }
+  throw new Error(`Unsupported blobstore mode: ${value}`);
+}
+function normalizeSpendingPolicy(value, defaults) {
+  if (!isRecord(value)) {
+    return defaults;
+  }
+  return {
+    defaultRail: normalizeRail(value.defaultRail) ?? defaults.defaultRail,
+    requireConfirmationAbove: value.requireConfirmationAbove === void 0 ? defaults.requireConfirmationAbove : parseBigInt(value.requireConfirmationAbove, "spending.requireConfirmationAbove"),
+    allowlist: Array.isArray(value.allowlist) ? value.allowlist.filter((entry) => typeof entry === "string") : defaults.allowlist,
+    denylist: Array.isArray(value.denylist) ? value.denylist.filter((entry) => typeof entry === "string") : defaults.denylist,
+    limits: Array.isArray(value.limits) && value.limits.length > 0 ? value.limits.map((limit, index) => normalizeSpendingLimit(limit, index, "spending.limits")) : defaults.limits,
+    perApp: normalizePerAppSpendingConfig(value.perApp, defaults.perApp)
+  };
+}
+function normalizePerAppSpendingConfig(value, defaults) {
+  if (!isRecord(value)) {
+    return defaults;
+  }
+  const perApp = Object.entries(value).map(([appName, config]) => {
+    if (!isRecord(config)) {
+      throw new Error(`spending.perApp.${appName} must be an object.`);
+    }
+    if (!Array.isArray(config.limits) || config.limits.length === 0) {
+      throw new Error(`spending.perApp.${appName}.limits must contain at least one limit.`);
+    }
+    return [
+      appName,
+      {
+        limits: config.limits.map(
+          (limit, index) => normalizeSpendingLimit(limit, index, `spending.perApp.${appName}.limits`)
+        )
+      }
+    ];
+  });
+  return Object.fromEntries(perApp);
+}
+function normalizeSpendingLimit(value, index, path) {
+  if (!isRecord(value)) {
+    throw new Error(`${path}[${index}] must be an object.`);
+  }
+  const interval = readString(value.interval);
+  if (!interval || !["transaction", "hour", "day", "month", "lifetime"].includes(interval)) {
+    throw new Error(`${path}[${index}].interval is invalid.`);
+  }
+  const normalizedInterval = interval;
+  return {
+    amount: parseBigInt(value.amount, `${path}[${index}].amount`),
+    interval: normalizedInterval,
+    rail: normalizeRail(value.rail),
+    currency: readString(value.currency)?.toUpperCase(),
+    scope: readString(value.scope) ?? void 0
+  };
+}
+function normalizeProviderConfig(value) {
+  if (!value) {
+    return void 0;
+  }
+  const capabilities = Array.isArray(value.capabilities) ? value.capabilities.map((entry, index) => normalizeProviderCapability(entry, index)) : [];
+  return {
+    enabled: readBoolean(value.enabled) ?? false,
+    capabilities,
+    maxConcurrency: readPositiveInteger(value.maxConcurrency, "provider.maxConcurrency"),
+    autoRegister: readBoolean(value.autoRegister)
+  };
+}
+function normalizeProviderCapability(value, index) {
+  if (!isRecord(value)) {
+    throw new Error(`provider.capabilities[${index}] must be an object.`);
+  }
+  const name = readString(value.name);
+  const description = readString(value.description);
+  const version = readString(value.version);
+  const adapter = readString(value.adapter);
+  const priceMist = readPositiveInteger(value.priceMist, `provider.capabilities[${index}].priceMist`);
+  if (!name || !description || !version || !adapter || priceMist === void 0) {
+    throw new Error(`provider.capabilities[${index}] is incomplete.`);
+  }
+  return {
+    name,
+    description,
+    version,
+    priceMist,
+    currency: readString(value.currency),
+    adapter,
+    adapterConfig: isRecord(value.adapterConfig) ? value.adapterConfig : void 0
+  };
+}
+function validateConfig(config) {
+  if (!config.network.rpcUrl) {
+    throw new Error("network.rpcUrl is required.");
+  }
+  if (!config.identity.dataDir) {
+    throw new Error("identity.dataDir is required.");
+  }
+  if (!config.auth.mode) {
+    throw new Error("auth.mode is required.");
+  }
+  if (config.auth.mode === "zklogin" && !config.auth.google?.clientId) {
+    throw new Error("auth.google.clientId is required when auth.mode is zklogin.");
+  }
+  if (!config.payment.evm) {
+    throw new Error("payment.evm configuration is required.");
+  }
+  if (!config.daemon.ipcPath || !config.daemon.dataDir || !config.daemon.pidFile) {
+    throw new Error("daemon configuration is incomplete.");
+  }
+  if (config.relay.enabled && config.relay.endpoints.length === 0) {
+    throw new Error("relay.endpoints must contain at least one entry when relay is enabled.");
+  }
+  for (const endpoint of config.relay.endpoints) {
+    if (!/^wss?:\/\//i.test(endpoint.url)) {
+      throw new Error(`Invalid relay endpoint URL: ${endpoint.url}`);
+    }
+  }
+  if (config.blobstore.mode === "filesystem" || config.blobstore.mode === "hybrid") {
+    if (!config.blobstore.filesystem?.dataDir) {
+      throw new Error("blobstore.filesystem.dataDir is required.");
+    }
+  }
+  if (config.blobstore.mode === "walrus" || config.blobstore.mode === "hybrid") {
+    if (!config.blobstore.walrus?.publisherUrl || !config.blobstore.walrus.aggregatorUrl) {
+      throw new Error("blobstore.walrus.publisherUrl and blobstore.walrus.aggregatorUrl are required.");
+    }
+  }
+  if (!LOG_LEVELS.has(config.daemon.logLevel)) {
+    throw new Error(`Invalid log level: ${config.daemon.logLevel}`);
+  }
+  if (config.encryption.requireEncryption && !config.encryption.enabled) {
+    throw new Error("encryption.requireEncryption cannot be true when encryption.enabled is false.");
+  }
+}
+function serializeConfig(config) {
+  return serializeValue(config);
+}
+function serializeValue(value) {
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => serializeValue(entry));
+  }
+  if (isRecord(value)) {
+    return Object.fromEntries(
+      Object.entries(value).filter(([, entry]) => entry !== void 0).map(([key, entry]) => [key, serializeValue(entry)])
+    );
+  }
+  return value;
+}
+function normalizeLogLevel(value, fallback) {
+  return typeof value === "string" && LOG_LEVELS.has(value) ? value : fallback;
+}
+function normalizeRail(value) {
+  if (value === PaymentRail.SUI_ESCROW || value === PaymentRail.SUI_TRANSFER || value === PaymentRail.X402_BASE) {
+    return value;
+  }
+  return void 0;
+}
+function parseBigInt(value, field) {
+  if (typeof value === "bigint") {
+    return value;
+  }
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) {
+    return BigInt(value);
+  }
+  if (typeof value === "string" && /^\d+$/.test(value.trim())) {
+    return BigInt(value.trim());
+  }
+  throw new Error(`${field} must be a non-negative integer.`);
+}
+function getEnvDataDir() {
+  return process.env.COLLECTIVE_DATA_DIR ? normalizePath(process.env.COLLECTIVE_DATA_DIR) : void 0;
+}
+function getNestedValue(record, ...keys) {
+  let current = record;
+  for (const key of keys) {
+    if (!isRecord(current)) {
+      return void 0;
+    }
+    current = current[key];
+  }
+  return current;
+}
+function normalizePath(value) {
+  return resolve(expandHome(value));
+}
+function expandHome(value) {
+  if (value === "~") {
+    return homedir();
+  }
+  if (value.startsWith("~/") || value.startsWith("~\\")) {
+    return join(homedir(), value.slice(2));
+  }
+  return value;
+}
+function resolveNetworkFromConfig(network, defaults) {
+  const nameField = readString(network.name);
+  const preset = nameField ? getNetworkPreset(nameField) : void 0;
+  const base = preset ?? defaults;
+  return {
+    rpcUrl: readString(network.rpcUrl) ?? base.rpcUrl,
+    faucetUrl: readString(network.faucetUrl) ?? base.faucetUrl,
+    packageId: readHexString(network.packageId) ?? base.packageId,
+    registryId: readHexString(network.registryId) ?? base.registryId
+  };
+}
+function readString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readBoolean(value) {
+  return typeof value === "boolean" ? value : void 0;
+}
+function readPositiveInteger(value, field) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) {
+    return value;
+  }
+  if (typeof value === "string" && /^\d+$/.test(value.trim())) {
+    return Number(value.trim());
+  }
+  throw new Error(`${field} must be a non-negative integer.`);
+}
+function readHexString(value) {
+  if (typeof value === "string" && value.trim()) {
+    return value.trim();
+  }
+  if (typeof value === "number" && Number.isSafeInteger(value) && value >= 0) {
+    return `0x${value.toString(16)}`;
+  }
+  return void 0;
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+export {
+  configIo,
+  getDefaultConfig,
+  getConfigPath,
+  loadConfig,
+  saveConfig
+};
+//# sourceMappingURL=chunk-CJHYQ7RR.js.map