@xyo-network/xl1-cli-lib 1.20.5 → 1.20.9

package/dist/node/xl1.mjs

@@ -5,21 +5,70 @@ var __name = (target, value) => __defProp(target, "name", { value, configurable:
 import { config } from "dotenv";
 
 // src/runCLI.ts
-import { createDeepMerge, isDefined as isDefined2 } from "@xylabs/sdk-js";
-import { getApiActor, runApi } from "@xyo-network/chain-api";
-import { getMempoolActor, runMempool } from "@xyo-network/chain-mempool";
-import { ApiConfigZod, BridgeConfigZod, contextFromConfigWithoutLocator, locatorsFromConfig, MempoolConfigZod, Orchestrator, ProducerConfigZod, RewardRedemptionConfigZod, tryParseConfig, ValidatorConfigZod } from "@xyo-network/chain-orchestration";
-import { runProducer } from "@xyo-network/chain-producer";
-import { ActorConfigZod, ConfigZod, isZodError, resolveConfig } from "@xyo-network/xl1-sdk";
+import { isDefined as isDefined2 } from "@xylabs/sdk-js";
+import { contextFromConfigWithoutLocator, locatorsFromConfig, Orchestrator } from "@xyo-network/chain-orchestration";
+import { ActorConfigZod, ConfigZod as ConfigZod2 } from "@xyo-network/xl1-sdk";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 
-// src/commands/bridge/runBridge.ts
+// src/commands/api/apiCommand.ts
+import { getApiActor } from "@xyo-network/chain-api";
+import { getMempoolActor } from "@xyo-network/chain-mempool";
+import { ApiConfigZod, MempoolConfigZod, ValidatorConfigZod } from "@xyo-network/chain-orchestration";
+
+// src/commands/validator/runValidator.ts
 import { exists } from "@xylabs/sdk-js";
+import { initActorWallet, ValidatorActor } from "@xyo-network/chain-orchestration";
+var getValidatorActor = /* @__PURE__ */ __name(async (config2, locator) => {
+  const account = await initActorWallet({
+    config: config2,
+    logger: locator.context.logger,
+    singletons: {},
+    caches: {}
+  });
+  return await ValidatorActor.create({
+    account,
+    config: config2,
+    locator
+  });
+}, "getValidatorActor");
+
+// src/commands/api/apiCommand.ts
+function apiCommand(getConfiguration2, getLocatorsFromConfig2) {
+  return {
+    command: "api",
+    deprecated: 'Use "start api" instead',
+    describe: "Run a XL1 API Node",
+    handler: /* @__PURE__ */ __name(async () => {
+      const configuration2 = getConfiguration2();
+      const { locators, orchestrator } = await getLocatorsFromConfig2([
+        "api",
+        "mempool",
+        "validator"
+      ], configuration2);
+      const actors = await Promise.all([
+        getApiActor(ApiConfigZod.parse(locators["api"].context.config), locators["api"]),
+        getMempoolActor(MempoolConfigZod.parse(locators["mempool"].context.config), locators["mempool"]),
+        getValidatorActor(ValidatorConfigZod.parse(locators["validator"].context.config), locators["validator"])
+      ]);
+      for (const actor of actors) {
+        await orchestrator.registerActor(actor);
+      }
+      await orchestrator.start();
+    }, "handler")
+  };
+}
+__name(apiCommand, "apiCommand");
+
+// src/commands/bridge/bridgeCommand.ts
+import { BridgeConfigZod } from "@xyo-network/chain-orchestration";
+
+// src/commands/bridge/runBridge.ts
+import { exists as exists2 } from "@xylabs/sdk-js";
 import { BridgeActor } from "@xyo-network/chain-bridge";
-import { initActorWallet } from "@xyo-network/chain-orchestration";
+import { initActorWallet as initActorWallet2 } from "@xyo-network/chain-orchestration";
 var getBridgeActor = /* @__PURE__ */ __name(async (config2, locator) => {
-  const account = await initActorWallet({
+  const account = await initActorWallet2({
     config: config2,
     logger: locator.context.logger,
     singletons: {},
@@ -35,19 +84,77 @@ var runBridge = /* @__PURE__ */ __name(async (config2, orchestrator, locator) =>
   const bridge = await getBridgeActor(config2, locator);
   const actors = [
     bridge
-  ].filter(exists);
+  ].filter(exists2);
   for (const actor of actors) {
     await orchestrator.registerActor(actor);
   }
   await orchestrator.start();
 }, "runBridge");
 
+// src/commands/bridge/bridgeCommand.ts
+function bridgeCommand(getConfiguration2, getLocatorsFromConfig2) {
+  return {
+    command: "bridge",
+    deprecated: 'Use "start bridge" instead',
+    describe: "Run a XL1 Bridge Node",
+    handler: /* @__PURE__ */ __name(async () => {
+      const configuration2 = getConfiguration2();
+      const { locators, orchestrator } = await getLocatorsFromConfig2([
+        "bridge"
+      ], configuration2);
+      await runBridge(BridgeConfigZod.parse(locators["bridge"].context.config), orchestrator, locators["bridge"]);
+    }, "handler")
+  };
+}
+__name(bridgeCommand, "bridgeCommand");
+
+// src/commands/mempool/mempoolCommand.ts
+import { runMempool } from "@xyo-network/chain-mempool";
+import { MempoolConfigZod as MempoolConfigZod2 } from "@xyo-network/chain-orchestration";
+function mempoolCommand(getConfiguration2, getLocatorsFromConfig2) {
+  return {
+    command: "mempool",
+    deprecated: 'Use "start mempool" instead',
+    describe: "Run a XL1 Mempool Node",
+    handler: /* @__PURE__ */ __name(async () => {
+      const configuration2 = getConfiguration2();
+      const { locators, orchestrator } = await getLocatorsFromConfig2([
+        "mempool"
+      ], configuration2);
+      await runMempool(MempoolConfigZod2.parse(locators["mempool"].context.config), orchestrator, locators["mempool"]);
+    }, "handler")
+  };
+}
+__name(mempoolCommand, "mempoolCommand");
+
+// src/commands/producer/producerCommand.ts
+import { ProducerConfigZod } from "@xyo-network/chain-orchestration";
+import { runProducer } from "@xyo-network/chain-producer";
+function producerCommand(getConfiguration2, getLocatorsFromConfig2) {
+  return {
+    command: "producer",
+    deprecated: 'Use "start producer" instead',
+    describe: "Run a XL1 Producer Node",
+    handler: /* @__PURE__ */ __name(async () => {
+      const configuration2 = getConfiguration2();
+      const { locators, orchestrator } = await getLocatorsFromConfig2([
+        "producer"
+      ], configuration2);
+      await runProducer(ProducerConfigZod.parse(locators["producer"].context.config), orchestrator, locators["producer"]);
+    }, "handler")
+  };
+}
+__name(producerCommand, "producerCommand");
+
+// src/commands/rewardRedemption/rewardRedemptionCommand.ts
+import { RewardRedemptionConfigZod } from "@xyo-network/chain-orchestration";
+
 // src/commands/rewardRedemption/runRewardRedemptionApi.ts
-import { exists as exists2 } from "@xylabs/sdk-js";
-import { initActorWallet as initActorWallet2 } from "@xyo-network/chain-orchestration";
+import { exists as exists3 } from "@xylabs/sdk-js";
+import { initActorWallet as initActorWallet3 } from "@xyo-network/chain-orchestration";
 import { RewardRedemptionActor } from "@xyo-network/chain-reward-redemption";
 async function getRewardRedemptionActor(config2, locator) {
-  const account = await initActorWallet2({
+  const account = await initActorWallet3({
     config: config2,
     logger: locator.context.logger,
     singletons: {},
@@ -64,7 +171,7 @@ async function runRewardRedemptionApi(config2, orchestrator, locator) {
   const rewardRedemption = await getRewardRedemptionActor(config2, locator);
   const actors = [
     rewardRedemption
-  ].filter(exists2);
+  ].filter(exists3);
   for (const actor of actors) {
     await orchestrator.registerActor(actor);
   }
@@ -72,22 +179,216 @@ async function runRewardRedemptionApi(config2, orchestrator, locator) {
 }
 __name(runRewardRedemptionApi, "runRewardRedemptionApi");
 
-// src/commands/validator/runValidator.ts
-import { exists as exists3 } from "@xylabs/sdk-js";
-import { initActorWallet as initActorWallet3, ValidatorActor } from "@xyo-network/chain-orchestration";
-var getValidatorActor = /* @__PURE__ */ __name(async (config2, locator) => {
-  const account = await initActorWallet3({
-    config: config2,
-    logger: locator.context.logger,
-    singletons: {},
-    caches: {}
-  });
-  return await ValidatorActor.create({
-    account,
-    config: config2,
-    locator
+// src/commands/rewardRedemption/rewardRedemptionCommand.ts
+function rewardRedemptionCommand(getConfiguration2, getLocatorsFromConfig2) {
+  return {
+    command: "reward-redemption-api",
+    deprecated: 'Use "start rewardRedemption" instead',
+    describe: "Run a XL1 Rewards Redemption API Node",
+    handler: /* @__PURE__ */ __name(async () => {
+      const configuration2 = getConfiguration2();
+      const { locators, orchestrator } = await getLocatorsFromConfig2([
+        "rewardRedemption"
+      ], configuration2);
+      await runRewardRedemptionApi(RewardRedemptionConfigZod.parse(locators["rewardRedemption"].context.config), orchestrator, locators["rewardRedemption"]);
+    }, "handler")
+  };
+}
+__name(rewardRedemptionCommand, "rewardRedemptionCommand");
+
+// src/commands/start/startCommand.ts
+import { getApiActor as getApiActor2 } from "@xyo-network/chain-api";
+import { getMempoolActor as getMempoolActor2 } from "@xyo-network/chain-mempool";
+import { ApiConfigZod as ApiConfigZod2, BridgeConfigZod as BridgeConfigZod2, MempoolConfigZod as MempoolConfigZod3, ProducerConfigZod as ProducerConfigZod2, RewardRedemptionConfigZod as RewardRedemptionConfigZod2, ValidatorConfigZod as ValidatorConfigZod2 } from "@xyo-network/chain-orchestration";
+import { runProducer as runProducer2 } from "@xyo-network/chain-producer";
+
+// src/waitForHostPort.ts
+import net from "net";
+var waitForHostPort = /* @__PURE__ */ __name((host, port) => {
+  return new Promise((resolve) => {
+    const tryConnect = /* @__PURE__ */ __name(() => {
+      const socket = new net.Socket();
+      socket.setTimeout(1e3).once("error", () => {
+        socket.destroy();
+        setTimeout(tryConnect, 500);
+      }).once("timeout", () => {
+        socket.destroy();
+        setTimeout(tryConnect, 500);
+      }).connect(port, host, () => {
+        socket.end();
+        resolve();
+      });
+    }, "tryConnect");
+    tryConnect();
   });
-}, "getValidatorActor");
+}, "waitForHostPort");
+
+// src/commands/start/startCommand.ts
+var KNOWN_ACTORS = [
+  "api",
+  "bridge",
+  "mempool",
+  "producer",
+  "rewardRedemption",
+  "validator"
+];
+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"
+  ];
+}
+__name(getDefaultActors, "getDefaultActors");
+async function startActor(name, locator, orchestrator) {
+  switch (name) {
+    case "api": {
+      const config2 = ApiConfigZod2.parse(locator.context.config);
+      const actor = await getApiActor2(config2, locator);
+      await orchestrator.registerActor(actor);
+      await orchestrator.start();
+      await waitForHostPort(config2.host, config2.port);
+      break;
+    }
+    case "bridge": {
+      const config2 = BridgeConfigZod2.parse(locator.context.config);
+      const actor = await getBridgeActor(config2, locator);
+      await orchestrator.registerActor(actor);
+      await orchestrator.start();
+      break;
+    }
+    case "mempool": {
+      const config2 = MempoolConfigZod3.parse(locator.context.config);
+      const actor = await getMempoolActor2(config2, locator);
+      await orchestrator.registerActor(actor);
+      await orchestrator.start();
+      await waitForHostPort(config2.host, config2.port);
+      break;
+    }
+    case "producer": {
+      const config2 = ProducerConfigZod2.parse(locator.context.config);
+      await runProducer2(config2, orchestrator, locator);
+      break;
+    }
+    case "rewardRedemption": {
+      const config2 = RewardRedemptionConfigZod2.parse(locator.context.config);
+      const actor = await getRewardRedemptionActor(config2, locator);
+      await orchestrator.registerActor(actor);
+      await orchestrator.start();
+      break;
+    }
+    case "validator": {
+      const config2 = ValidatorConfigZod2.parse(locator.context.config);
+      const actor = await getValidatorActor(config2, locator);
+      await orchestrator.registerActor(actor);
+      await orchestrator.start();
+      break;
+    }
+    default: {
+      throw new Error(`Unknown actor: ${name}`);
+    }
+  }
+}
+__name(startActor, "startActor");
+function startCommand(getConfiguration2, getLocatorsFromConfig2) {
+  return {
+    command: [
+      "start [actors..]",
+      "$0"
+    ],
+    describe: "Run a full XL1 Node",
+    builder: /* @__PURE__ */ __name((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")
+      }).option("actors", {
+        type: "array",
+        string: true,
+        choices: KNOWN_ACTORS,
+        description: "List of actors to start (e.g. --actors api producer mempool). Defaults to api, producer, and mempool if enabled."
+      });
+    }, "builder"),
+    handler: /* @__PURE__ */ __name(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);
+      for (const name of requestedActors) {
+        await startActor(name, locators[name], orchestrator);
+      }
+    }, "handler")
+  };
+}
+__name(startCommand, "startCommand");
+
+// src/commands/withDeprecationWarning.ts
+import { delay } from "@xylabs/sdk-js";
+function withDeprecationWarning(module) {
+  const { deprecated, handler } = module;
+  if (typeof deprecated === "string") {
+    return {
+      ...module,
+      handler: /* @__PURE__ */ __name(async (argv) => {
+        console.warn(`[deprecated] ${deprecated}`);
+        await delay(3e3);
+        return handler(argv);
+      }, "handler")
+    };
+  }
+  return module;
+}
+__name(withDeprecationWarning, "withDeprecationWarning");
+
+// src/configMiddleware.ts
+import { createDeepMerge } from "@xylabs/sdk-js";
+import { tryParseConfig } from "@xyo-network/chain-orchestration";
+import { ConfigZod, isZodError, resolveConfig } from "@xyo-network/xl1-sdk";
+var deepMerge = createDeepMerge({
+  arrayStrategy: "concat"
+});
+async function configMiddleware(argv, setConfiguration) {
+  try {
+    const configPath = argv.config;
+    const parsedConfigFile = await tryParseConfig({
+      configPath
+    });
+    const parsedConfigArgs = ConfigZod.safeParse(argv).data ?? {};
+    const parseResult = ConfigZod.safeParse(deepMerge(parsedConfigFile, parsedConfigArgs));
+    if (!parseResult.success) {
+      throw parseResult.error;
+    }
+    const mergedConfig = parseResult.data;
+    const validatedMergedConfigResult = ConfigZod.safeParse(mergedConfig);
+    if (!validatedMergedConfigResult.success) {
+      throw validatedMergedConfigResult.error;
+    }
+    const resolvedConfig = resolveConfig(validatedMergedConfigResult.data);
+    const validatedConfigResult = ConfigZod.safeParse(resolvedConfig);
+    if (!validatedConfigResult.success) {
+      throw validatedConfigResult.error;
+    }
+    setConfiguration(validatedConfigResult.data);
+    if (argv["dump-config"]) {
+      console.log(JSON.stringify(validatedConfigResult.data, null, 2));
+      process.exit(0);
+    }
+  } catch (err) {
+    if (isZodError(err)) {
+      console.error(`Zod error: ${err.message}`);
+    } else {
+      console.error(`Error parsing configuration: ${err}`);
+    }
+    console.error(`Stack: ${err instanceof Error ? err.stack : "N/A"}`);
+    throw new Error("Invalid configuration");
+  }
+}
+__name(configMiddleware, "configMiddleware");
 
 // 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
@@ -144,52 +445,30 @@ var optionsFromGlobalZodRegistry = /* @__PURE__ */ __name(() => {
   return opts;
 }, "optionsFromGlobalZodRegistry");
 
-// src/waitForHostPort.ts
-import net from "net";
-var waitForHostPort = /* @__PURE__ */ __name((host, port) => {
-  return new Promise((resolve) => {
-    const tryConnect = /* @__PURE__ */ __name(() => {
-      const socket = new net.Socket();
-      socket.setTimeout(1e3).once("error", () => {
-        socket.destroy();
-        setTimeout(tryConnect, 500);
-      }).once("timeout", () => {
-        socket.destroy();
-        setTimeout(tryConnect, 500);
-      }).connect(port, host, () => {
-        socket.end();
-        resolve();
-      });
-    }, "tryConnect");
-    tryConnect();
-  });
-}, "waitForHostPort");
-
 // src/runCLI.ts
 var configuration;
-var version = isDefined2("1.20.4") ? "1.20.4" : "unknown";
-var deepMerge = createDeepMerge({
-  arrayStrategy: "concat"
-});
+var version = isDefined2("1.20.8") ? "1.20.8" : "unknown";
+function getConfiguration() {
+  return configuration;
+}
+__name(getConfiguration, "getConfiguration");
 async function getLocatorsFromConfig(actors, configuration2) {
   const actorConfigs = [];
   for (const actorName of actors) {
-    const rawConfig = configuration2.actors.find((actor) => actor.name === actorName) ?? {
-      name: actorName
-    };
-    const actorConfig = ActorConfigZod.loose().parse(rawConfig);
-    actorConfigs.push(actorConfig);
+    const existingConfig = configuration2.actors.find((actor) => actor.name === actorName);
+    if (existingConfig) {
+      actorConfigs.push(existingConfig);
+    } else {
+      const actorConfig = ActorConfigZod.loose().parse({
+        name: actorName
+      });
+      actorConfigs.push(actorConfig);
+    }
   }
-  const config2 = ConfigZod.parse(deepMerge(configuration2, {
+  const config2 = ConfigZod2.parse({
+    ...configuration2,
     actors: actorConfigs
-  }));
-  const actorList = [
-    .../* @__PURE__ */ new Set([
-      ...config2.actors.map((actor) => actor.name),
-      ...actorConfigs.map((actor) => actor.name)
-    ])
-  ];
-  config2.actors = actorList.map((actorName) => ActorConfigZod.loose().parse(deepMerge(config2.actors.find((actor) => actor.name === actorName) ?? {}, actorConfigs.find((actor) => actor.name === actorName) ?? {})));
+  });
   const logger = initLogger(configuration2);
   const orchestrator = await Orchestrator.create({
     logger
@@ -228,115 +507,10 @@ $0 <command> [options]`).parserConfiguration({
     "parse-numbers": false,
     "populate--": true
   }).env("XL1").scriptName("xl1").middleware(async (argv2) => {
-    try {
-      const configPath = argv2.config;
-      const parsedConfigFile = await tryParseConfig({
-        configPath
-      });
-      const parsedConfigArgs = ConfigZod.safeParse(argv2).data ?? {};
-      const parseResult = ConfigZod.safeParse(deepMerge(parsedConfigFile, parsedConfigArgs));
-      if (!parseResult.success) {
-        throw parseResult.error;
-      }
-      const mergedConfig = parseResult.data;
-      const validatedMergedConfigResult = ConfigZod.safeParse(mergedConfig);
-      if (!validatedMergedConfigResult.success) {
-        throw validatedMergedConfigResult.error;
-      }
-      const resolvedConfig = resolveConfig(validatedMergedConfigResult.data);
-      const validatedConfigResult = ConfigZod.safeParse(resolvedConfig);
-      if (!validatedConfigResult.success) {
-        throw validatedConfigResult.error;
-      }
-      configuration = validatedConfigResult.data;
-      if (argv2["dump-config"]) {
-        console.log(JSON.stringify(configuration, null, 2));
-        process.exit(0);
-      }
-    } catch (err) {
-      if (isZodError(err)) {
-        console.error(`Zod error: ${err.message}`);
-      } else {
-        console.error(`Error parsing configuration: ${err}`);
-      }
-      console.error(`Stack: ${err instanceof Error ? err.stack : "N/A"}`);
-      throw new Error("Invalid configuration");
-    }
-  }).options(optionsFromGlobalZodRegistry()).wrap(y.terminalWidth()).command("api", "Run a XL1 API Node", (yargs2) => {
-    return yargs2.command("$0", "Run a XL1 API Node", () => {
-    }, async () => {
-      const { locators, orchestrator } = await getLocatorsFromConfig([
-        "api",
-        "mempool",
-        "validator"
-      ], configuration);
-      const actors = await Promise.all([
-        getApiActor(ApiConfigZod.parse(locators["api"].context.config), locators["api"]),
-        getMempoolActor(MempoolConfigZod.parse(locators["mempool"].context.config), locators["mempool"]),
-        getValidatorActor(ValidatorConfigZod.parse(locators["validator"].context.config), locators["validator"])
-      ]);
-      for (const actor of actors) {
-        await orchestrator.registerActor(actor);
-      }
-      await orchestrator.start();
+    await configMiddleware(argv2, (config2) => {
+      configuration = config2;
     });
-  }).command("bridge", "Run a XL1 Bridge Node", (yargs2) => {
-    return yargs2.command("$0", "Run a XL1 Bridge Node", () => {
-    }, async () => {
-      const { locators, orchestrator } = await getLocatorsFromConfig([
-        "bridge"
-      ], configuration);
-      await runBridge(BridgeConfigZod.parse(locators["bridge"].context.config), orchestrator, locators["bridge"]);
-    });
-  }).command("mempool", "Run a XL1 Mempool Node", (yargs2) => {
-    return yargs2.command("$0", "Run a XL1 Mempool Node", () => {
-    }, async () => {
-      const { locators, orchestrator } = await getLocatorsFromConfig([
-        "mempool"
-      ], configuration);
-      await runMempool(MempoolConfigZod.parse(locators["mempool"].context.config), orchestrator, locators["mempool"]);
-    });
-  }).command("producer", "Run a XL1 Producer Node", (yargs2) => {
-    return yargs2.command("$0", "Run a XL1 Producer Node", () => {
-    }, async () => {
-      const { locators, orchestrator } = await getLocatorsFromConfig([
-        "producer"
-      ], configuration);
-      await runProducer(ProducerConfigZod.parse(locators["producer"].context.config), orchestrator, locators["producer"]);
-    });
-  }).command("reward-redemption-api", "Run a XL1 Rewards Redemption API Node", (yargs2) => {
-    return yargs2.command("$0", "Run a XL1 Rewards Redemption API Node", () => {
-    }, async () => {
-      const { locators, orchestrator } = await getLocatorsFromConfig([
-        "rewardRedemption"
-      ], configuration);
-      await runRewardRedemptionApi(RewardRedemptionConfigZod.parse(locators["rewardRedemption"].context.config), orchestrator, locators["rewardRedemption"]);
-    });
-  }).command("$0", "Run a full XL1 Node", () => {
-  }, async () => {
-    const actors = [
-      "producer",
-      "api"
-    ];
-    const mempoolEnabled = configuration.actors.find((actor) => actor.name === "mempool")?.enabled;
-    if (mempoolEnabled) {
-      actors.push("mempool");
-    }
-    const { locators, orchestrator } = await getLocatorsFromConfig([
-      "api",
-      "producer"
-    ], configuration);
-    if (mempoolEnabled) {
-      const mempoolConfig = MempoolConfigZod.parse(locators["mempool"].context.config);
-      await runMempool(mempoolConfig, orchestrator, locators["mempool"]);
-      await waitForHostPort(mempoolConfig.host, mempoolConfig.port);
-    }
-    const apiConfig = ApiConfigZod.parse(locators["api"].context.config);
-    await runApi(apiConfig, orchestrator, locators["api"]);
-    await waitForHostPort(apiConfig.host, apiConfig.port);
-    const producerConfig = ProducerConfigZod.parse(locators["producer"].context.config);
-    await runProducer(producerConfig, orchestrator, locators["producer"]);
-  }).options({
+  }).options(optionsFromGlobalZodRegistry()).wrap(y.terminalWidth()).command(withDeprecationWarning(apiCommand(getConfiguration, getLocatorsFromConfig))).command(withDeprecationWarning(bridgeCommand(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",
       description: "Path to a config file to use instead of the default search.",