@xyo-network/xl1-cli-lib 1.22.0 → 1.23.2

package/dist/node/xl1.mjs

@@ -1,22 +1,30 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
 // src/start.ts
 import { config } from "dotenv";
 
 // src/runCLI.ts
-import { stdin as input, stdout as output } from "process";
-import { createInterface } from "readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { createInterface } from "node:readline/promises";
 import { isDefined as isDefined3 } from "@xylabs/sdk-js";
 import { apiCommand } from "@xyo-network/chain-api";
 import { bridgeCommand } from "@xyo-network/chain-bridge";
 import { finalizerCommand } from "@xyo-network/chain-finalizer";
 import { mempoolCommand } from "@xyo-network/chain-mempool";
-import { contextFromConfigWithoutLocator, detectDerivationPathCollisions, formatWalletReport, initializeResolvedWalletReport, locatorsFromConfig, Orchestrator } from "@xyo-network/chain-orchestration";
+import {
+  contextFromConfigWithoutLocator,
+  detectDerivationPathCollisions,
+  formatWalletReport,
+  initializeResolvedWalletReport,
+  locatorsFromConfig,
+  Orchestrator
+} from "@xyo-network/chain-orchestration";
 import { initHealthEndpoints } from "@xyo-network/chain-orchestration-express";
 import { producerCommand } from "@xyo-network/chain-producer";
 import { rewardRedemptionCommand } from "@xyo-network/chain-reward-redemption";
-import { ActorConfigZod, ConfigZod as ConfigZod2, DefaultMetricsScrapePorts } from "@xyo-network/xl1-sdk";
+import {
+  ActorConfigZod,
+  ConfigZod as ConfigZod2,
+  DefaultMetricsScrapePorts
+} from "@xyo-network/xl1-sdk";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 
@@ -25,13 +33,26 @@ import { getApiActor } from "@xyo-network/chain-api";
 import { getBridgeActor } from "@xyo-network/chain-bridge";
 import { getFinalizerActor } from "@xyo-network/chain-finalizer";
 import { getMempoolActor } from "@xyo-network/chain-mempool";
-import { ApiConfigZod, BridgeConfigZod, FinalizerConfigZod, MempoolConfigZod, ProducerConfigZod, RewardRedemptionConfigZod } from "@xyo-network/chain-orchestration";
+import {
+  ApiConfigZod,
+  BridgeConfigZod,
+  FinalizerConfigZod,
+  MempoolConfigZod,
+  ProducerConfigZod,
+  RewardRedemptionConfigZod
+} from "@xyo-network/chain-orchestration";
 import { getProducerActor } from "@xyo-network/chain-producer";
 import { getRewardRedemptionActor } from "@xyo-network/chain-reward-redemption";
 
 // src/initLogger.ts
-import { Base, ConsoleLogger, isDefined, LogLevel, SilentLogger } from "@xylabs/sdk-js";
-var initLogger = /* @__PURE__ */ __name((config2) => {
+import {
+  Base,
+  ConsoleLogger,
+  isDefined,
+  LogLevel,
+  SilentLogger
+} from "@xylabs/sdk-js";
+var initLogger = (config2) => {
   let logger;
   if (config2.log.silent) {
     logger = new SilentLogger();
@@ -45,31 +66,18 @@ var initLogger = /* @__PURE__ */ __name((config2) => {
   }
   Base.defaultLogger = logger;
   return logger;
-}, "initLogger");
+};
 
 // src/commands/start/startCommand.ts
-var KNOWN_ACTORS = [
-  "api",
-  "bridge",
-  "finalizer",
-  "mempool",
-  "producer",
-  "rewardRedemption"
-];
+var KNOWN_ACTORS = ["api", "bridge", "finalizer", "mempool", "producer", "rewardRedemption"];
 var BOOT_TIMEOUT_MS = 6e4;
 function getActorsFromConfig(configuration2) {
   const enabledActors = configuration2.actors.filter((actor) => actor.enabled !== false).map((actor) => actor.name);
   return enabledActors.length > 0 ? enabledActors : void 0;
 }
-__name(getActorsFromConfig, "getActorsFromConfig");
 function getDefaultActors() {
-  return [
-    "api",
-    "producer",
-    "finalizer"
-  ];
+  return ["api", "producer", "finalizer"];
 }
-__name(getDefaultActors, "getDefaultActors");
 async function buildActor(name, locator) {
   switch (name) {
     case "api": {
@@ -101,7 +109,6 @@ async function buildActor(name, locator) {
     }
   }
 }
-__name(buildActor, "buildActor");
 async function bootActors(requestedActors, locators, orchestrator, configuration2) {
   const startedAt = Date.now();
   const actors = await Promise.all(requestedActors.map((name) => buildActor(name, locators[name])));
@@ -111,39 +118,34 @@ async function bootActors(requestedActors, locators, orchestrator, configuration
   await orchestrator.start();
   await orchestrator.whenReady(BOOT_TIMEOUT_MS);
   const ms = Date.now() - startedAt;
-  initLogger(configuration2).info(`[xl1] system ready (${requestedActors.length} actor${requestedActors.length === 1 ? "" : "s"}, ${ms}ms)`);
+  initLogger(configuration2).info(`[xl1] system ready (${requestedActors.join("/")} in ${ms}ms)`);
 }
-__name(bootActors, "bootActors");
 function startCommand(getConfiguration2, getLocatorsFromConfig2) {
   return {
-    command: [
-      "start [actors..]",
-      "$0"
-    ],
+    command: ["start [actors..]", "$0"],
     describe: "Run a full XL1 Node",
-    builder: /* @__PURE__ */ __name((yargs2) => {
+    builder: (yargs2) => {
       return yargs2.positional("actors", {
         type: "string",
         array: true,
         choices: KNOWN_ACTORS,
         description: "Actors to start (e.g. xl1 start api producer or xl1 start api,producer)",
-        coerce: /* @__PURE__ */ __name((values) => values.flatMap((v) => v.split(",")), "coerce")
+        coerce: (values) => values.flatMap((v) => v.split(","))
       }).option("actors", {
         type: "array",
         string: true,
         choices: KNOWN_ACTORS,
         description: "List of actors to start (e.g. --actors api producer finalizer). Defaults to api, producer, and finalizer."
       });
-    }, "builder"),
-    handler: /* @__PURE__ */ __name(async (argv) => {
+    },
+    handler: async (argv) => {
       const configuration2 = getConfiguration2();
       const requestedActors = argv.actors !== void 0 && argv.actors.length > 0 ? argv.actors : getActorsFromConfig(configuration2) ?? getDefaultActors();
       const { locators, orchestrator } = await getLocatorsFromConfig2(requestedActors, configuration2);
       await bootActors(requestedActors, locators, orchestrator, configuration2);
-    }, "handler")
+    }
   };
 }
-__name(startCommand, "startCommand");
 
 // src/commands/withDeprecationWarning.ts
 import { delay } from "@xylabs/sdk-js";
@@ -152,53 +154,76 @@ function withDeprecationWarning(module) {
   if (typeof deprecated === "string") {
     return {
       ...module,
-      handler: /* @__PURE__ */ __name(async (argv) => {
+      handler: async (argv) => {
         console.warn(`[deprecated] ${deprecated}`);
         await delay(3e3);
         return handler(argv);
-      }, "handler")
+      }
     };
   }
   return module;
 }
-__name(withDeprecationWarning, "withDeprecationWarning");
 
 // src/configMiddleware.ts
 import { createDeepMerge, isDefined as isDefined2 } from "@xylabs/sdk-js";
-import { ActorMnemonicNotAllowedError, assertNoActorMnemonics, ConfigFileNotFoundError, tryParseConfig } from "@xyo-network/chain-orchestration";
-import { ConfigZod, isZodError, resolveConfig } from "@xyo-network/xl1-sdk";
-var deepMerge = createDeepMerge({
-  arrayStrategy: "concat"
-});
+import {
+  ActorMnemonicNotAllowedError,
+  assertNoActorMnemonics,
+  ConfigFileNotFoundError,
+  tryParseConfig
+} from "@xyo-network/chain-orchestration";
+import {
+  ConfigZod,
+  isZodError,
+  resolveConfig
+} from "@xyo-network/xl1-sdk";
+var deepMerge = createDeepMerge({ arrayStrategy: "concat" });
+var REDACTED = "[REDACTED]";
+var REDACTED_KEY_NAMES = /* @__PURE__ */ new Set(["mnemonic", "connectionString"]);
+var REDACTED_KEY_SUFFIX = /(PrivateKey|Secret|Password)$/i;
+function shouldRedactKey(key) {
+  if (REDACTED_KEY_NAMES.has(key)) return true;
+  return REDACTED_KEY_SUFFIX.test(key);
+}
+function redactConfig(config2) {
+  const cloned = structuredClone(config2);
+  redactInPlace(cloned);
+  return cloned;
+}
+function redactInPlace(node) {
+  if (Array.isArray(node)) {
+    for (const item of node) redactInPlace(item);
+    return;
+  }
+  if (node === null || typeof node !== "object") return;
+  const obj = node;
+  for (const key of Object.keys(obj)) {
+    if (shouldRedactKey(key) && obj[key] !== void 0 && obj[key] !== null) {
+      obj[key] = REDACTED;
+    } else {
+      redactInPlace(obj[key]);
+    }
+  }
+}
 function coerceActorsArray(argv) {
   const actors = argv.actors;
   if (actors === void 0 || Array.isArray(actors)) return argv;
   if (typeof actors !== "object" || actors === null) return argv;
   const entries = Object.entries(actors);
-  const numericEntries = entries.map(([key, value]) => [
-    Number(key),
-    value
-  ]).filter(([key]) => Number.isInteger(key) && key >= 0);
+  const numericEntries = entries.map(([key, value]) => [Number(key), value]).filter(([key]) => Number.isInteger(key) && key >= 0);
   if (numericEntries.length !== entries.length) return argv;
   const asArray = [];
   for (const [key, value] of numericEntries) asArray[key] = value;
-  return {
-    ...argv,
-    actors: asArray
-  };
+  return { ...argv, actors: asArray };
 }
-__name(coerceActorsArray, "coerceActorsArray");
 function safeParseOrThrow(input2) {
   const result = ConfigZod.safeParse(input2);
   if (!result.success) throw result.error;
   return result.data;
 }
-__name(safeParseOrThrow, "safeParseOrThrow");
 async function buildFinalConfig(argv) {
   const configPath = argv.config;
-  const parsedConfigFile = await tryParseConfig({
-    configPath
-  });
+  const parsedConfigFile = await tryParseConfig({ configPath });
   const rootMnemonicFromFile = typeof parsedConfigFile.mnemonic === "string" ? parsedConfigFile.mnemonic : void 0;
   const normalizedArgv = coerceActorsArray(argv);
   const parsedConfigArgs = ConfigZod.safeParse(normalizedArgv).data ?? {};
@@ -206,19 +231,17 @@ async function buildFinalConfig(argv) {
   const mergedConfig = safeParseOrThrow(deepMerge(parsedConfigFile, parsedConfigArgs));
   const validated = safeParseOrThrow(resolveConfig(safeParseOrThrow(mergedConfig)));
   const rootMnemonic = rootMnemonicFromArgs ?? rootMnemonicFromFile;
-  return isDefined2(rootMnemonic) ? {
-    ...validated,
-    mnemonic: rootMnemonic
-  } : validated;
+  return isDefined2(rootMnemonic) ? { ...validated, mnemonic: rootMnemonic } : validated;
 }
-__name(buildFinalConfig, "buildFinalConfig");
 async function configMiddleware(argv, setConfiguration) {
   try {
     const finalConfig = await buildFinalConfig(argv);
     assertNoActorMnemonics(finalConfig);
     setConfiguration(finalConfig);
     if (argv["dump-config"]) {
-      console.log(JSON.stringify(finalConfig, null, 2));
+      const withSecrets = Boolean(argv["with-secrets"]);
+      const output2 = withSecrets ? finalConfig : redactConfig(finalConfig);
+      console.log(JSON.stringify(output2, null, 2));
       process.exit(0);
     }
   } catch (err) {
@@ -234,12 +257,141 @@ async function configMiddleware(argv, setConfiguration) {
     if (!(err instanceof ConfigFileNotFoundError) && !(err instanceof ActorMnemonicNotAllowedError)) {
       console.error(`Stack: ${err instanceof Error ? err.stack : "N/A"}`);
     }
-    throw new Error("Invalid configuration", {
-      cause: err
-    });
+    throw new Error("Invalid configuration", { cause: err });
   }
 }
-__name(configMiddleware, "configMiddleware");
+
+// src/dumpProviders.ts
+var CANONICAL_ACTOR_ORDER = [
+  "_root",
+  "producer",
+  "finalizer",
+  "api",
+  "mempool",
+  "bridge",
+  "rewardRedemption"
+];
+function enumerateLocator(locator) {
+  const collapsed = /* @__PURE__ */ new Map();
+  const registry = locator.registry;
+  for (const moniker of Object.keys(registry)) {
+    const factories = registry[moniker];
+    if (!factories) continue;
+    for (const factory of factories) {
+      const f = factory;
+      const providerName = f.providerName ?? "<unknown>";
+      const scope = f.scope ?? "<unknown>";
+      const dependencies = f.dependencies ?? [];
+      const fingerprint = `${moniker}|${providerName}|${scope}|${dependencies.join(",")}`;
+      const existing = collapsed.get(fingerprint);
+      if (existing) {
+        existing.count += 1;
+      } else {
+        collapsed.set(fingerprint, {
+          count: 1,
+          dependencies,
+          moniker,
+          providerName,
+          scope
+        });
+      }
+    }
+  }
+  return [...collapsed.values()].toSorted((a, b) => a.moniker.localeCompare(b.moniker) || a.providerName.localeCompare(b.providerName));
+}
+function buildOwnerIndex(perActor) {
+  const monikerOwners = /* @__PURE__ */ new Map();
+  for (const [actorName, entries] of perActor) {
+    for (const entry of entries) {
+      let owners = monikerOwners.get(entry.moniker);
+      if (!owners) {
+        owners = /* @__PURE__ */ new Set();
+        monikerOwners.set(entry.moniker, owners);
+      }
+      owners.add(actorName);
+    }
+  }
+  return monikerOwners;
+}
+function renderDuplicatesSummary(monikerOwners) {
+  const duplicates = [...monikerOwners.entries()].filter(([, owners]) => owners.size > 1).map(([moniker, owners]) => ({ moniker, owners: [...owners].toSorted().map(formatGroupForDisplay) })).toSorted((a, b) => a.moniker.localeCompare(b.moniker));
+  if (duplicates.length === 0) return [];
+  const lines = ["Duplicate monikers (registered by more than one locator):"];
+  for (const { moniker, owners } of duplicates) {
+    lines.push(`  - ${moniker}: ${owners.join(", ")}`);
+  }
+  lines.push("");
+  return lines;
+}
+function groupActorsBySharedRegistry(locators) {
+  const groups = [];
+  for (const actorName of Object.keys(locators)) {
+    const locator = locators[actorName];
+    const existing = groups.find((g) => g.registry === locator.registry);
+    if (existing) {
+      existing.actorNames.push(actorName);
+    } else {
+      groups.push({
+        actorNames: [actorName],
+        locator,
+        registry: locator.registry
+      });
+    }
+  }
+  return groups;
+}
+function groupId(actorNames) {
+  return [...actorNames].toSorted().join(",");
+}
+function formatGroupForDisplay(groupKey) {
+  const members = groupKey.split(",");
+  return members.length === 1 ? members[0] : `(${members.join(", ")})`;
+}
+function renderGroupSection(actorNames, entries, monikerOwners) {
+  const sortedActors = [...actorNames].toSorted();
+  const ownGroupKey = groupId(sortedActors);
+  const heading = sortedActors.length === 1 ? `Providers for actor: ${sortedActors[0]}  (${entries.length} registered)` : `Providers shared by actors: ${sortedActors.join(", ")}  (${entries.length} registered)`;
+  const lines = [heading];
+  if (entries.length === 0) {
+    lines.push("  (none)", "");
+    return lines;
+  }
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    const isLast = i === entries.length - 1;
+    const branch = isLast ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500";
+    const owners = monikerOwners.get(entry.moniker) ?? /* @__PURE__ */ new Set();
+    const otherOwners = [...owners].filter((o) => o !== ownGroupKey).toSorted().map(formatGroupForDisplay);
+    const dupNote = otherOwners.length > 0 ? `   \u26A0 also in: ${otherOwners.join(", ")}` : "";
+    const depsNote = entry.dependencies.length > 0 ? `, deps: [${entry.dependencies.join(", ")}]` : "";
+    const countNote = entry.count > 1 ? ` (\xD7${entry.count})` : "";
+    lines.push(`  ${branch} ${entry.moniker}${countNote}  [impl: ${entry.providerName}, scope: ${entry.scope}${depsNote}]${dupNote}`);
+  }
+  lines.push("");
+  return lines;
+}
+function formatProviderTree(locators) {
+  const groups = groupActorsBySharedRegistry(locators);
+  const groupKeys = groups.map((g) => ({ ...g, key: groupId(g.actorNames) }));
+  const perGroup = /* @__PURE__ */ new Map();
+  for (const g of groupKeys) perGroup.set(g.key, enumerateLocator(g.locator));
+  const monikerOwners = buildOwnerIndex(perGroup);
+  const orderedGroups = [...groupKeys].toSorted((a, b) => {
+    const aHasRoot = a.actorNames.includes("_root");
+    const bHasRoot = b.actorNames.includes("_root");
+    if (aHasRoot !== bHasRoot) return aHasRoot ? -1 : 1;
+    const ai = CANONICAL_ACTOR_ORDER.indexOf(a.actorNames[0]);
+    const bi = CANONICAL_ACTOR_ORDER.indexOf(b.actorNames[0]);
+    if (ai !== bi) return (ai === -1 ? Number.MAX_SAFE_INTEGER : ai) - (bi === -1 ? Number.MAX_SAFE_INTEGER : bi);
+    return a.key.localeCompare(b.key);
+  });
+  const lines = ["XL1 Provider Dump", "=================", ""];
+  for (const g of orderedGroups) {
+    lines.push(...renderGroupSection(g.actorNames.toSorted(), perGroup.get(g.key) ?? [], monikerOwners));
+  }
+  lines.push(...renderDuplicatesSummary(monikerOwners));
+  return lines.join("\n");
+}
 
 // src/images.ts
 var XL1LogoColorizedAscii = `\x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\xA0\x1B[0m\x1B[38;2;118;111;144m_\x1B[0m
@@ -264,10 +416,10 @@ var XL1LogoColorizedAscii = `\x1B[38;2;128;128;128m\xA0\xA0\xA0\xA0\xA0\xA0\xA0\
 // src/optionsFromGlobalZodRegistry.ts
 import { isUsageMeta } from "@xyo-network/xl1-sdk";
 import { globalRegistry } from "zod";
-var usageMetaToOptions = /* @__PURE__ */ __name((meta) => {
+var usageMetaToOptions = (meta) => {
   return meta;
-}, "usageMetaToOptions");
-var optionsFromGlobalZodRegistry = /* @__PURE__ */ __name(() => {
+};
+var optionsFromGlobalZodRegistry = () => {
   const opts = {};
   for (const schema of Object.values(globalRegistry._map)) {
     if (isUsageMeta(schema)) {
@@ -276,7 +428,7 @@ var optionsFromGlobalZodRegistry = /* @__PURE__ */ __name(() => {
     }
   }
   return opts;
-}, "optionsFromGlobalZodRegistry");
+};
 
 // src/runCLI.ts
 var DEFAULT_HEALTH_CHECK_PORT = 9090;
@@ -285,30 +437,25 @@ function defaultScrapePortForActors(actors) {
   const key = primary === "rewardRedemption" ? "rewardRedemptionApi" : primary;
   return DefaultMetricsScrapePorts[key] ?? DefaultMetricsScrapePorts.producer;
 }
-__name(defaultScrapePortForActors, "defaultScrapePortForActors");
 var configuration;
 var skipInsecureConfirm = false;
-var version = isDefined3("1.22.0") ? "1.22.0" : "unknown";
+var dumpProviders = false;
+var version = isDefined3("1.23.2") ? "1.23.2" : "unknown";
 function getConfiguration() {
   return configuration;
 }
-__name(getConfiguration, "getConfiguration");
 async function promptForInsecureGenesisConfirmation(logger) {
   if (!input.isTTY || !output.isTTY) {
     logger.warn("Insecure genesis reward wallet is active. Interactive confirmation skipped because this session is not a TTY.");
     return;
   }
-  const rl = createInterface({
-    input,
-    output
-  });
+  const rl = createInterface({ input, output });
   try {
     await rl.question("Insecure genesis reward wallet is active. Hit RETURN to continue.");
   } finally {
     rl.close();
   }
 }
-__name(promptForInsecureGenesisConfirmation, "promptForInsecureGenesisConfirmation");
 async function getLocatorsFromConfig(actors, configuration2) {
   const actorConfigs = [];
   for (const actorName of actors) {
@@ -316,20 +463,13 @@ async function getLocatorsFromConfig(actors, configuration2) {
     if (existingConfig) {
       actorConfigs.push(existingConfig);
     } else {
-      const actorConfig = ActorConfigZod.loose().parse({
-        name: actorName
-      });
+      const actorConfig = ActorConfigZod.loose().parse({ name: actorName });
       actorConfigs.push(actorConfig);
     }
   }
-  const config2 = ConfigZod2.parse({
-    ...configuration2,
-    actors: actorConfigs
-  });
+  const config2 = ConfigZod2.parse({ ...configuration2, actors: actorConfigs });
   const logger = initLogger(configuration2);
-  const orchestrator = await Orchestrator.create({
-    logger
-  });
+  const orchestrator = await Orchestrator.create({ logger });
   const collision = detectDerivationPathCollisions(actors, configuration2);
   if (collision) throw collision;
   const walletReport = await initializeResolvedWalletReport(actors, configuration2);
@@ -341,6 +481,10 @@ async function getLocatorsFromConfig(actors, configuration2) {
   }
   const onInsecureGenesisConfirm = skipInsecureConfirm ? void 0 : async () => await promptForInsecureGenesisConfirmation(logger);
   const locators = await locatorsFromConfig(context, config2, onInsecureGenesisConfirm);
+  if (dumpProviders) {
+    console.log(formatProviderTree(locators));
+    process.exit(0);
+  }
   const healthCheckPort = configuration2.healthCheckPort ?? DEFAULT_HEALTH_CHECK_PORT;
   const healthServer = healthCheckPort > 0 && context.statusReporter !== void 0 ? await initHealthEndpoints({
     logger,
@@ -362,12 +506,8 @@ async function getLocatorsFromConfig(actors, configuration2) {
       }
     })();
   });
-  return {
-    locators,
-    orchestrator
-  };
+  return { locators, orchestrator };
 }
-__name(getLocatorsFromConfig, "getLocatorsFromConfig");
 async function runCLI() {
   const y = yargs(hideBin(process.argv));
   const argv = y.usage(`
@@ -378,13 +518,17 @@ Run various components of the XL1 ecosystem.
 Usage:
 $0 <command> [options]`).parserConfiguration({
     "dot-notation": true,
+    // foo.bar → { foo: { bar } }
     "parse-numbers": false,
+    // Don't auto-parse numbers to allow strings like "0x1"
     "populate--": true
+    // Populate -- with all options so we can detected user-supplied vs defaults
   }).env("XL1").scriptName("xl1").middleware(async (argv2) => {
     await configMiddleware(argv2, (config2) => {
       configuration = config2;
     });
     skipInsecureConfirm = Boolean(argv2["skip-insecure-confirm"]);
+    dumpProviders = Boolean(argv2["dump-providers"]);
   }).options(optionsFromGlobalZodRegistry()).wrap(y.terminalWidth()).command(withDeprecationWarning(apiCommand(getConfiguration, getLocatorsFromConfig))).command(withDeprecationWarning(bridgeCommand(getConfiguration, getLocatorsFromConfig))).command(withDeprecationWarning(finalizerCommand(getConfiguration, getLocatorsFromConfig))).command(withDeprecationWarning(mempoolCommand(getConfiguration, getLocatorsFromConfig))).command(withDeprecationWarning(producerCommand(getConfiguration, getLocatorsFromConfig))).command(withDeprecationWarning(rewardRedemptionCommand(getConfiguration, getLocatorsFromConfig))).command(startCommand(getConfiguration, getLocatorsFromConfig)).options({
     "config": {
       type: "string",
@@ -397,7 +541,17 @@ $0 <command> [options]`).parserConfiguration({
     },
     "dump-config": {
       type: "boolean",
-      description: "Just process the configuration and print the resolved config to stdout, then exit.",
+      description: "Just process the configuration and print the resolved config to stdout, then exit. Secrets are redacted unless --with-secrets is also passed.",
+      default: false
+    },
+    "with-secrets": {
+      type: "boolean",
+      description: 'When used with --dump-config, print raw secret values (mnemonic, private keys, passwords) instead of "[REDACTED]". Use only on a developer machine.',
+      default: false
+    },
+    "dump-providers": {
+      type: "boolean",
+      description: "Run the normal command flow up to provider locator construction, print the per-actor provider tree (with duplicate detection), then exit.",
       default: false
     },
     "skip-insecure-confirm": {
@@ -408,19 +562,16 @@ $0 <command> [options]`).parserConfiguration({
   }).help().alias("help", "h").version(version).argv;
   await argv;
 }
-__name(runCLI, "runCLI");
 
 // src/start.ts
-var start = /* @__PURE__ */ __name(async () => {
-  config({
-    quiet: true
-  });
+var start = async () => {
+  config({ quiet: true });
   await runCLI();
-}, "start");
+};
 
 // src/xl1.ts
 start().catch((err) => {
   if (process.env.NODE_ENV === "development") console.error("An error occurred during startup:", err);
   process.exit(1);
 });
-//# sourceMappingURL=xl1.mjs.map
+//# sourceMappingURL=xl1.mjs.map