@settlemint/sdk-mcp 1.1.16-pr0d9719ab → 1.1.16-pr18cd48b2

package/dist/mcp.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 import { createRequire } from "node:module";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
@@ -10014,8 +10015,7 @@ var require_mapAsyncIterator = __commonJS((exports) => {
         if (typeof iterator.return === "function") {
           try {
             await iterator.return();
-          } catch (_e) {
-          }
+          } catch (_e) {}
         }
         throw error;
       }
@@ -13988,8 +13988,7 @@ var require_p_limit = __commonJS((exports, module) => {
       resolve(result);
       try {
         await result;
-      } catch {
-      }
+      } catch {}
       next();
     };
     const enqueue = (fn, resolve, ...args) => {
@@ -14037,8 +14036,7 @@ var require_constants = __commonJS((exports, module) => {
     kListener: Symbol("kListener"),
     kStatusCode: Symbol("status-code"),
     kWebSocket: Symbol("websocket"),
-    NOOP: () => {
-    }
+    NOOP: () => {}
   };
 });
 
@@ -14116,8 +14114,7 @@ var require_buffer_util = __commonJS((exports, module) => {
         else
           bufferUtil.unmask(buffer, mask);
       };
-    } catch (e) {
-    }
+    } catch (e) {}
   }
 });
 
@@ -14596,8 +14593,7 @@ var require_validation2 = __commonJS((exports, module) => {
       module.exports.isValidUTF8 = function(buf) {
         return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf);
       };
-    } catch (e) {
-    }
+    } catch (e) {}
   }
 });
 
@@ -18883,8 +18879,7 @@ var require_utils = __commonJS((exports, module) => {
       try {
         const decoder = new TextDecoder(exports);
         return decoder.decode(data);
-      } catch {
-      }
+      } catch {}
     }
   };
   function convertToUTF8(data, charset, hint) {
@@ -20614,8 +20609,7 @@ var require_multipart = __commonJS((exports, module) => {
 `);
   var BUF_CR = Buffer.from("\r");
   var BUF_DASH = Buffer.from("-");
-  function noop() {
-  }
+  function noop() {}
   var MAX_HEADER_PAIRS = 2000;
   var MAX_HEADER_SIZE = 16 * 1024;
   var HPARSER_NAME = 0;
@@ -20783,10 +20777,8 @@ var require_multipart = __commonJS((exports, module) => {
     }
   }
   var ignoreData = {
-    push: (chunk, pos) => {
-    },
-    destroy: () => {
-    }
+    push: (chunk, pos) => {},
+    destroy: () => {}
   };
   function callAndUnsetCb(self2, err) {
     const cb = self2._writecb;
@@ -24701,8 +24693,7 @@ var require_WritableStream = __commonJS((exports) => {
             resolve(undefined);
           });
         }),
-        releaseLock() {
-        },
+        releaseLock() {},
         write(chunk) {
           if (chunk == null) {
             return (0, utils_js_1.fakePromise)();
@@ -24803,8 +24794,7 @@ var require_TransformStream = __commonJS((exports) => {
           }
         };
         const transform = new node_stream_1.Transform({
-          read() {
-          },
+          read() {},
           write(chunk, _encoding, callback) {
             try {
               const result = transformer.transform?.(chunk, controller);
@@ -25219,8 +25209,7 @@ var require_ValueOrPromise = __commonJS((exports) => {
       }
       if (containsPromise) {
         if (rejected) {
-          Promise.all(values).catch(() => {
-          });
+          Promise.all(values).catch(() => {});
           return new ValueOrPromise(() => {
             throw reason;
           });
@@ -25411,8 +25400,7 @@ var require_dataloader = __commonJS((exports, module) => {
           var promise;
           if (value instanceof Error) {
             promise = Promise.reject(value);
-            promise["catch"](function() {
-            });
+            promise["catch"](function() {});
           } else {
             promise = Promise.resolve(value);
           }
@@ -27662,8 +27650,7 @@ var require_push_directory = __commonJS((exports) => {
       paths.push(path);
     }
   };
-  var empty = () => {
-  };
+  var empty = () => {};
   function build(root, options) {
     const { includeDirs, filters, relativePaths } = options;
     if (!includeDirs)
@@ -27693,8 +27680,7 @@ var require_push_file = __commonJS((exports) => {
   var pushFile = (filename, paths) => {
     paths.push(filename);
   };
-  var empty = () => {
-  };
+  var empty = () => {};
   function build(options) {
     const { excludeFiles, filters, onlyCounts } = options;
     if (excludeFiles)
@@ -27733,8 +27719,7 @@ var require_group_files = __commonJS((exports) => {
   var groupFiles = (groups, directory, files) => {
     groups.push({ directory, files, dir: directory });
   };
-  var empty = () => {
-  };
+  var empty = () => {};
   function build(options) {
     return options.group ? groupFiles : empty;
   }
@@ -29592,8 +29577,7 @@ var require_builder = __commonJS((exports) => {
   try {
     __require.resolve("picomatch");
     pm = require_picomatch2();
-  } catch (_e) {
-  }
+  } catch (_e) {}
 
   class Builder {
     globCache = {};
@@ -30327,8 +30311,7 @@ var require_utils7 = __commonJS((exports) => {
   function numberToBytesBE(n, len) {
     return hexToBytes(n.toString(16).padStart(len * 2, "0"));
   }
-  var nextTick = async () => {
-  };
+  var nextTick = async () => {};
   exports.nextTick = nextTick;
   function utf8ToBytes(str) {
     if (typeof str !== "string")
@@ -30791,8 +30774,7 @@ var require_utils8 = __commonJS((exports) => {
     }
     return array2;
   }
-  var nextTick = async () => {
-  };
+  var nextTick = async () => {};
   exports.nextTick = nextTick;
   async function asyncLoop(iters, tick, cb) {
     let ts = Date.now();
@@ -31789,8 +31771,7 @@ var require_modular = __commonJS((exports) => {
         return root;
       };
     }
-    if (P % _16n === _9n) {
-    }
+    if (P % _16n === _9n) {}
     return tonelliShanks(P);
   }
   var isNegativeLE = (num, modulo) => (mod(num, modulo) & _1n) === _1n;
@@ -37158,8 +37139,7 @@ var require_main3 = __commonJS((exports, module) => {
       logger.success(`✔ set ${key}${withEncryption} (${changedFilepaths.join(",")})`);
     } else if (unchangedFilepaths.length > 0) {
       logger.info(`no changes (${unchangedFilepaths})`);
-    } else {
-    }
+    } else {}
     for (const processedEnv of processedEnvs) {
       if (processedEnv.privateKeyAdded) {
         logger.success(`✔ key added to ${processedEnv.envKeysFilepath} (${processedEnv.privateKeyName})`);
@@ -37563,18 +37543,18 @@ var require_help = __commonJS((exports) => {
   class Help {
     constructor() {
       this.helpWidth = undefined;
-      this.minWidthToWrap = 40;
       this.sortSubcommands = false;
       this.sortOptions = false;
       this.showGlobalOptions = false;
     }
-    prepareContext(contextOptions) {
-      this.helpWidth = this.helpWidth ?? contextOptions.helpWidth ?? 80;
-    }
     visibleCommands(cmd) {
       const visibleCommands = cmd.commands.filter((cmd2) => !cmd2._hidden);
-      const helpCommand = cmd._getHelpCommand();
-      if (helpCommand && !helpCommand._hidden) {
+      if (cmd._hasImplicitHelpCommand()) {
+        const [, helpName, helpArgs] = cmd._helpCommandnameAndArgs.match(/([^ ]+) *(.*)/);
+        const helpCommand = cmd.createCommand(helpName).helpOption(false);
+        helpCommand.description(cmd._helpCommandDescription);
+        if (helpArgs)
+          helpCommand.arguments(helpArgs);
         visibleCommands.push(helpCommand);
       }
       if (this.sortSubcommands) {
@@ -37592,17 +37572,18 @@ var require_help = __commonJS((exports) => {
     }
     visibleOptions(cmd) {
       const visibleOptions = cmd.options.filter((option) => !option.hidden);
-      const helpOption = cmd._getHelpOption();
-      if (helpOption && !helpOption.hidden) {
-        const removeShort = helpOption.short && cmd._findOption(helpOption.short);
-        const removeLong = helpOption.long && cmd._findOption(helpOption.long);
-        if (!removeShort && !removeLong) {
-          visibleOptions.push(helpOption);
-        } else if (helpOption.long && !removeLong) {
-          visibleOptions.push(cmd.createOption(helpOption.long, helpOption.description));
-        } else if (helpOption.short && !removeShort) {
-          visibleOptions.push(cmd.createOption(helpOption.short, helpOption.description));
+      const showShortHelpFlag = cmd._hasHelpOption && cmd._helpShortFlag && !cmd._findOption(cmd._helpShortFlag);
+      const showLongHelpFlag = cmd._hasHelpOption && !cmd._findOption(cmd._helpLongFlag);
+      if (showShortHelpFlag || showLongHelpFlag) {
+        let helpOption;
+        if (!showShortHelpFlag) {
+          helpOption = cmd.createOption(cmd._helpLongFlag, cmd._helpDescription);
+        } else if (!showLongHelpFlag) {
+          helpOption = cmd.createOption(cmd._helpShortFlag, cmd._helpDescription);
+        } else {
+          helpOption = cmd.createOption(cmd._helpFlags, cmd._helpDescription);
         }
+        visibleOptions.push(helpOption);
       }
       if (this.sortOptions) {
         visibleOptions.sort(this.compareOptions);
@@ -37645,22 +37626,22 @@ var require_help = __commonJS((exports) => {
     }
     longestSubcommandTermLength(cmd, helper) {
       return helper.visibleCommands(cmd).reduce((max, command) => {
-        return Math.max(max, this.displayWidth(helper.styleSubcommandTerm(helper.subcommandTerm(command))));
+        return Math.max(max, helper.subcommandTerm(command).length);
       }, 0);
     }
     longestOptionTermLength(cmd, helper) {
       return helper.visibleOptions(cmd).reduce((max, option) => {
-        return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
+        return Math.max(max, helper.optionTerm(option).length);
       }, 0);
     }
     longestGlobalOptionTermLength(cmd, helper) {
       return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
-        return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
+        return Math.max(max, helper.optionTerm(option).length);
       }, 0);
     }
     longestArgumentTermLength(cmd, helper) {
       return helper.visibleArguments(cmd).reduce((max, argument) => {
-        return Math.max(max, this.displayWidth(helper.styleArgumentTerm(helper.argumentTerm(argument))));
+        return Math.max(max, helper.argumentTerm(argument).length);
       }, 0);
     }
     commandUsage(cmd) {
@@ -37711,199 +37692,95 @@ var require_help = __commonJS((exports) => {
         extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
       }
       if (extraInfo.length > 0) {
-        const extraDescription = `(${extraInfo.join(", ")})`;
+        const extraDescripton = `(${extraInfo.join(", ")})`;
         if (argument.description) {
-          return `${argument.description} ${extraDescription}`;
+          return `${argument.description} ${extraDescripton}`;
         }
-        return extraDescription;
+        return extraDescripton;
       }
       return argument.description;
     }
     formatHelp(cmd, helper) {
       const termWidth = helper.padWidth(cmd, helper);
-      const helpWidth = helper.helpWidth ?? 80;
-      function callFormatItem(term, description) {
-        return helper.formatItem(term, termWidth, description, helper);
+      const helpWidth = helper.helpWidth || 80;
+      const itemIndentWidth = 2;
+      const itemSeparatorWidth = 2;
+      function formatItem(term, description) {
+        if (description) {
+          const fullText = `${term.padEnd(termWidth + itemSeparatorWidth)}${description}`;
+          return helper.wrap(fullText, helpWidth - itemIndentWidth, termWidth + itemSeparatorWidth);
+        }
+        return term;
       }
-      let output = [
-        `${helper.styleTitle("Usage:")} ${helper.styleUsage(helper.commandUsage(cmd))}`,
-        ""
-      ];
+      function formatList(textArray) {
+        return textArray.join(`
+`).replace(/^/gm, " ".repeat(itemIndentWidth));
+      }
+      let output = [`Usage: ${helper.commandUsage(cmd)}`, ""];
       const commandDescription = helper.commandDescription(cmd);
       if (commandDescription.length > 0) {
-        output = output.concat([
-          helper.boxWrap(helper.styleCommandDescription(commandDescription), helpWidth),
-          ""
-        ]);
+        output = output.concat([helper.wrap(commandDescription, helpWidth, 0), ""]);
       }
       const argumentList = helper.visibleArguments(cmd).map((argument) => {
-        return callFormatItem(helper.styleArgumentTerm(helper.argumentTerm(argument)), helper.styleArgumentDescription(helper.argumentDescription(argument)));
+        return formatItem(helper.argumentTerm(argument), helper.argumentDescription(argument));
       });
       if (argumentList.length > 0) {
-        output = output.concat([
-          helper.styleTitle("Arguments:"),
-          ...argumentList,
-          ""
-        ]);
+        output = output.concat(["Arguments:", formatList(argumentList), ""]);
       }
       const optionList = helper.visibleOptions(cmd).map((option) => {
-        return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
+        return formatItem(helper.optionTerm(option), helper.optionDescription(option));
       });
       if (optionList.length > 0) {
-        output = output.concat([
-          helper.styleTitle("Options:"),
-          ...optionList,
-          ""
-        ]);
+        output = output.concat(["Options:", formatList(optionList), ""]);
       }
-      if (helper.showGlobalOptions) {
+      if (this.showGlobalOptions) {
         const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
-          return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
+          return formatItem(helper.optionTerm(option), helper.optionDescription(option));
         });
         if (globalOptionList.length > 0) {
-          output = output.concat([
-            helper.styleTitle("Global Options:"),
-            ...globalOptionList,
-            ""
-          ]);
+          output = output.concat(["Global Options:", formatList(globalOptionList), ""]);
         }
       }
       const commandList = helper.visibleCommands(cmd).map((cmd2) => {
-        return callFormatItem(helper.styleSubcommandTerm(helper.subcommandTerm(cmd2)), helper.styleSubcommandDescription(helper.subcommandDescription(cmd2)));
+        return formatItem(helper.subcommandTerm(cmd2), helper.subcommandDescription(cmd2));
       });
       if (commandList.length > 0) {
-        output = output.concat([
-          helper.styleTitle("Commands:"),
-          ...commandList,
-          ""
-        ]);
+        output = output.concat(["Commands:", formatList(commandList), ""]);
       }
       return output.join(`
 `);
     }
-    displayWidth(str) {
-      return stripColor(str).length;
-    }
-    styleTitle(str) {
-      return str;
-    }
-    styleUsage(str) {
-      return str.split(" ").map((word) => {
-        if (word === "[options]")
-          return this.styleOptionText(word);
-        if (word === "[command]")
-          return this.styleSubcommandText(word);
-        if (word[0] === "[" || word[0] === "<")
-          return this.styleArgumentText(word);
-        return this.styleCommandText(word);
-      }).join(" ");
-    }
-    styleCommandDescription(str) {
-      return this.styleDescriptionText(str);
-    }
-    styleOptionDescription(str) {
-      return this.styleDescriptionText(str);
-    }
-    styleSubcommandDescription(str) {
-      return this.styleDescriptionText(str);
-    }
-    styleArgumentDescription(str) {
-      return this.styleDescriptionText(str);
-    }
-    styleDescriptionText(str) {
-      return str;
-    }
-    styleOptionTerm(str) {
-      return this.styleOptionText(str);
-    }
-    styleSubcommandTerm(str) {
-      return str.split(" ").map((word) => {
-        if (word === "[options]")
-          return this.styleOptionText(word);
-        if (word[0] === "[" || word[0] === "<")
-          return this.styleArgumentText(word);
-        return this.styleSubcommandText(word);
-      }).join(" ");
-    }
-    styleArgumentTerm(str) {
-      return this.styleArgumentText(str);
-    }
-    styleOptionText(str) {
-      return str;
-    }
-    styleArgumentText(str) {
-      return str;
-    }
-    styleSubcommandText(str) {
-      return str;
-    }
-    styleCommandText(str) {
-      return str;
-    }
     padWidth(cmd, helper) {
       return Math.max(helper.longestOptionTermLength(cmd, helper), helper.longestGlobalOptionTermLength(cmd, helper), helper.longestSubcommandTermLength(cmd, helper), helper.longestArgumentTermLength(cmd, helper));
     }
-    preformatted(str) {
-      return /\n[^\S\r\n]/.test(str);
-    }
-    formatItem(term, termWidth, description, helper) {
-      const itemIndent = 2;
-      const itemIndentStr = " ".repeat(itemIndent);
-      if (!description)
-        return itemIndentStr + term;
-      const paddedTerm = term.padEnd(termWidth + term.length - helper.displayWidth(term));
-      const spacerWidth = 2;
-      const helpWidth = this.helpWidth ?? 80;
-      const remainingWidth = helpWidth - termWidth - spacerWidth - itemIndent;
-      let formattedDescription;
-      if (remainingWidth < this.minWidthToWrap || helper.preformatted(description)) {
-        formattedDescription = description;
-      } else {
-        const wrappedDescription = helper.boxWrap(description, remainingWidth);
-        formattedDescription = wrappedDescription.replace(/\n/g, `
-` + " ".repeat(termWidth + spacerWidth));
-      }
-      return itemIndentStr + paddedTerm + " ".repeat(spacerWidth) + formattedDescription.replace(/\n/g, `
-${itemIndentStr}`);
-    }
-    boxWrap(str, width) {
-      if (width < this.minWidthToWrap)
+    wrap(str, width, indent2, minColumnWidth = 40) {
+      const indents = " \\f\\t\\v   -   　\uFEFF";
+      const manualIndent = new RegExp(`[\\n][${indents}]+`);
+      if (str.match(manualIndent))
         return str;
-      const rawLines = str.split(/\r\n|\n/);
-      const chunkPattern = /[\s]*[^\s]+/g;
-      const wrappedLines = [];
-      rawLines.forEach((line) => {
-        const chunks = line.match(chunkPattern);
-        if (chunks === null) {
-          wrappedLines.push("");
-          return;
-        }
-        let sumChunks = [chunks.shift()];
-        let sumWidth = this.displayWidth(sumChunks[0]);
-        chunks.forEach((chunk) => {
-          const visibleWidth = this.displayWidth(chunk);
-          if (sumWidth + visibleWidth <= width) {
-            sumChunks.push(chunk);
-            sumWidth += visibleWidth;
-            return;
-          }
-          wrappedLines.push(sumChunks.join(""));
-          const nextChunk = chunk.trimStart();
-          sumChunks = [nextChunk];
-          sumWidth = this.displayWidth(nextChunk);
-        });
-        wrappedLines.push(sumChunks.join(""));
-      });
-      return wrappedLines.join(`
+      const columnWidth = width - indent2;
+      if (columnWidth < minColumnWidth)
+        return str;
+      const leadingStr = str.slice(0, indent2);
+      const columnText = str.slice(indent2).replace(`\r
+`, `
+`);
+      const indentString = " ".repeat(indent2);
+      const zeroWidthSpace = "​";
+      const breaks = `\\s${zeroWidthSpace}`;
+      const regex = new RegExp(`
+|.{1,${columnWidth - 1}}([${breaks}]|$)|[^${breaks}]+?([${breaks}]|$)`, "g");
+      const lines = columnText.match(regex) || [];
+      return leadingStr + lines.map((line, i) => {
+        if (line === `
+`)
+          return "";
+        return (i > 0 ? indentString : "") + line.trimEnd();
+      }).join(`
 `);
     }
   }
-  function stripColor(str) {
-    const sgrPattern = /\x1b\[\d*(;\d*)*m/g;
-    return str.replace(sgrPattern, "");
-  }
   exports.Help = Help;
-  exports.stripColor = stripColor;
 });
 
 // ../../node_modules/commander/lib/option.js
@@ -37998,10 +37875,7 @@ var require_option = __commonJS((exports) => {
       return this.short.replace(/^-/, "");
     }
     attributeName() {
-      if (this.negate) {
-        return camelcase(this.name().replace(/^no-/, ""));
-      }
-      return camelcase(this.name());
+      return camelcase(this.name().replace(/^no-/, ""));
     }
     is(arg) {
       return this.short === arg || this.long === arg;
@@ -38046,41 +37920,18 @@ var require_option = __commonJS((exports) => {
   function splitOptionFlags(flags) {
     let shortFlag;
     let longFlag;
-    const shortFlagExp = /^-[^-]$/;
-    const longFlagExp = /^--[^-]/;
-    const flagParts = flags.split(/[ |,]+/).concat("guard");
-    if (shortFlagExp.test(flagParts[0]))
-      shortFlag = flagParts.shift();
-    if (longFlagExp.test(flagParts[0]))
-      longFlag = flagParts.shift();
-    if (!shortFlag && shortFlagExp.test(flagParts[0]))
+    const flagParts = flags.split(/[ |,]+/);
+    if (flagParts.length > 1 && !/^[[<]/.test(flagParts[1]))
       shortFlag = flagParts.shift();
-    if (!shortFlag && longFlagExp.test(flagParts[0])) {
+    longFlag = flagParts.shift();
+    if (!shortFlag && /^-[^-]$/.test(longFlag)) {
       shortFlag = longFlag;
-      longFlag = flagParts.shift();
-    }
-    if (flagParts[0].startsWith("-")) {
-      const unsupportedFlag = flagParts[0];
-      const baseError = `option creation failed due to '${unsupportedFlag}' in option flags '${flags}'`;
-      if (/^-[^-][^-]/.test(unsupportedFlag))
-        throw new Error(`${baseError}
-- a short flag is a single dash and a single character
-  - either use a single dash and a single character (for a short flag)
-  - or use a double dash for a long option (and can have two, like '--ws, --workspace')`);
-      if (shortFlagExp.test(unsupportedFlag))
-        throw new Error(`${baseError}
-- too many short flags`);
-      if (longFlagExp.test(unsupportedFlag))
-        throw new Error(`${baseError}
-- too many long flags`);
-      throw new Error(`${baseError}
-- unrecognised flag format`);
-    }
-    if (shortFlag === undefined && longFlag === undefined)
-      throw new Error(`option creation failed due to no flags found in '${flags}'.`);
+      longFlag = undefined;
+    }
     return { shortFlag, longFlag };
   }
   exports.Option = Option;
+  exports.splitOptionFlags = splitOptionFlags;
   exports.DualOptions = DualOptions;
 });
 
@@ -38159,15 +38010,15 @@ var require_suggestSimilar = __commonJS((exports) => {
 
 // ../../node_modules/commander/lib/command.js
 var require_command = __commonJS((exports) => {
-  var EventEmitter2 = __require("node:events").EventEmitter;
-  var childProcess = __require("node:child_process");
-  var path2 = __require("node:path");
-  var fs = __require("node:fs");
-  var process3 = __require("node:process");
+  var EventEmitter2 = __require("events").EventEmitter;
+  var childProcess = __require("child_process");
+  var path2 = __require("path");
+  var fs = __require("fs");
+  var process3 = __require("process");
   var { Argument, humanReadableArgName } = require_argument();
   var { CommanderError } = require_error3();
-  var { Help, stripColor } = require_help();
-  var { Option, DualOptions } = require_option();
+  var { Help } = require_help();
+  var { Option, splitOptionFlags, DualOptions } = require_option();
   var { suggestSimilar } = require_suggestSimilar();
 
   class Command extends EventEmitter2 {
@@ -38177,7 +38028,7 @@ var require_command = __commonJS((exports) => {
       this.options = [];
       this.parent = null;
       this._allowUnknownOption = false;
-      this._allowExcessArguments = false;
+      this._allowExcessArguments = true;
       this.registeredArguments = [];
       this._args = this.registeredArguments;
       this.args = [];
@@ -38204,27 +38055,35 @@ var require_command = __commonJS((exports) => {
       this._lifeCycleHooks = {};
       this._showHelpAfterError = false;
       this._showSuggestionAfterError = true;
-      this._savedState = null;
       this._outputConfiguration = {
         writeOut: (str) => process3.stdout.write(str),
         writeErr: (str) => process3.stderr.write(str),
-        outputError: (str, write) => write(str),
         getOutHelpWidth: () => process3.stdout.isTTY ? process3.stdout.columns : undefined,
         getErrHelpWidth: () => process3.stderr.isTTY ? process3.stderr.columns : undefined,
-        getOutHasColors: () => useColor() ?? (process3.stdout.isTTY && process3.stdout.hasColors?.()),
-        getErrHasColors: () => useColor() ?? (process3.stderr.isTTY && process3.stderr.hasColors?.()),
-        stripColor: (str) => stripColor(str)
+        outputError: (str, write) => write(str)
       };
       this._hidden = false;
-      this._helpOption = undefined;
+      this._hasHelpOption = true;
+      this._helpFlags = "-h, --help";
+      this._helpDescription = "display help for command";
+      this._helpShortFlag = "-h";
+      this._helpLongFlag = "--help";
       this._addImplicitHelpCommand = undefined;
-      this._helpCommand = undefined;
+      this._helpCommandName = "help";
+      this._helpCommandnameAndArgs = "help [command]";
+      this._helpCommandDescription = "display help for command";
       this._helpConfiguration = {};
     }
     copyInheritedSettings(sourceCommand) {
       this._outputConfiguration = sourceCommand._outputConfiguration;
-      this._helpOption = sourceCommand._helpOption;
-      this._helpCommand = sourceCommand._helpCommand;
+      this._hasHelpOption = sourceCommand._hasHelpOption;
+      this._helpFlags = sourceCommand._helpFlags;
+      this._helpDescription = sourceCommand._helpDescription;
+      this._helpShortFlag = sourceCommand._helpShortFlag;
+      this._helpLongFlag = sourceCommand._helpLongFlag;
+      this._helpCommandName = sourceCommand._helpCommandName;
+      this._helpCommandnameAndArgs = sourceCommand._helpCommandnameAndArgs;
+      this._helpCommandDescription = sourceCommand._helpCommandDescription;
       this._helpConfiguration = sourceCommand._helpConfiguration;
       this._exitCallback = sourceCommand._exitCallback;
       this._storeOptionsAsProperties = sourceCommand._storeOptionsAsProperties;
@@ -38262,7 +38121,7 @@ var require_command = __commonJS((exports) => {
       cmd._executableFile = opts.executableFile || null;
       if (args)
         cmd.arguments(args);
-      this._registerCommand(cmd);
+      this.commands.push(cmd);
       cmd.parent = this;
       cmd.copyInheritedSettings(this);
       if (desc)
@@ -38307,9 +38166,8 @@ var require_command = __commonJS((exports) => {
         this._defaultCommandName = cmd._name;
       if (opts.noHelp || opts.hidden)
         cmd._hidden = true;
-      this._registerCommand(cmd);
+      this.commands.push(cmd);
       cmd.parent = this;
-      cmd._checkForBrokenPassThrough();
       return this;
     }
     createArgument(name, description) {
@@ -38342,42 +38200,24 @@ var require_command = __commonJS((exports) => {
       this.registeredArguments.push(argument);
       return this;
     }
-    helpCommand(enableOrNameAndArgs, description) {
-      if (typeof enableOrNameAndArgs === "boolean") {
-        this._addImplicitHelpCommand = enableOrNameAndArgs;
-        return this;
-      }
-      enableOrNameAndArgs = enableOrNameAndArgs ?? "help [command]";
-      const [, helpName, helpArgs] = enableOrNameAndArgs.match(/([^ ]+) *(.*)/);
-      const helpDescription = description ?? "display help for command";
-      const helpCommand = this.createCommand(helpName);
-      helpCommand.helpOption(false);
-      if (helpArgs)
-        helpCommand.arguments(helpArgs);
-      if (helpDescription)
-        helpCommand.description(helpDescription);
-      this._addImplicitHelpCommand = true;
-      this._helpCommand = helpCommand;
-      return this;
-    }
-    addHelpCommand(helpCommand, deprecatedDescription) {
-      if (typeof helpCommand !== "object") {
-        this.helpCommand(helpCommand, deprecatedDescription);
-        return this;
+    addHelpCommand(enableOrNameAndArgs, description) {
+      if (enableOrNameAndArgs === false) {
+        this._addImplicitHelpCommand = false;
+      } else {
+        this._addImplicitHelpCommand = true;
+        if (typeof enableOrNameAndArgs === "string") {
+          this._helpCommandName = enableOrNameAndArgs.split(" ")[0];
+          this._helpCommandnameAndArgs = enableOrNameAndArgs;
+        }
+        this._helpCommandDescription = description || this._helpCommandDescription;
       }
-      this._addImplicitHelpCommand = true;
-      this._helpCommand = helpCommand;
       return this;
     }
-    _getHelpCommand() {
-      const hasImplicitHelpCommand = this._addImplicitHelpCommand ?? (this.commands.length && !this._actionHandler && !this._findCommand("help"));
-      if (hasImplicitHelpCommand) {
-        if (this._helpCommand === undefined) {
-          this.helpCommand(undefined, undefined);
-        }
-        return this._helpCommand;
+    _hasImplicitHelpCommand() {
+      if (this._addImplicitHelpCommand === undefined) {
+        return this.commands.length && !this._actionHandler && !this._findCommand("help");
       }
-      return null;
+      return this._addImplicitHelpCommand;
     }
     hook(event, listener) {
       const allowedValues = ["preSubcommand", "preAction", "postAction"];
@@ -38399,8 +38239,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         this._exitCallback = (err) => {
           if (err.code !== "commander.executeSubCommandAsync") {
             throw err;
-          } else {
-          }
+          } else {}
         };
       }
       return this;
@@ -38440,29 +38279,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         throw err;
       }
     }
-    _registerOption(option) {
-      const matchingOption = option.short && this._findOption(option.short) || option.long && this._findOption(option.long);
-      if (matchingOption) {
-        const matchingFlag = option.long && this._findOption(option.long) ? option.long : option.short;
-        throw new Error(`Cannot add option '${option.flags}'${this._name && ` to command '${this._name}'`} due to conflicting flag '${matchingFlag}'
--  already used by option '${matchingOption.flags}'`);
-      }
-      this.options.push(option);
-    }
-    _registerCommand(command) {
-      const knownBy = (cmd) => {
-        return [cmd.name()].concat(cmd.aliases());
-      };
-      const alreadyUsed = knownBy(command).find((name) => this._findCommand(name));
-      if (alreadyUsed) {
-        const existingCmd = knownBy(this._findCommand(alreadyUsed)).join("|");
-        const newCmd = knownBy(command).join("|");
-        throw new Error(`cannot add command '${newCmd}' as already have command '${existingCmd}'`);
-      }
-      this.commands.push(command);
-    }
     addOption(option) {
-      this._registerOption(option);
       const oname = option.name();
       const name = option.attributeName();
       if (option.negate) {
@@ -38473,6 +38290,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       } else if (option.defaultValue !== undefined) {
         this.setOptionValueWithSource(name, option.defaultValue, "default");
       }
+      this.options.push(option);
       const handleOptionValue = (val, invalidValueMessage, valueSource) => {
         if (val == null && option.presetArg !== undefined) {
           val = option.presetArg;
@@ -38550,21 +38368,15 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     passThroughOptions(passThrough = true) {
       this._passThroughOptions = !!passThrough;
-      this._checkForBrokenPassThrough();
-      return this;
-    }
-    _checkForBrokenPassThrough() {
-      if (this.parent && this._passThroughOptions && !this.parent._enablePositionalOptions) {
-        throw new Error(`passThroughOptions cannot be used for '${this._name}' without turning on enablePositionalOptions for parent command(s)`);
+      if (!!this.parent && passThrough && !this.parent._enablePositionalOptions) {
+        throw new Error("passThroughOptions can not be used without turning on enablePositionalOptions for parent command(s)");
       }
+      return this;
     }
     storeOptionsAsProperties(storeAsProperties = true) {
       if (this.options.length) {
         throw new Error("call .storeOptionsAsProperties() before adding options");
       }
-      if (Object.keys(this._optionValues).length) {
-        throw new Error("call .storeOptionsAsProperties() before setting option values");
-      }
       this._storeOptionsAsProperties = !!storeAsProperties;
       return this;
     }
@@ -38603,17 +38415,11 @@ Expecting one of '${allowedValues.join("', '")}'`);
         throw new Error("first parameter to parse must be array or undefined");
       }
       parseOptions = parseOptions || {};
-      if (argv === undefined && parseOptions.from === undefined) {
-        if (process3.versions?.electron) {
-          parseOptions.from = "electron";
-        }
-        const execArgv = process3.execArgv ?? [];
-        if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
-          parseOptions.from = "eval";
-        }
-      }
       if (argv === undefined) {
         argv = process3.argv;
+        if (process3.versions && process3.versions.electron) {
+          parseOptions.from = "electron";
+        }
       }
       this.rawArgs = argv.slice();
       let userArgs;
@@ -38634,9 +38440,6 @@ Expecting one of '${allowedValues.join("', '")}'`);
         case "user":
           userArgs = argv.slice(0);
           break;
-        case "eval":
-          userArgs = argv.slice(1);
-          break;
         default:
           throw new Error(`unexpected parse option { from: '${parseOptions.from}' }`);
       }
@@ -38646,53 +38449,15 @@ Expecting one of '${allowedValues.join("', '")}'`);
       return userArgs;
     }
     parse(argv, parseOptions) {
-      this._prepareForParse();
       const userArgs = this._prepareUserArgs(argv, parseOptions);
       this._parseCommand([], userArgs);
       return this;
     }
     async parseAsync(argv, parseOptions) {
-      this._prepareForParse();
       const userArgs = this._prepareUserArgs(argv, parseOptions);
       await this._parseCommand([], userArgs);
       return this;
     }
-    _prepareForParse() {
-      if (this._savedState === null) {
-        this.saveStateBeforeParse();
-      } else {
-        this.restoreStateBeforeParse();
-      }
-    }
-    saveStateBeforeParse() {
-      this._savedState = {
-        _name: this._name,
-        _optionValues: { ...this._optionValues },
-        _optionValueSources: { ...this._optionValueSources }
-      };
-    }
-    restoreStateBeforeParse() {
-      if (this._storeOptionsAsProperties)
-        throw new Error(`Can not call parse again when storeOptionsAsProperties is true.
-- either make a new Command for each call to parse, or stop storing options as properties`);
-      this._name = this._savedState._name;
-      this._scriptPath = null;
-      this.rawArgs = [];
-      this._optionValues = { ...this._savedState._optionValues };
-      this._optionValueSources = { ...this._savedState._optionValueSources };
-      this.args = [];
-      this.processedArgs = [];
-    }
-    _checkForMissingExecutable(executableFile, executableDir, subcommandName) {
-      if (fs.existsSync(executableFile))
-        return;
-      const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
-      const executableMissing = `'${executableFile}' does not exist
- - if '${subcommandName}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
- - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
- - ${executableDirMessage}`;
-      throw new Error(executableMissing);
-    }
     _executeSubCommand(subcommand, args) {
       args = args.slice();
       let launchWithNode = false;
@@ -38716,7 +38481,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let resolvedScriptPath;
         try {
           resolvedScriptPath = fs.realpathSync(this._scriptPath);
-        } catch {
+        } catch (err) {
           resolvedScriptPath = this._scriptPath;
         }
         executableDir = path2.resolve(path2.dirname(resolvedScriptPath), executableDir);
@@ -38742,7 +38507,6 @@ Expecting one of '${allowedValues.join("', '")}'`);
           proc2 = childProcess.spawn(executableFile, args, { stdio: "inherit" });
         }
       } else {
-        this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
         args.unshift(executableFile);
         args = incrementNodeInspectorPort(process3.execArgv).concat(args);
         proc2 = childProcess.spawn(process3.execPath, args, { stdio: "inherit" });
@@ -38758,17 +38522,21 @@ Expecting one of '${allowedValues.join("', '")}'`);
         });
       }
       const exitCallback = this._exitCallback;
-      proc2.on("close", (code) => {
-        code = code ?? 1;
-        if (!exitCallback) {
-          process3.exit(code);
-        } else {
-          exitCallback(new CommanderError(code, "commander.executeSubCommandAsync", "(close)"));
-        }
-      });
+      if (!exitCallback) {
+        proc2.on("close", process3.exit.bind(process3));
+      } else {
+        proc2.on("close", () => {
+          exitCallback(new CommanderError(process3.exitCode || 0, "commander.executeSubCommandAsync", "(close)"));
+        });
+      }
       proc2.on("error", (err) => {
         if (err.code === "ENOENT") {
-          this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
+          const executableDirMessage = executableDir ? `searched for local subcommand relative to directory '${executableDir}'` : "no directory for search for local subcommand, use .executableDir() to supply a custom directory";
+          const executableMissing = `'${executableFile}' does not exist
+ - if '${subcommand._name}' is not meant to be an executable command, remove description parameter from '.command()' and use '.description()' instead
+ - if the default executable name is not suitable, use the executableFile option to supply a custom name or path
+ - ${executableDirMessage}`;
+          throw new Error(executableMissing);
         } else if (err.code === "EACCES") {
           throw new Error(`'${executableFile}' not executable`);
         }
@@ -38786,7 +38554,6 @@ Expecting one of '${allowedValues.join("', '")}'`);
       const subCommand = this._findCommand(commandName);
       if (!subCommand)
         this.help({ error: true });
-      subCommand._prepareForParse();
       let promiseChain;
       promiseChain = this._chainOrCallSubCommandHook(promiseChain, subCommand, "preSubcommand");
       promiseChain = this._chainOrCall(promiseChain, () => {
@@ -38806,7 +38573,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
       if (subCommand && !subCommand._executableHandler) {
         subCommand.help();
       }
-      return this._dispatchSubcommand(subcommandName, [], [this._getHelpOption()?.long ?? this._getHelpOption()?.short ?? "--help"]);
+      return this._dispatchSubcommand(subcommandName, [], [
+        this._helpLongFlag || this._helpShortFlag
+      ]);
     }
     _checkNumberOfArguments() {
       this.registeredArguments.forEach((arg, i) => {
@@ -38900,17 +38669,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
       if (operands && this._findCommand(operands[0])) {
         return this._dispatchSubcommand(operands[0], operands.slice(1), unknown2);
       }
-      if (this._getHelpCommand() && operands[0] === this._getHelpCommand().name()) {
+      if (this._hasImplicitHelpCommand() && operands[0] === this._helpCommandName) {
         return this._dispatchHelpCommand(operands[1]);
       }
       if (this._defaultCommandName) {
-        this._outputHelpIfRequested(unknown2);
+        outputHelpIfRequested(this, unknown2);
         return this._dispatchSubcommand(this._defaultCommandName, operands, unknown2);
       }
       if (this.commands.length && this.args.length === 0 && !this._actionHandler && !this._defaultCommandName) {
         this.help({ error: true });
       }
-      this._outputHelpIfRequested(parsed.unknown);
+      outputHelpIfRequested(this, parsed.unknown);
       this._checkForMissingMandatoryOptions();
       this._checkForConflictingOptions();
       const checkForUnknownOptions = () => {
@@ -39067,7 +38836,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
             if (args.length > 0)
               unknown2.push(...args);
             break;
-          } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
+          } else if (arg === this._helpCommandName && this._hasImplicitHelpCommand()) {
             operands.push(arg);
             if (args.length > 0)
               operands.push(...args);
@@ -39229,7 +38998,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
       description = description || "output the version number";
       const versionOption = this.createOption(flags, description);
       this._versionOptionName = versionOption.attributeName();
-      this._registerOption(versionOption);
+      this.options.push(versionOption);
       this.on("option:" + versionOption.name(), () => {
         this._outputConfiguration.writeOut(`${str}
 `);
@@ -39261,11 +39030,6 @@ Expecting one of '${allowedValues.join("', '")}'`);
       }
       if (alias === command._name)
         throw new Error("Command alias can't be the same as its name");
-      const matchingCommand = this.parent?._findCommand(alias);
-      if (matchingCommand) {
-        const existingCmd = [matchingCommand.name()].concat(matchingCommand.aliases()).join("|");
-        throw new Error(`cannot add alias '${alias}' to command '${this.name()}' as already have command '${existingCmd}'`);
-      }
       command._aliases.push(alias);
       return this;
     }
@@ -39282,7 +39046,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
         const args = this.registeredArguments.map((arg) => {
           return humanReadableArgName(arg);
         });
-        return [].concat(this.options.length || this._helpOption !== null ? "[options]" : [], this.commands.length ? "[command]" : [], this.registeredArguments.length ? args : []).join(" ");
+        return [].concat(this.options.length || this._hasHelpOption ? "[options]" : [], this.commands.length ? "[command]" : [], this.registeredArguments.length ? args : []).join(" ");
       }
       this._usage = str;
       return this;
@@ -39305,38 +39069,23 @@ Expecting one of '${allowedValues.join("', '")}'`);
     }
     helpInformation(contextOptions) {
       const helper = this.createHelp();
-      const context = this._getOutputContext(contextOptions);
-      helper.prepareContext({
-        error: context.error,
-        helpWidth: context.helpWidth,
-        outputHasColors: context.hasColors
-      });
-      const text = helper.formatHelp(this, helper);
-      if (context.hasColors)
-        return text;
-      return this._outputConfiguration.stripColor(text);
+      if (helper.helpWidth === undefined) {
+        helper.helpWidth = contextOptions && contextOptions.error ? this._outputConfiguration.getErrHelpWidth() : this._outputConfiguration.getOutHelpWidth();
+      }
+      return helper.formatHelp(this, helper);
     }
-    _getOutputContext(contextOptions) {
+    _getHelpContext(contextOptions) {
       contextOptions = contextOptions || {};
-      const error = !!contextOptions.error;
-      let baseWrite;
-      let hasColors2;
-      let helpWidth;
-      if (error) {
-        baseWrite = (str) => this._outputConfiguration.writeErr(str);
-        hasColors2 = this._outputConfiguration.getErrHasColors();
-        helpWidth = this._outputConfiguration.getErrHelpWidth();
+      const context = { error: !!contextOptions.error };
+      let write;
+      if (context.error) {
+        write = (arg) => this._outputConfiguration.writeErr(arg);
       } else {
-        baseWrite = (str) => this._outputConfiguration.writeOut(str);
-        hasColors2 = this._outputConfiguration.getOutHasColors();
-        helpWidth = this._outputConfiguration.getOutHelpWidth();
-      }
-      const write = (str) => {
-        if (!hasColors2)
-          str = this._outputConfiguration.stripColor(str);
-        return baseWrite(str);
-      };
-      return { error, write, hasColors: hasColors2, helpWidth };
+        write = (arg) => this._outputConfiguration.writeOut(arg);
+      }
+      context.write = contextOptions.write || write;
+      context.command = this;
+      return context;
     }
     outputHelp(contextOptions) {
       let deprecatedCallback;
@@ -39344,55 +39093,38 @@ Expecting one of '${allowedValues.join("', '")}'`);
         deprecatedCallback = contextOptions;
         contextOptions = undefined;
       }
-      const outputContext = this._getOutputContext(contextOptions);
-      const eventContext = {
-        error: outputContext.error,
-        write: outputContext.write,
-        command: this
-      };
-      this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", eventContext));
-      this.emit("beforeHelp", eventContext);
-      let helpInformation = this.helpInformation({ error: outputContext.error });
+      const context = this._getHelpContext(contextOptions);
+      this._getCommandAndAncestors().reverse().forEach((command) => command.emit("beforeAllHelp", context));
+      this.emit("beforeHelp", context);
+      let helpInformation = this.helpInformation(context);
       if (deprecatedCallback) {
         helpInformation = deprecatedCallback(helpInformation);
         if (typeof helpInformation !== "string" && !Buffer.isBuffer(helpInformation)) {
           throw new Error("outputHelp callback must return a string or a Buffer");
         }
       }
-      outputContext.write(helpInformation);
-      if (this._getHelpOption()?.long) {
-        this.emit(this._getHelpOption().long);
+      context.write(helpInformation);
+      if (this._helpLongFlag) {
+        this.emit(this._helpLongFlag);
       }
-      this.emit("afterHelp", eventContext);
-      this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", eventContext));
+      this.emit("afterHelp", context);
+      this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", context));
     }
     helpOption(flags, description) {
       if (typeof flags === "boolean") {
-        if (flags) {
-          this._helpOption = this._helpOption ?? undefined;
-        } else {
-          this._helpOption = null;
-        }
+        this._hasHelpOption = flags;
         return this;
       }
-      flags = flags ?? "-h, --help";
-      description = description ?? "display help for command";
-      this._helpOption = this.createOption(flags, description);
-      return this;
-    }
-    _getHelpOption() {
-      if (this._helpOption === undefined) {
-        this.helpOption(undefined, undefined);
-      }
-      return this._helpOption;
-    }
-    addHelpOption(option) {
-      this._helpOption = option;
+      this._helpFlags = flags || this._helpFlags;
+      this._helpDescription = description || this._helpDescription;
+      const helpFlags = splitOptionFlags(this._helpFlags);
+      this._helpShortFlag = helpFlags.shortFlag;
+      this._helpLongFlag = helpFlags.longFlag;
       return this;
     }
     help(contextOptions) {
       this.outputHelp(contextOptions);
-      let exitCode = Number(process3.exitCode ?? 0);
+      let exitCode = process3.exitCode || 0;
       if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
         exitCode = 1;
       }
@@ -39419,13 +39151,12 @@ Expecting one of '${allowedValues.join("', '")}'`);
       });
       return this;
     }
-    _outputHelpIfRequested(args) {
-      const helpOption = this._getHelpOption();
-      const helpRequested = helpOption && args.find((arg) => helpOption.is(arg));
-      if (helpRequested) {
-        this.outputHelp();
-        this._exit(0, "commander.helpDisplayed", "(outputHelp)");
-      }
+  }
+  function outputHelpIfRequested(cmd, args) {
+    const helpOption = cmd._hasHelpOption && args.find((arg) => arg === cmd._helpLongFlag || arg === cmd._helpShortFlag);
+    if (helpOption) {
+      cmd.outputHelp();
+      cmd._exit(0, "commander.helpDisplayed", "(outputHelp)");
     }
   }
   function incrementNodeInspectorPort(args) {
@@ -39457,28 +39188,18 @@ Expecting one of '${allowedValues.join("', '")}'`);
       return arg;
     });
   }
-  function useColor() {
-    if (process3.env.NO_COLOR || process3.env.FORCE_COLOR === "0" || process3.env.FORCE_COLOR === "false")
-      return false;
-    if (process3.env.FORCE_COLOR || process3.env.CLICOLOR_FORCE !== undefined)
-      return true;
-    return;
-  }
   exports.Command = Command;
-  exports.useColor = useColor;
 });
 
 // ../../node_modules/commander/index.js
-var require_commander = __commonJS((exports) => {
+var require_commander = __commonJS((exports, module) => {
   var { Argument } = require_argument();
   var { Command } = require_command();
   var { CommanderError, InvalidArgumentError } = require_error3();
   var { Help } = require_help();
   var { Option } = require_option();
-  exports.program = new Command;
-  exports.createCommand = (name) => new Command(name);
-  exports.createOption = (flags, description) => new Option(flags, description);
-  exports.createArgument = (name, description) => new Argument(name, description);
+  exports = module.exports = new Command;
+  exports.program = exports;
   exports.Command = Command;
   exports.Option = Option;
   exports.Argument = Argument;
@@ -42616,8 +42337,7 @@ function getCustomLoaderByPath(path, cwd) {
         return requiredModule;
       }
     }
-  } catch (e) {
-  }
+  } catch (e) {}
   return null;
 }
 async function useCustomLoader(loaderPointer, cwd) {
@@ -42652,8 +42372,7 @@ function useStack(...fns) {
   return (input) => {
     function createNext(i) {
       if (i >= fns.length) {
-        return () => {
-        };
+        return () => {};
       }
       return function next() {
         fns[i](input, createNext(i + 1));
@@ -44587,8 +44306,7 @@ function createClient(options) {
     })())));
     if (socket.readyState === WebSocketImpl.CLOSING)
       await throwOnClose;
-    let release = () => {
-    };
+    let release = () => {};
     const released = new Promise((resolve) => release = resolve);
     return [
       socket,
@@ -44724,8 +44442,7 @@ function createClient(options) {
       const deferred = {
         done: false,
         error: null,
-        resolve: () => {
-        }
+        resolve: () => {}
       };
       const dispose = subscribe(request, {
         next(val) {
@@ -44886,8 +44603,7 @@ if (!shouldSkipPonyfill()) {
   try {
     const nodelibcurlName = "node-libcurl";
     globalThis.libcurl = globalThis.libcurl || __require(nodelibcurlName);
-  } catch (e) {
-  }
+  } catch (e) {}
 }
 var $fetch = ponyfills.fetch;
 var $Headers = ponyfills.Headers;
@@ -45245,8 +44961,7 @@ var Stopped = 2;
 var Done = 3;
 var Rejected = 4;
 var MAX_QUEUE_LENGTH = 1024;
-var NOOP = function() {
-};
+var NOOP = function() {};
 function consumeExecution(r) {
   var err = r.err;
   var execution = Promise.resolve(r.execution).then(function(value) {
@@ -46012,8 +45727,7 @@ async function t(t2, n) {
               if (d = f2["content-type"], d && ~d.indexOf("application/json"))
                 try {
                   r3 = JSON.parse(r3), l3 = true;
-                } catch (e3) {
-                }
+                } catch (e3) {}
               if (d = { headers: f2, body: r3, json: l3 }, a ? yield d : c.push(d), t5.slice(0, 2) === "--")
                 break e;
             } else
@@ -46058,8 +45772,7 @@ async function e2(e3, t2) {
             if (f = d["content-type"], f && ~f.indexOf("application/json"))
               try {
                 l2 = JSON.parse(String(l2)), i3 = true;
-              } catch (e7) {
-              }
+              } catch (e7) {}
             if (f = { headers: d, body: l2, json: i3 }, a ? yield f : s.push(f), n4[0] === 45 && n4[1] === 45)
               break e;
           } else
@@ -47765,8 +47478,7 @@ async function executeStreamIterator(initialIndex, iterator, exeContext, fieldNo
       filterSubsequentPayloads(exeContext, path, asyncPayloadRecord);
       asyncPayloadRecord.addItems(null);
       if (iterator?.return) {
-        iterator.return().catch(() => {
-        });
+        iterator.return().catch(() => {});
       }
       return;
     }
@@ -47801,8 +47513,7 @@ function filterSubsequentPayloads(exeContext, nullPath, currentAsyncRecord) {
       }
     }
     if (isStreamPayload(asyncRecord) && asyncRecord.iterator?.return) {
-      asyncRecord.iterator.return().catch(() => {
-      });
+      asyncRecord.iterator.return().catch(() => {});
     }
     exeContext.subsequentPayloads.delete(asyncRecord);
   });
@@ -50660,54 +50371,39 @@ async function fetchProcessedSchema(endpoint, accessToken, adminSecret, timeoutM
   const schema = await fetchGraphQLSchema(endpoint, accessToken, adminSecret, timeoutMs);
   return processSchema(schema);
 }
+var formatField = (name, field) => {
+  const args = field.args.length > 0 ? ` (${field.args.map((arg) => `${arg.name}: ${arg.type}`).join(", ")})` : "";
+  const returnType = ` → ${field.type}`;
+  return `• ${name}${args}${returnType}`;
+};
+var formatFields = (fields2) => {
+  return Object.entries(fields2).map(([name, field]) => formatField(name, field));
+};
 var createSchemaDescription = (schema) => {
   const parts = [];
   const queryType = schema.getQueryType();
   if (queryType) {
-    const fields2 = queryType.getFields();
-    for (const [name, field] of Object.entries(fields2)) {
-      const args = field.args.length > 0 ? ` (${field.args.map((arg) => `${arg.name}: ${arg.type}`).join(", ")})` : "";
-      const returnType = ` → ${field.type}`;
-      parts.push(`• ${name}${args}${returnType}`);
-    }
-    parts.push("");
+    parts.push(...formatFields(queryType.getFields()), "");
   }
   const mutationType = schema.getMutationType();
   if (mutationType) {
-    const fields2 = mutationType.getFields();
-    for (const [name, field] of Object.entries(fields2)) {
-      const args = field.args.length > 0 ? ` (${field.args.map((arg) => `${arg.name}: ${arg.type}`).join(", ")})` : "";
-      const returnType = ` → ${field.type}`;
-      parts.push(`• ${name}${args}${returnType}`);
-    }
-    parts.push("");
+    parts.push(...formatFields(mutationType.getFields()), "");
   }
   return parts.join(`
 `).trim();
 };
-var processFields = (type) => {
-  return type.getFields();
+var extractOperationFields = (schema, getType) => {
+  const type = getType(schema);
+  return type ? type.getFields() : {};
 };
 var extractQueries = (schema) => {
-  const queryType = schema.getQueryType();
-  if (!queryType) {
-    return {};
-  }
-  return processFields(queryType);
+  return extractOperationFields(schema, (s) => s.getQueryType());
 };
 var extractMutations = (schema) => {
-  const mutationType = schema.getMutationType();
-  if (!mutationType) {
-    return {};
-  }
-  return processFields(mutationType);
+  return extractOperationFields(schema, (s) => s.getMutationType());
 };
 var extractSubscriptions = (schema) => {
-  const subscriptionType = schema.getSubscriptionType();
-  if (!subscriptionType) {
-    return {};
-  }
-  return processFields(subscriptionType);
+  return extractOperationFields(schema, (s) => s.getSubscriptionType());
 };
 var extractTypes = (schema) => {
   const typeMap = schema.getTypeMap();
@@ -50787,8 +50483,7 @@ var portalQueries = (server, env3) => {
 var util;
 (function(util2) {
   util2.assertEqual = (val) => val;
-  function assertIs(_arg) {
-  }
+  function assertIs(_arg) {}
   util2.assertIs = assertIs;
   function assertNever(_x) {
     throw new Error;
@@ -56102,8 +55797,7 @@ function parseStringDef(def, refs) {
         case "trim":
           break;
         default:
-          ((_) => {
-          })(check);
+          ((_) => {})(check);
       }
     }
   }
@@ -58114,8 +57808,7 @@ class Minimatch {
     }
     return false;
   }
-  debug(..._) {
-  }
+  debug(..._) {}
   make() {
     const pattern = this.pattern;
     const options = this.options;
@@ -58947,12 +58640,9 @@ class LRUCache {
       return !!t2 && !!s && (cachedNow || getNow()) - s > t2;
     };
   }
-  #updateItemAge = () => {
-  };
-  #statusTTL = () => {
-  };
-  #setItemTTL = () => {
-  };
+  #updateItemAge = () => {};
+  #statusTTL = () => {};
+  #setItemTTL = () => {};
   #isStale = () => false;
   #initializeSizeTracking() {
     const sizes = new ZeroArray(this.#max);
@@ -58996,10 +58686,8 @@ class LRUCache {
       }
     };
   }
-  #removeItemSize = (_i) => {
-  };
-  #addItemSize = (_i, _s, _st) => {
-  };
+  #removeItemSize = (_i) => {};
+  #addItemSize = (_i, _s, _st) => {};
   #requireSize = (_k, _v, size, sizeCalculation) => {
     if (size || sizeCalculation) {
       throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
@@ -59798,8 +59486,7 @@ class Pipe {
   unpipe() {
     this.dest.removeListener("drain", this.ondrain);
   }
-  proxyErrors(_er) {
-  }
+  proxyErrors(_er) {}
   end() {
     this.unpipe();
     if (this.opts.end)
@@ -59909,8 +59596,7 @@ class Minipass extends EventEmitter {
   get aborted() {
     return this[ABORTED];
   }
-  set aborted(_) {
-  }
+  set aborted(_) {}
   write(chunk, encoding, cb) {
     if (this[ABORTED])
       return false;
@@ -60082,8 +59768,7 @@ class Minipass extends EventEmitter {
     return this[BUFFER].shift();
   }
   [FLUSH](noDrain = false) {
-    do {
-    } while (this[FLUSHCHUNK](this[BUFFERSHIFT]()) && this[BUFFER].length);
+    do {} while (this[FLUSHCHUNK](this[BUFFERSHIFT]()) && this[BUFFER].length);
     if (!noDrain && !this[BUFFER].length && !this[EOF])
       this.emit("drain");
   }
@@ -61028,8 +60713,7 @@ class PathBase {
     if (this.#asyncReaddirInFlight) {
       await this.#asyncReaddirInFlight;
     } else {
-      let resolve = () => {
-      };
+      let resolve = () => {};
       this.#asyncReaddirInFlight = new Promise((res) => resolve = res);
       try {
         for (const e3 of await this.#fs.promises.readdir(fullpath, {
@@ -62894,7 +62578,7 @@ var {
 var package_default = {
   name: "@settlemint/sdk-mcp",
   description: "MCP interface for SettleMint SDK, providing development tools and project management capabilities",
-  version: "1.1.16-pr0d9719ab",
+  version: "1.1.16-pr18cd48b2",
   type: "module",
   private: false,
   license: "FSL-1.1-MIT",
@@ -62903,11 +62587,11 @@ var package_default = {
     email: "support@settlemint.com",
     url: "https://settlemint.com"
   },
-  homepage: "https://github.com/settlemint/sdk/blob/main/sdk/mpc/README.md",
+  homepage: "https://github.com/settlemint/sdk/blob/main/sdk/mcp/README.md",
   repository: {
     type: "git",
     url: "git+https://github.com/settlemint/sdk.git",
-    directory: "sdk/mpc"
+    directory: "sdk/mcp"
   },
   bugs: {
     url: "https://github.com/settlemint/sdk/issues",
@@ -62921,7 +62605,7 @@ var package_default = {
     }
   },
   bin: {
-    settlemint: "dist/mcp.js"
+    "settlemint-mcp": "dist/mcp.js"
   },
   scripts: {
     build: "bun run build.ts",
@@ -62930,17 +62614,16 @@ var package_default = {
     "test:coverage": "bun test --coverage",
     typecheck: "tsc --noEmit",
     "publish-npm": "bun publish --tag ${TAG} --access public || exit 0",
-    docs: "bun scripts/create-docs.ts",
     prepack: "cp ../../LICENSE ."
   },
   dependencies: {
     "@graphql-tools/load": "8.0.17",
     "@graphql-tools/url-loader": "8.0.29",
     "@modelcontextprotocol/sdk": "1.6.1",
-    "@settlemint/sdk-js": "1.1.16-pr0d9719ab",
-    "@settlemint/sdk-utils": "1.1.16-pr0d9719ab",
-    "@commander-js/extra-typings": "13.1.0",
-    commander: "13.1.0",
+    "@settlemint/sdk-js": "1.1.16-pr18cd48b2",
+    "@settlemint/sdk-utils": "1.1.16-pr18cd48b2",
+    "@commander-js/extra-typings": "11.1.0",
+    commander: "11.1.0",
     zod: "3.24.2"
   },
   devDependencies: {},
@@ -63757,6 +63440,16 @@ var registerBlockchainConcepts = (server) => {
 
 // src/utils/sdl.ts
 var import_graphql53 = __toESM(require_graphql2(), 1);
+var processFieldTypes = (fields2, schema, collectedTypes) => {
+  for (const field of Object.values(fields2)) {
+    collectCustomTypes(field.type, schema, collectedTypes);
+    if ("args" in field && field.args.length > 0) {
+      for (const arg of field.args) {
+        collectCustomTypes(arg.type, schema, collectedTypes);
+      }
+    }
+  }
+};
 var collectCustomTypes = (type, schema, collectedTypes = new Set) => {
   const typeName = type.toString().replace(/[\[\]!]/g, "");
   if (collectedTypes.has(typeName) || ["String", "Int", "Float", "Boolean", "ID"].includes(typeName)) {
@@ -63767,20 +63460,9 @@ var collectCustomTypes = (type, schema, collectedTypes = new Set) => {
     return collectedTypes;
   }
   collectedTypes.add(typeName);
-  if (import_graphql53.isInputObjectType(schemaType)) {
-    const fields2 = schemaType.getFields();
-    for (const field of Object.values(fields2)) {
-      collectCustomTypes(field.type, schema, collectedTypes);
-    }
-  }
-  if (import_graphql53.isObjectType(schemaType)) {
+  if (import_graphql53.isInputObjectType(schemaType) || import_graphql53.isObjectType(schemaType)) {
     const fields2 = schemaType.getFields();
-    for (const field of Object.values(fields2)) {
-      collectCustomTypes(field.type, schema, collectedTypes);
-      for (const arg of field.args) {
-        collectCustomTypes(arg.type, schema, collectedTypes);
-      }
-    }
+    processFieldTypes(fields2, schema, collectedTypes);
   }
   return collectedTypes;
 };
@@ -64741,16 +64423,14 @@ function blockString(e4) {
 function ignored() {
   for (var e4 = 0 | i.charCodeAt(n++);e4 === 9 || e4 === 10 || e4 === 13 || e4 === 32 || e4 === 35 || e4 === 44 || e4 === 65279; e4 = 0 | i.charCodeAt(n++)) {
     if (e4 === 35) {
-      for (;(e4 = i.charCodeAt(n++)) !== 10 && e4 !== 13; ) {
-      }
+      for (;(e4 = i.charCodeAt(n++)) !== 10 && e4 !== 13; ) {}
     }
   }
   n--;
 }
 function name() {
   var e4 = n;
-  for (var r = 0 | i.charCodeAt(n++);r >= 48 && r <= 57 || r >= 65 && r <= 90 || r === 95 || r >= 97 && r <= 122; r = 0 | i.charCodeAt(n++)) {
-  }
+  for (var r = 0 | i.charCodeAt(n++);r >= 48 && r <= 57 || r >= 65 && r <= 90 || r === 95 || r >= 97 && r <= 122; r = 0 | i.charCodeAt(n++)) {}
   if (e4 === n - 1) {
     throw error("Name");
   }
@@ -64819,8 +64499,7 @@ function value(e4) {
         var s;
         n++;
         var c = false;
-        for (s = 0 | i.charCodeAt(n++);s === 92 && (n++, c = true) || s !== 10 && s !== 13 && s !== 34 && s; s = 0 | i.charCodeAt(n++)) {
-        }
+        for (s = 0 | i.charCodeAt(n++);s === 92 && (n++, c = true) || s !== 10 && s !== 13 && s !== 34 && s; s = 0 | i.charCodeAt(n++)) {}
         if (s !== 34) {
           throw error("StringValue");
         }
@@ -64843,8 +64522,7 @@ function value(e4) {
     case 57:
       var v = n++;
       var f;
-      for (;(f = 0 | i.charCodeAt(n++)) >= 48 && f <= 57; ) {
-      }
+      for (;(f = 0 | i.charCodeAt(n++)) >= 48 && f <= 57; ) {}
       var m = i.slice(v, --n);
       if ((f = i.charCodeAt(n)) === 46 || f === 69 || f === 101) {
         if ((r = advance(o)) == null) {
@@ -68607,9 +68285,9 @@ async function main() {
     process.exit(1);
   }
 }
-main().catch((error2) => {
+await main().catch((error2) => {
   console.error("Unhandled error:", error2);
   process.exit(1);
 });
 
-//# debugId=C802315A2EB302F264756E2164756E21
+//# debugId=1DDF9A3BE379750F64756E2164756E21