@hasna/shortlinks 0.1.7 → 0.1.9

package/dist/cli/index.js

@@ -1,3944 +0,0 @@
-#!/usr/bin/env bun
-// @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __require = import.meta.require;
-
-// node_modules/commander/lib/error.js
-var require_error = __commonJS((exports) => {
-  class CommanderError extends Error {
-    constructor(exitCode, code, message) {
-      super(message);
-      Error.captureStackTrace(this, this.constructor);
-      this.name = this.constructor.name;
-      this.code = code;
-      this.exitCode = exitCode;
-      this.nestedError = undefined;
-    }
-  }
-
-  class InvalidArgumentError extends CommanderError {
-    constructor(message) {
-      super(1, "commander.invalidArgument", message);
-      Error.captureStackTrace(this, this.constructor);
-      this.name = this.constructor.name;
-    }
-  }
-  exports.CommanderError = CommanderError;
-  exports.InvalidArgumentError = InvalidArgumentError;
-});
-
-// node_modules/commander/lib/argument.js
-var require_argument = __commonJS((exports) => {
-  var { InvalidArgumentError } = require_error();
-
-  class Argument {
-    constructor(name, description) {
-      this.description = description || "";
-      this.variadic = false;
-      this.parseArg = undefined;
-      this.defaultValue = undefined;
-      this.defaultValueDescription = undefined;
-      this.argChoices = undefined;
-      switch (name[0]) {
-        case "<":
-          this.required = true;
-          this._name = name.slice(1, -1);
-          break;
-        case "[":
-          this.required = false;
-          this._name = name.slice(1, -1);
-          break;
-        default:
-          this.required = true;
-          this._name = name;
-          break;
-      }
-      if (this._name.length > 3 && this._name.slice(-3) === "...") {
-        this.variadic = true;
-        this._name = this._name.slice(0, -3);
-      }
-    }
-    name() {
-      return this._name;
-    }
-    _concatValue(value, previous) {
-      if (previous === this.defaultValue || !Array.isArray(previous)) {
-        return [value];
-      }
-      return previous.concat(value);
-    }
-    default(value, description) {
-      this.defaultValue = value;
-      this.defaultValueDescription = description;
-      return this;
-    }
-    argParser(fn) {
-      this.parseArg = fn;
-      return this;
-    }
-    choices(values) {
-      this.argChoices = values.slice();
-      this.parseArg = (arg, previous) => {
-        if (!this.argChoices.includes(arg)) {
-          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
-        }
-        if (this.variadic) {
-          return this._concatValue(arg, previous);
-        }
-        return arg;
-      };
-      return this;
-    }
-    argRequired() {
-      this.required = true;
-      return this;
-    }
-    argOptional() {
-      this.required = false;
-      return this;
-    }
-  }
-  function humanReadableArgName(arg) {
-    const nameOutput = arg.name() + (arg.variadic === true ? "..." : "");
-    return arg.required ? "<" + nameOutput + ">" : "[" + nameOutput + "]";
-  }
-  exports.Argument = Argument;
-  exports.humanReadableArgName = humanReadableArgName;
-});
-
-// node_modules/commander/lib/help.js
-var require_help = __commonJS((exports) => {
-  var { humanReadableArgName } = require_argument();
-
-  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) {
-        visibleCommands.push(helpCommand);
-      }
-      if (this.sortSubcommands) {
-        visibleCommands.sort((a, b) => {
-          return a.name().localeCompare(b.name());
-        });
-      }
-      return visibleCommands;
-    }
-    compareOptions(a, b) {
-      const getSortKey = (option) => {
-        return option.short ? option.short.replace(/^-/, "") : option.long.replace(/^--/, "");
-      };
-      return getSortKey(a).localeCompare(getSortKey(b));
-    }
-    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));
-        }
-      }
-      if (this.sortOptions) {
-        visibleOptions.sort(this.compareOptions);
-      }
-      return visibleOptions;
-    }
-    visibleGlobalOptions(cmd) {
-      if (!this.showGlobalOptions)
-        return [];
-      const globalOptions = [];
-      for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
-        const visibleOptions = ancestorCmd.options.filter((option) => !option.hidden);
-        globalOptions.push(...visibleOptions);
-      }
-      if (this.sortOptions) {
-        globalOptions.sort(this.compareOptions);
-      }
-      return globalOptions;
-    }
-    visibleArguments(cmd) {
-      if (cmd._argsDescription) {
-        cmd.registeredArguments.forEach((argument) => {
-          argument.description = argument.description || cmd._argsDescription[argument.name()] || "";
-        });
-      }
-      if (cmd.registeredArguments.find((argument) => argument.description)) {
-        return cmd.registeredArguments;
-      }
-      return [];
-    }
-    subcommandTerm(cmd) {
-      const args = cmd.registeredArguments.map((arg) => humanReadableArgName(arg)).join(" ");
-      return cmd._name + (cmd._aliases[0] ? "|" + cmd._aliases[0] : "") + (cmd.options.length ? " [options]" : "") + (args ? " " + args : "");
-    }
-    optionTerm(option) {
-      return option.flags;
-    }
-    argumentTerm(argument) {
-      return argument.name();
-    }
-    longestSubcommandTermLength(cmd, helper) {
-      return helper.visibleCommands(cmd).reduce((max, command) => {
-        return Math.max(max, this.displayWidth(helper.styleSubcommandTerm(helper.subcommandTerm(command))));
-      }, 0);
-    }
-    longestOptionTermLength(cmd, helper) {
-      return helper.visibleOptions(cmd).reduce((max, option) => {
-        return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
-      }, 0);
-    }
-    longestGlobalOptionTermLength(cmd, helper) {
-      return helper.visibleGlobalOptions(cmd).reduce((max, option) => {
-        return Math.max(max, this.displayWidth(helper.styleOptionTerm(helper.optionTerm(option))));
-      }, 0);
-    }
-    longestArgumentTermLength(cmd, helper) {
-      return helper.visibleArguments(cmd).reduce((max, argument) => {
-        return Math.max(max, this.displayWidth(helper.styleArgumentTerm(helper.argumentTerm(argument))));
-      }, 0);
-    }
-    commandUsage(cmd) {
-      let cmdName = cmd._name;
-      if (cmd._aliases[0]) {
-        cmdName = cmdName + "|" + cmd._aliases[0];
-      }
-      let ancestorCmdNames = "";
-      for (let ancestorCmd = cmd.parent;ancestorCmd; ancestorCmd = ancestorCmd.parent) {
-        ancestorCmdNames = ancestorCmd.name() + " " + ancestorCmdNames;
-      }
-      return ancestorCmdNames + cmdName + " " + cmd.usage();
-    }
-    commandDescription(cmd) {
-      return cmd.description();
-    }
-    subcommandDescription(cmd) {
-      return cmd.summary() || cmd.description();
-    }
-    optionDescription(option) {
-      const extraInfo = [];
-      if (option.argChoices) {
-        extraInfo.push(`choices: ${option.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
-      }
-      if (option.defaultValue !== undefined) {
-        const showDefault = option.required || option.optional || option.isBoolean() && typeof option.defaultValue === "boolean";
-        if (showDefault) {
-          extraInfo.push(`default: ${option.defaultValueDescription || JSON.stringify(option.defaultValue)}`);
-        }
-      }
-      if (option.presetArg !== undefined && option.optional) {
-        extraInfo.push(`preset: ${JSON.stringify(option.presetArg)}`);
-      }
-      if (option.envVar !== undefined) {
-        extraInfo.push(`env: ${option.envVar}`);
-      }
-      if (extraInfo.length > 0) {
-        return `${option.description} (${extraInfo.join(", ")})`;
-      }
-      return option.description;
-    }
-    argumentDescription(argument) {
-      const extraInfo = [];
-      if (argument.argChoices) {
-        extraInfo.push(`choices: ${argument.argChoices.map((choice) => JSON.stringify(choice)).join(", ")}`);
-      }
-      if (argument.defaultValue !== undefined) {
-        extraInfo.push(`default: ${argument.defaultValueDescription || JSON.stringify(argument.defaultValue)}`);
-      }
-      if (extraInfo.length > 0) {
-        const extraDescription = `(${extraInfo.join(", ")})`;
-        if (argument.description) {
-          return `${argument.description} ${extraDescription}`;
-        }
-        return extraDescription;
-      }
-      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);
-      }
-      let output = [
-        `${helper.styleTitle("Usage:")} ${helper.styleUsage(helper.commandUsage(cmd))}`,
-        ""
-      ];
-      const commandDescription = helper.commandDescription(cmd);
-      if (commandDescription.length > 0) {
-        output = output.concat([
-          helper.boxWrap(helper.styleCommandDescription(commandDescription), helpWidth),
-          ""
-        ]);
-      }
-      const argumentList = helper.visibleArguments(cmd).map((argument) => {
-        return callFormatItem(helper.styleArgumentTerm(helper.argumentTerm(argument)), helper.styleArgumentDescription(helper.argumentDescription(argument)));
-      });
-      if (argumentList.length > 0) {
-        output = output.concat([
-          helper.styleTitle("Arguments:"),
-          ...argumentList,
-          ""
-        ]);
-      }
-      const optionList = helper.visibleOptions(cmd).map((option) => {
-        return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
-      });
-      if (optionList.length > 0) {
-        output = output.concat([
-          helper.styleTitle("Options:"),
-          ...optionList,
-          ""
-        ]);
-      }
-      if (helper.showGlobalOptions) {
-        const globalOptionList = helper.visibleGlobalOptions(cmd).map((option) => {
-          return callFormatItem(helper.styleOptionTerm(helper.optionTerm(option)), helper.styleOptionDescription(helper.optionDescription(option)));
-        });
-        if (globalOptionList.length > 0) {
-          output = output.concat([
-            helper.styleTitle("Global Options:"),
-            ...globalOptionList,
-            ""
-          ]);
-        }
-      }
-      const commandList = helper.visibleCommands(cmd).map((cmd2) => {
-        return callFormatItem(helper.styleSubcommandTerm(helper.subcommandTerm(cmd2)), helper.styleSubcommandDescription(helper.subcommandDescription(cmd2)));
-      });
-      if (commandList.length > 0) {
-        output = output.concat([
-          helper.styleTitle("Commands:"),
-          ...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)
-        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(`
-`);
-    }
-  }
-  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
-var require_option = __commonJS((exports) => {
-  var { InvalidArgumentError } = require_error();
-
-  class Option {
-    constructor(flags, description) {
-      this.flags = flags;
-      this.description = description || "";
-      this.required = flags.includes("<");
-      this.optional = flags.includes("[");
-      this.variadic = /\w\.\.\.[>\]]$/.test(flags);
-      this.mandatory = false;
-      const optionFlags = splitOptionFlags(flags);
-      this.short = optionFlags.shortFlag;
-      this.long = optionFlags.longFlag;
-      this.negate = false;
-      if (this.long) {
-        this.negate = this.long.startsWith("--no-");
-      }
-      this.defaultValue = undefined;
-      this.defaultValueDescription = undefined;
-      this.presetArg = undefined;
-      this.envVar = undefined;
-      this.parseArg = undefined;
-      this.hidden = false;
-      this.argChoices = undefined;
-      this.conflictsWith = [];
-      this.implied = undefined;
-    }
-    default(value, description) {
-      this.defaultValue = value;
-      this.defaultValueDescription = description;
-      return this;
-    }
-    preset(arg) {
-      this.presetArg = arg;
-      return this;
-    }
-    conflicts(names) {
-      this.conflictsWith = this.conflictsWith.concat(names);
-      return this;
-    }
-    implies(impliedOptionValues) {
-      let newImplied = impliedOptionValues;
-      if (typeof impliedOptionValues === "string") {
-        newImplied = { [impliedOptionValues]: true };
-      }
-      this.implied = Object.assign(this.implied || {}, newImplied);
-      return this;
-    }
-    env(name) {
-      this.envVar = name;
-      return this;
-    }
-    argParser(fn) {
-      this.parseArg = fn;
-      return this;
-    }
-    makeOptionMandatory(mandatory = true) {
-      this.mandatory = !!mandatory;
-      return this;
-    }
-    hideHelp(hide = true) {
-      this.hidden = !!hide;
-      return this;
-    }
-    _concatValue(value, previous) {
-      if (previous === this.defaultValue || !Array.isArray(previous)) {
-        return [value];
-      }
-      return previous.concat(value);
-    }
-    choices(values) {
-      this.argChoices = values.slice();
-      this.parseArg = (arg, previous) => {
-        if (!this.argChoices.includes(arg)) {
-          throw new InvalidArgumentError(`Allowed choices are ${this.argChoices.join(", ")}.`);
-        }
-        if (this.variadic) {
-          return this._concatValue(arg, previous);
-        }
-        return arg;
-      };
-      return this;
-    }
-    name() {
-      if (this.long) {
-        return this.long.replace(/^--/, "");
-      }
-      return this.short.replace(/^-/, "");
-    }
-    attributeName() {
-      if (this.negate) {
-        return camelcase(this.name().replace(/^no-/, ""));
-      }
-      return camelcase(this.name());
-    }
-    is(arg) {
-      return this.short === arg || this.long === arg;
-    }
-    isBoolean() {
-      return !this.required && !this.optional && !this.negate;
-    }
-  }
-
-  class DualOptions {
-    constructor(options) {
-      this.positiveOptions = new Map;
-      this.negativeOptions = new Map;
-      this.dualOptions = new Set;
-      options.forEach((option) => {
-        if (option.negate) {
-          this.negativeOptions.set(option.attributeName(), option);
-        } else {
-          this.positiveOptions.set(option.attributeName(), option);
-        }
-      });
-      this.negativeOptions.forEach((value, key) => {
-        if (this.positiveOptions.has(key)) {
-          this.dualOptions.add(key);
-        }
-      });
-    }
-    valueFromOption(value, option) {
-      const optionKey = option.attributeName();
-      if (!this.dualOptions.has(optionKey))
-        return true;
-      const preset = this.negativeOptions.get(optionKey).presetArg;
-      const negativeValue = preset !== undefined ? preset : false;
-      return option.negate === (negativeValue === value);
-    }
-  }
-  function camelcase(str) {
-    return str.split("-").reduce((str2, word) => {
-      return str2 + word[0].toUpperCase() + word.slice(1);
-    });
-  }
-  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]))
-      shortFlag = flagParts.shift();
-    if (!shortFlag && longFlagExp.test(flagParts[0])) {
-      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}'.`);
-    return { shortFlag, longFlag };
-  }
-  exports.Option = Option;
-  exports.DualOptions = DualOptions;
-});
-
-// node_modules/commander/lib/suggestSimilar.js
-var require_suggestSimilar = __commonJS((exports) => {
-  var maxDistance = 3;
-  function editDistance(a, b) {
-    if (Math.abs(a.length - b.length) > maxDistance)
-      return Math.max(a.length, b.length);
-    const d = [];
-    for (let i = 0;i <= a.length; i++) {
-      d[i] = [i];
-    }
-    for (let j = 0;j <= b.length; j++) {
-      d[0][j] = j;
-    }
-    for (let j = 1;j <= b.length; j++) {
-      for (let i = 1;i <= a.length; i++) {
-        let cost = 1;
-        if (a[i - 1] === b[j - 1]) {
-          cost = 0;
-        } else {
-          cost = 1;
-        }
-        d[i][j] = Math.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
-        if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
-          d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + 1);
-        }
-      }
-    }
-    return d[a.length][b.length];
-  }
-  function suggestSimilar(word, candidates) {
-    if (!candidates || candidates.length === 0)
-      return "";
-    candidates = Array.from(new Set(candidates));
-    const searchingOptions = word.startsWith("--");
-    if (searchingOptions) {
-      word = word.slice(2);
-      candidates = candidates.map((candidate) => candidate.slice(2));
-    }
-    let similar = [];
-    let bestDistance = maxDistance;
-    const minSimilarity = 0.4;
-    candidates.forEach((candidate) => {
-      if (candidate.length <= 1)
-        return;
-      const distance = editDistance(word, candidate);
-      const length = Math.max(word.length, candidate.length);
-      const similarity = (length - distance) / length;
-      if (similarity > minSimilarity) {
-        if (distance < bestDistance) {
-          bestDistance = distance;
-          similar = [candidate];
-        } else if (distance === bestDistance) {
-          similar.push(candidate);
-        }
-      }
-    });
-    similar.sort((a, b) => a.localeCompare(b));
-    if (searchingOptions) {
-      similar = similar.map((candidate) => `--${candidate}`);
-    }
-    if (similar.length > 1) {
-      return `
-(Did you mean one of ${similar.join(", ")}?)`;
-    }
-    if (similar.length === 1) {
-      return `
-(Did you mean ${similar[0]}?)`;
-    }
-    return "";
-  }
-  exports.suggestSimilar = suggestSimilar;
-});
-
-// node_modules/commander/lib/command.js
-var require_command = __commonJS((exports) => {
-  var EventEmitter = __require("events").EventEmitter;
-  var childProcess = __require("child_process");
-  var path = __require("path");
-  var fs = __require("fs");
-  var process2 = __require("process");
-  var { Argument, humanReadableArgName } = require_argument();
-  var { CommanderError } = require_error();
-  var { Help, stripColor } = require_help();
-  var { Option, DualOptions } = require_option();
-  var { suggestSimilar } = require_suggestSimilar();
-
-  class Command extends EventEmitter {
-    constructor(name) {
-      super();
-      this.commands = [];
-      this.options = [];
-      this.parent = null;
-      this._allowUnknownOption = false;
-      this._allowExcessArguments = false;
-      this.registeredArguments = [];
-      this._args = this.registeredArguments;
-      this.args = [];
-      this.rawArgs = [];
-      this.processedArgs = [];
-      this._scriptPath = null;
-      this._name = name || "";
-      this._optionValues = {};
-      this._optionValueSources = {};
-      this._storeOptionsAsProperties = false;
-      this._actionHandler = null;
-      this._executableHandler = false;
-      this._executableFile = null;
-      this._executableDir = null;
-      this._defaultCommandName = null;
-      this._exitCallback = null;
-      this._aliases = [];
-      this._combineFlagAndOptionalValue = true;
-      this._description = "";
-      this._summary = "";
-      this._argsDescription = undefined;
-      this._enablePositionalOptions = false;
-      this._passThroughOptions = false;
-      this._lifeCycleHooks = {};
-      this._showHelpAfterError = false;
-      this._showSuggestionAfterError = true;
-      this._savedState = null;
-      this._outputConfiguration = {
-        writeOut: (str) => process2.stdout.write(str),
-        writeErr: (str) => process2.stderr.write(str),
-        outputError: (str, write) => write(str),
-        getOutHelpWidth: () => process2.stdout.isTTY ? process2.stdout.columns : undefined,
-        getErrHelpWidth: () => process2.stderr.isTTY ? process2.stderr.columns : undefined,
-        getOutHasColors: () => useColor() ?? (process2.stdout.isTTY && process2.stdout.hasColors?.()),
-        getErrHasColors: () => useColor() ?? (process2.stderr.isTTY && process2.stderr.hasColors?.()),
-        stripColor: (str) => stripColor(str)
-      };
-      this._hidden = false;
-      this._helpOption = undefined;
-      this._addImplicitHelpCommand = undefined;
-      this._helpCommand = undefined;
-      this._helpConfiguration = {};
-    }
-    copyInheritedSettings(sourceCommand) {
-      this._outputConfiguration = sourceCommand._outputConfiguration;
-      this._helpOption = sourceCommand._helpOption;
-      this._helpCommand = sourceCommand._helpCommand;
-      this._helpConfiguration = sourceCommand._helpConfiguration;
-      this._exitCallback = sourceCommand._exitCallback;
-      this._storeOptionsAsProperties = sourceCommand._storeOptionsAsProperties;
-      this._combineFlagAndOptionalValue = sourceCommand._combineFlagAndOptionalValue;
-      this._allowExcessArguments = sourceCommand._allowExcessArguments;
-      this._enablePositionalOptions = sourceCommand._enablePositionalOptions;
-      this._showHelpAfterError = sourceCommand._showHelpAfterError;
-      this._showSuggestionAfterError = sourceCommand._showSuggestionAfterError;
-      return this;
-    }
-    _getCommandAndAncestors() {
-      const result = [];
-      for (let command = this;command; command = command.parent) {
-        result.push(command);
-      }
-      return result;
-    }
-    command(nameAndArgs, actionOptsOrExecDesc, execOpts) {
-      let desc = actionOptsOrExecDesc;
-      let opts = execOpts;
-      if (typeof desc === "object" && desc !== null) {
-        opts = desc;
-        desc = null;
-      }
-      opts = opts || {};
-      const [, name, args] = nameAndArgs.match(/([^ ]+) *(.*)/);
-      const cmd = this.createCommand(name);
-      if (desc) {
-        cmd.description(desc);
-        cmd._executableHandler = true;
-      }
-      if (opts.isDefault)
-        this._defaultCommandName = cmd._name;
-      cmd._hidden = !!(opts.noHelp || opts.hidden);
-      cmd._executableFile = opts.executableFile || null;
-      if (args)
-        cmd.arguments(args);
-      this._registerCommand(cmd);
-      cmd.parent = this;
-      cmd.copyInheritedSettings(this);
-      if (desc)
-        return this;
-      return cmd;
-    }
-    createCommand(name) {
-      return new Command(name);
-    }
-    createHelp() {
-      return Object.assign(new Help, this.configureHelp());
-    }
-    configureHelp(configuration) {
-      if (configuration === undefined)
-        return this._helpConfiguration;
-      this._helpConfiguration = configuration;
-      return this;
-    }
-    configureOutput(configuration) {
-      if (configuration === undefined)
-        return this._outputConfiguration;
-      Object.assign(this._outputConfiguration, configuration);
-      return this;
-    }
-    showHelpAfterError(displayHelp = true) {
-      if (typeof displayHelp !== "string")
-        displayHelp = !!displayHelp;
-      this._showHelpAfterError = displayHelp;
-      return this;
-    }
-    showSuggestionAfterError(displaySuggestion = true) {
-      this._showSuggestionAfterError = !!displaySuggestion;
-      return this;
-    }
-    addCommand(cmd, opts) {
-      if (!cmd._name) {
-        throw new Error(`Command passed to .addCommand() must have a name
-- specify the name in Command constructor or using .name()`);
-      }
-      opts = opts || {};
-      if (opts.isDefault)
-        this._defaultCommandName = cmd._name;
-      if (opts.noHelp || opts.hidden)
-        cmd._hidden = true;
-      this._registerCommand(cmd);
-      cmd.parent = this;
-      cmd._checkForBrokenPassThrough();
-      return this;
-    }
-    createArgument(name, description) {
-      return new Argument(name, description);
-    }
-    argument(name, description, fn, defaultValue) {
-      const argument = this.createArgument(name, description);
-      if (typeof fn === "function") {
-        argument.default(defaultValue).argParser(fn);
-      } else {
-        argument.default(fn);
-      }
-      this.addArgument(argument);
-      return this;
-    }
-    arguments(names) {
-      names.trim().split(/ +/).forEach((detail) => {
-        this.argument(detail);
-      });
-      return this;
-    }
-    addArgument(argument) {
-      const previousArgument = this.registeredArguments.slice(-1)[0];
-      if (previousArgument && previousArgument.variadic) {
-        throw new Error(`only the last argument can be variadic '${previousArgument.name()}'`);
-      }
-      if (argument.required && argument.defaultValue !== undefined && argument.parseArg === undefined) {
-        throw new Error(`a default value for a required argument is never used: '${argument.name()}'`);
-      }
-      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;
-      }
-      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;
-      }
-      return null;
-    }
-    hook(event, listener) {
-      const allowedValues = ["preSubcommand", "preAction", "postAction"];
-      if (!allowedValues.includes(event)) {
-        throw new Error(`Unexpected value for event passed to hook : '${event}'.
-Expecting one of '${allowedValues.join("', '")}'`);
-      }
-      if (this._lifeCycleHooks[event]) {
-        this._lifeCycleHooks[event].push(listener);
-      } else {
-        this._lifeCycleHooks[event] = [listener];
-      }
-      return this;
-    }
-    exitOverride(fn) {
-      if (fn) {
-        this._exitCallback = fn;
-      } else {
-        this._exitCallback = (err) => {
-          if (err.code !== "commander.executeSubCommandAsync") {
-            throw err;
-          } else {}
-        };
-      }
-      return this;
-    }
-    _exit(exitCode, code, message) {
-      if (this._exitCallback) {
-        this._exitCallback(new CommanderError(exitCode, code, message));
-      }
-      process2.exit(exitCode);
-    }
-    action(fn) {
-      const listener = (args) => {
-        const expectedArgsCount = this.registeredArguments.length;
-        const actionArgs = args.slice(0, expectedArgsCount);
-        if (this._storeOptionsAsProperties) {
-          actionArgs[expectedArgsCount] = this;
-        } else {
-          actionArgs[expectedArgsCount] = this.opts();
-        }
-        actionArgs.push(this);
-        return fn.apply(this, actionArgs);
-      };
-      this._actionHandler = listener;
-      return this;
-    }
-    createOption(flags, description) {
-      return new Option(flags, description);
-    }
-    _callParseArg(target, value, previous, invalidArgumentMessage) {
-      try {
-        return target.parseArg(value, previous);
-      } catch (err) {
-        if (err.code === "commander.invalidArgument") {
-          const message = `${invalidArgumentMessage} ${err.message}`;
-          this.error(message, { exitCode: err.exitCode, code: err.code });
-        }
-        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) {
-        const positiveLongFlag = option.long.replace(/^--no-/, "--");
-        if (!this._findOption(positiveLongFlag)) {
-          this.setOptionValueWithSource(name, option.defaultValue === undefined ? true : option.defaultValue, "default");
-        }
-      } else if (option.defaultValue !== undefined) {
-        this.setOptionValueWithSource(name, option.defaultValue, "default");
-      }
-      const handleOptionValue = (val, invalidValueMessage, valueSource) => {
-        if (val == null && option.presetArg !== undefined) {
-          val = option.presetArg;
-        }
-        const oldValue = this.getOptionValue(name);
-        if (val !== null && option.parseArg) {
-          val = this._callParseArg(option, val, oldValue, invalidValueMessage);
-        } else if (val !== null && option.variadic) {
-          val = option._concatValue(val, oldValue);
-        }
-        if (val == null) {
-          if (option.negate) {
-            val = false;
-          } else if (option.isBoolean() || option.optional) {
-            val = true;
-          } else {
-            val = "";
-          }
-        }
-        this.setOptionValueWithSource(name, val, valueSource);
-      };
-      this.on("option:" + oname, (val) => {
-        const invalidValueMessage = `error: option '${option.flags}' argument '${val}' is invalid.`;
-        handleOptionValue(val, invalidValueMessage, "cli");
-      });
-      if (option.envVar) {
-        this.on("optionEnv:" + oname, (val) => {
-          const invalidValueMessage = `error: option '${option.flags}' value '${val}' from env '${option.envVar}' is invalid.`;
-          handleOptionValue(val, invalidValueMessage, "env");
-        });
-      }
-      return this;
-    }
-    _optionEx(config, flags, description, fn, defaultValue) {
-      if (typeof flags === "object" && flags instanceof Option) {
-        throw new Error("To add an Option object use addOption() instead of option() or requiredOption()");
-      }
-      const option = this.createOption(flags, description);
-      option.makeOptionMandatory(!!config.mandatory);
-      if (typeof fn === "function") {
-        option.default(defaultValue).argParser(fn);
-      } else if (fn instanceof RegExp) {
-        const regex = fn;
-        fn = (val, def) => {
-          const m = regex.exec(val);
-          return m ? m[0] : def;
-        };
-        option.default(defaultValue).argParser(fn);
-      } else {
-        option.default(fn);
-      }
-      return this.addOption(option);
-    }
-    option(flags, description, parseArg, defaultValue) {
-      return this._optionEx({}, flags, description, parseArg, defaultValue);
-    }
-    requiredOption(flags, description, parseArg, defaultValue) {
-      return this._optionEx({ mandatory: true }, flags, description, parseArg, defaultValue);
-    }
-    combineFlagAndOptionalValue(combine = true) {
-      this._combineFlagAndOptionalValue = !!combine;
-      return this;
-    }
-    allowUnknownOption(allowUnknown = true) {
-      this._allowUnknownOption = !!allowUnknown;
-      return this;
-    }
-    allowExcessArguments(allowExcess = true) {
-      this._allowExcessArguments = !!allowExcess;
-      return this;
-    }
-    enablePositionalOptions(positional = true) {
-      this._enablePositionalOptions = !!positional;
-      return this;
-    }
-    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)`);
-      }
-    }
-    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;
-    }
-    getOptionValue(key) {
-      if (this._storeOptionsAsProperties) {
-        return this[key];
-      }
-      return this._optionValues[key];
-    }
-    setOptionValue(key, value) {
-      return this.setOptionValueWithSource(key, value, undefined);
-    }
-    setOptionValueWithSource(key, value, source) {
-      if (this._storeOptionsAsProperties) {
-        this[key] = value;
-      } else {
-        this._optionValues[key] = value;
-      }
-      this._optionValueSources[key] = source;
-      return this;
-    }
-    getOptionValueSource(key) {
-      return this._optionValueSources[key];
-    }
-    getOptionValueSourceWithGlobals(key) {
-      let source;
-      this._getCommandAndAncestors().forEach((cmd) => {
-        if (cmd.getOptionValueSource(key) !== undefined) {
-          source = cmd.getOptionValueSource(key);
-        }
-      });
-      return source;
-    }
-    _prepareUserArgs(argv, parseOptions) {
-      if (argv !== undefined && !Array.isArray(argv)) {
-        throw new Error("first parameter to parse must be array or undefined");
-      }
-      parseOptions = parseOptions || {};
-      if (argv === undefined && parseOptions.from === undefined) {
-        if (process2.versions?.electron) {
-          parseOptions.from = "electron";
-        }
-        const execArgv = process2.execArgv ?? [];
-        if (execArgv.includes("-e") || execArgv.includes("--eval") || execArgv.includes("-p") || execArgv.includes("--print")) {
-          parseOptions.from = "eval";
-        }
-      }
-      if (argv === undefined) {
-        argv = process2.argv;
-      }
-      this.rawArgs = argv.slice();
-      let userArgs;
-      switch (parseOptions.from) {
-        case undefined:
-        case "node":
-          this._scriptPath = argv[1];
-          userArgs = argv.slice(2);
-          break;
-        case "electron":
-          if (process2.defaultApp) {
-            this._scriptPath = argv[1];
-            userArgs = argv.slice(2);
-          } else {
-            userArgs = argv.slice(1);
-          }
-          break;
-        case "user":
-          userArgs = argv.slice(0);
-          break;
-        case "eval":
-          userArgs = argv.slice(1);
-          break;
-        default:
-          throw new Error(`unexpected parse option { from: '${parseOptions.from}' }`);
-      }
-      if (!this._name && this._scriptPath)
-        this.nameFromFilename(this._scriptPath);
-      this._name = this._name || "program";
-      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;
-      const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
-      function findFile(baseDir, baseName) {
-        const localBin = path.resolve(baseDir, baseName);
-        if (fs.existsSync(localBin))
-          return localBin;
-        if (sourceExt.includes(path.extname(baseName)))
-          return;
-        const foundExt = sourceExt.find((ext) => fs.existsSync(`${localBin}${ext}`));
-        if (foundExt)
-          return `${localBin}${foundExt}`;
-        return;
-      }
-      this._checkForMissingMandatoryOptions();
-      this._checkForConflictingOptions();
-      let executableFile = subcommand._executableFile || `${this._name}-${subcommand._name}`;
-      let executableDir = this._executableDir || "";
-      if (this._scriptPath) {
-        let resolvedScriptPath;
-        try {
-          resolvedScriptPath = fs.realpathSync(this._scriptPath);
-        } catch {
-          resolvedScriptPath = this._scriptPath;
-        }
-        executableDir = path.resolve(path.dirname(resolvedScriptPath), executableDir);
-      }
-      if (executableDir) {
-        let localFile = findFile(executableDir, executableFile);
-        if (!localFile && !subcommand._executableFile && this._scriptPath) {
-          const legacyName = path.basename(this._scriptPath, path.extname(this._scriptPath));
-          if (legacyName !== this._name) {
-            localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
-          }
-        }
-        executableFile = localFile || executableFile;
-      }
-      launchWithNode = sourceExt.includes(path.extname(executableFile));
-      let proc;
-      if (process2.platform !== "win32") {
-        if (launchWithNode) {
-          args.unshift(executableFile);
-          args = incrementNodeInspectorPort(process2.execArgv).concat(args);
-          proc = childProcess.spawn(process2.argv[0], args, { stdio: "inherit" });
-        } else {
-          proc = childProcess.spawn(executableFile, args, { stdio: "inherit" });
-        }
-      } else {
-        this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
-        args.unshift(executableFile);
-        args = incrementNodeInspectorPort(process2.execArgv).concat(args);
-        proc = childProcess.spawn(process2.execPath, args, { stdio: "inherit" });
-      }
-      if (!proc.killed) {
-        const signals = ["SIGUSR1", "SIGUSR2", "SIGTERM", "SIGINT", "SIGHUP"];
-        signals.forEach((signal) => {
-          process2.on(signal, () => {
-            if (proc.killed === false && proc.exitCode === null) {
-              proc.kill(signal);
-            }
-          });
-        });
-      }
-      const exitCallback = this._exitCallback;
-      proc.on("close", (code) => {
-        code = code ?? 1;
-        if (!exitCallback) {
-          process2.exit(code);
-        } else {
-          exitCallback(new CommanderError(code, "commander.executeSubCommandAsync", "(close)"));
-        }
-      });
-      proc.on("error", (err) => {
-        if (err.code === "ENOENT") {
-          this._checkForMissingExecutable(executableFile, executableDir, subcommand._name);
-        } else if (err.code === "EACCES") {
-          throw new Error(`'${executableFile}' not executable`);
-        }
-        if (!exitCallback) {
-          process2.exit(1);
-        } else {
-          const wrappedError = new CommanderError(1, "commander.executeSubCommandAsync", "(error)");
-          wrappedError.nestedError = err;
-          exitCallback(wrappedError);
-        }
-      });
-      this.runningCommand = proc;
-    }
-    _dispatchSubcommand(commandName, operands, unknown) {
-      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, () => {
-        if (subCommand._executableHandler) {
-          this._executeSubCommand(subCommand, operands.concat(unknown));
-        } else {
-          return subCommand._parseCommand(operands, unknown);
-        }
-      });
-      return promiseChain;
-    }
-    _dispatchHelpCommand(subcommandName) {
-      if (!subcommandName) {
-        this.help();
-      }
-      const subCommand = this._findCommand(subcommandName);
-      if (subCommand && !subCommand._executableHandler) {
-        subCommand.help();
-      }
-      return this._dispatchSubcommand(subcommandName, [], [this._getHelpOption()?.long ?? this._getHelpOption()?.short ?? "--help"]);
-    }
-    _checkNumberOfArguments() {
-      this.registeredArguments.forEach((arg, i) => {
-        if (arg.required && this.args[i] == null) {
-          this.missingArgument(arg.name());
-        }
-      });
-      if (this.registeredArguments.length > 0 && this.registeredArguments[this.registeredArguments.length - 1].variadic) {
-        return;
-      }
-      if (this.args.length > this.registeredArguments.length) {
-        this._excessArguments(this.args);
-      }
-    }
-    _processArguments() {
-      const myParseArg = (argument, value, previous) => {
-        let parsedValue = value;
-        if (value !== null && argument.parseArg) {
-          const invalidValueMessage = `error: command-argument value '${value}' is invalid for argument '${argument.name()}'.`;
-          parsedValue = this._callParseArg(argument, value, previous, invalidValueMessage);
-        }
-        return parsedValue;
-      };
-      this._checkNumberOfArguments();
-      const processedArgs = [];
-      this.registeredArguments.forEach((declaredArg, index) => {
-        let value = declaredArg.defaultValue;
-        if (declaredArg.variadic) {
-          if (index < this.args.length) {
-            value = this.args.slice(index);
-            if (declaredArg.parseArg) {
-              value = value.reduce((processed, v) => {
-                return myParseArg(declaredArg, v, processed);
-              }, declaredArg.defaultValue);
-            }
-          } else if (value === undefined) {
-            value = [];
-          }
-        } else if (index < this.args.length) {
-          value = this.args[index];
-          if (declaredArg.parseArg) {
-            value = myParseArg(declaredArg, value, declaredArg.defaultValue);
-          }
-        }
-        processedArgs[index] = value;
-      });
-      this.processedArgs = processedArgs;
-    }
-    _chainOrCall(promise, fn) {
-      if (promise && promise.then && typeof promise.then === "function") {
-        return promise.then(() => fn());
-      }
-      return fn();
-    }
-    _chainOrCallHooks(promise, event) {
-      let result = promise;
-      const hooks = [];
-      this._getCommandAndAncestors().reverse().filter((cmd) => cmd._lifeCycleHooks[event] !== undefined).forEach((hookedCommand) => {
-        hookedCommand._lifeCycleHooks[event].forEach((callback) => {
-          hooks.push({ hookedCommand, callback });
-        });
-      });
-      if (event === "postAction") {
-        hooks.reverse();
-      }
-      hooks.forEach((hookDetail) => {
-        result = this._chainOrCall(result, () => {
-          return hookDetail.callback(hookDetail.hookedCommand, this);
-        });
-      });
-      return result;
-    }
-    _chainOrCallSubCommandHook(promise, subCommand, event) {
-      let result = promise;
-      if (this._lifeCycleHooks[event] !== undefined) {
-        this._lifeCycleHooks[event].forEach((hook) => {
-          result = this._chainOrCall(result, () => {
-            return hook(this, subCommand);
-          });
-        });
-      }
-      return result;
-    }
-    _parseCommand(operands, unknown) {
-      const parsed = this.parseOptions(unknown);
-      this._parseOptionsEnv();
-      this._parseOptionsImplied();
-      operands = operands.concat(parsed.operands);
-      unknown = parsed.unknown;
-      this.args = operands.concat(unknown);
-      if (operands && this._findCommand(operands[0])) {
-        return this._dispatchSubcommand(operands[0], operands.slice(1), unknown);
-      }
-      if (this._getHelpCommand() && operands[0] === this._getHelpCommand().name()) {
-        return this._dispatchHelpCommand(operands[1]);
-      }
-      if (this._defaultCommandName) {
-        this._outputHelpIfRequested(unknown);
-        return this._dispatchSubcommand(this._defaultCommandName, operands, unknown);
-      }
-      if (this.commands.length && this.args.length === 0 && !this._actionHandler && !this._defaultCommandName) {
-        this.help({ error: true });
-      }
-      this._outputHelpIfRequested(parsed.unknown);
-      this._checkForMissingMandatoryOptions();
-      this._checkForConflictingOptions();
-      const checkForUnknownOptions = () => {
-        if (parsed.unknown.length > 0) {
-          this.unknownOption(parsed.unknown[0]);
-        }
-      };
-      const commandEvent = `command:${this.name()}`;
-      if (this._actionHandler) {
-        checkForUnknownOptions();
-        this._processArguments();
-        let promiseChain;
-        promiseChain = this._chainOrCallHooks(promiseChain, "preAction");
-        promiseChain = this._chainOrCall(promiseChain, () => this._actionHandler(this.processedArgs));
-        if (this.parent) {
-          promiseChain = this._chainOrCall(promiseChain, () => {
-            this.parent.emit(commandEvent, operands, unknown);
-          });
-        }
-        promiseChain = this._chainOrCallHooks(promiseChain, "postAction");
-        return promiseChain;
-      }
-      if (this.parent && this.parent.listenerCount(commandEvent)) {
-        checkForUnknownOptions();
-        this._processArguments();
-        this.parent.emit(commandEvent, operands, unknown);
-      } else if (operands.length) {
-        if (this._findCommand("*")) {
-          return this._dispatchSubcommand("*", operands, unknown);
-        }
-        if (this.listenerCount("command:*")) {
-          this.emit("command:*", operands, unknown);
-        } else if (this.commands.length) {
-          this.unknownCommand();
-        } else {
-          checkForUnknownOptions();
-          this._processArguments();
-        }
-      } else if (this.commands.length) {
-        checkForUnknownOptions();
-        this.help({ error: true });
-      } else {
-        checkForUnknownOptions();
-        this._processArguments();
-      }
-    }
-    _findCommand(name) {
-      if (!name)
-        return;
-      return this.commands.find((cmd) => cmd._name === name || cmd._aliases.includes(name));
-    }
-    _findOption(arg) {
-      return this.options.find((option) => option.is(arg));
-    }
-    _checkForMissingMandatoryOptions() {
-      this._getCommandAndAncestors().forEach((cmd) => {
-        cmd.options.forEach((anOption) => {
-          if (anOption.mandatory && cmd.getOptionValue(anOption.attributeName()) === undefined) {
-            cmd.missingMandatoryOptionValue(anOption);
-          }
-        });
-      });
-    }
-    _checkForConflictingLocalOptions() {
-      const definedNonDefaultOptions = this.options.filter((option) => {
-        const optionKey = option.attributeName();
-        if (this.getOptionValue(optionKey) === undefined) {
-          return false;
-        }
-        return this.getOptionValueSource(optionKey) !== "default";
-      });
-      const optionsWithConflicting = definedNonDefaultOptions.filter((option) => option.conflictsWith.length > 0);
-      optionsWithConflicting.forEach((option) => {
-        const conflictingAndDefined = definedNonDefaultOptions.find((defined) => option.conflictsWith.includes(defined.attributeName()));
-        if (conflictingAndDefined) {
-          this._conflictingOption(option, conflictingAndDefined);
-        }
-      });
-    }
-    _checkForConflictingOptions() {
-      this._getCommandAndAncestors().forEach((cmd) => {
-        cmd._checkForConflictingLocalOptions();
-      });
-    }
-    parseOptions(argv) {
-      const operands = [];
-      const unknown = [];
-      let dest = operands;
-      const args = argv.slice();
-      function maybeOption(arg) {
-        return arg.length > 1 && arg[0] === "-";
-      }
-      let activeVariadicOption = null;
-      while (args.length) {
-        const arg = args.shift();
-        if (arg === "--") {
-          if (dest === unknown)
-            dest.push(arg);
-          dest.push(...args);
-          break;
-        }
-        if (activeVariadicOption && !maybeOption(arg)) {
-          this.emit(`option:${activeVariadicOption.name()}`, arg);
-          continue;
-        }
-        activeVariadicOption = null;
-        if (maybeOption(arg)) {
-          const option = this._findOption(arg);
-          if (option) {
-            if (option.required) {
-              const value = args.shift();
-              if (value === undefined)
-                this.optionMissingArgument(option);
-              this.emit(`option:${option.name()}`, value);
-            } else if (option.optional) {
-              let value = null;
-              if (args.length > 0 && !maybeOption(args[0])) {
-                value = args.shift();
-              }
-              this.emit(`option:${option.name()}`, value);
-            } else {
-              this.emit(`option:${option.name()}`);
-            }
-            activeVariadicOption = option.variadic ? option : null;
-            continue;
-          }
-        }
-        if (arg.length > 2 && arg[0] === "-" && arg[1] !== "-") {
-          const option = this._findOption(`-${arg[1]}`);
-          if (option) {
-            if (option.required || option.optional && this._combineFlagAndOptionalValue) {
-              this.emit(`option:${option.name()}`, arg.slice(2));
-            } else {
-              this.emit(`option:${option.name()}`);
-              args.unshift(`-${arg.slice(2)}`);
-            }
-            continue;
-          }
-        }
-        if (/^--[^=]+=/.test(arg)) {
-          const index = arg.indexOf("=");
-          const option = this._findOption(arg.slice(0, index));
-          if (option && (option.required || option.optional)) {
-            this.emit(`option:${option.name()}`, arg.slice(index + 1));
-            continue;
-          }
-        }
-        if (maybeOption(arg)) {
-          dest = unknown;
-        }
-        if ((this._enablePositionalOptions || this._passThroughOptions) && operands.length === 0 && unknown.length === 0) {
-          if (this._findCommand(arg)) {
-            operands.push(arg);
-            if (args.length > 0)
-              unknown.push(...args);
-            break;
-          } else if (this._getHelpCommand() && arg === this._getHelpCommand().name()) {
-            operands.push(arg);
-            if (args.length > 0)
-              operands.push(...args);
-            break;
-          } else if (this._defaultCommandName) {
-            unknown.push(arg);
-            if (args.length > 0)
-              unknown.push(...args);
-            break;
-          }
-        }
-        if (this._passThroughOptions) {
-          dest.push(arg);
-          if (args.length > 0)
-            dest.push(...args);
-          break;
-        }
-        dest.push(arg);
-      }
-      return { operands, unknown };
-    }
-    opts() {
-      if (this._storeOptionsAsProperties) {
-        const result = {};
-        const len = this.options.length;
-        for (let i = 0;i < len; i++) {
-          const key = this.options[i].attributeName();
-          result[key] = key === this._versionOptionName ? this._version : this[key];
-        }
-        return result;
-      }
-      return this._optionValues;
-    }
-    optsWithGlobals() {
-      return this._getCommandAndAncestors().reduce((combinedOptions, cmd) => Object.assign(combinedOptions, cmd.opts()), {});
-    }
-    error(message, errorOptions) {
-      this._outputConfiguration.outputError(`${message}
-`, this._outputConfiguration.writeErr);
-      if (typeof this._showHelpAfterError === "string") {
-        this._outputConfiguration.writeErr(`${this._showHelpAfterError}
-`);
-      } else if (this._showHelpAfterError) {
-        this._outputConfiguration.writeErr(`
-`);
-        this.outputHelp({ error: true });
-      }
-      const config = errorOptions || {};
-      const exitCode = config.exitCode || 1;
-      const code = config.code || "commander.error";
-      this._exit(exitCode, code, message);
-    }
-    _parseOptionsEnv() {
-      this.options.forEach((option) => {
-        if (option.envVar && option.envVar in process2.env) {
-          const optionKey = option.attributeName();
-          if (this.getOptionValue(optionKey) === undefined || ["default", "config", "env"].includes(this.getOptionValueSource(optionKey))) {
-            if (option.required || option.optional) {
-              this.emit(`optionEnv:${option.name()}`, process2.env[option.envVar]);
-            } else {
-              this.emit(`optionEnv:${option.name()}`);
-            }
-          }
-        }
-      });
-    }
-    _parseOptionsImplied() {
-      const dualHelper = new DualOptions(this.options);
-      const hasCustomOptionValue = (optionKey) => {
-        return this.getOptionValue(optionKey) !== undefined && !["default", "implied"].includes(this.getOptionValueSource(optionKey));
-      };
-      this.options.filter((option) => option.implied !== undefined && hasCustomOptionValue(option.attributeName()) && dualHelper.valueFromOption(this.getOptionValue(option.attributeName()), option)).forEach((option) => {
-        Object.keys(option.implied).filter((impliedKey) => !hasCustomOptionValue(impliedKey)).forEach((impliedKey) => {
-          this.setOptionValueWithSource(impliedKey, option.implied[impliedKey], "implied");
-        });
-      });
-    }
-    missingArgument(name) {
-      const message = `error: missing required argument '${name}'`;
-      this.error(message, { code: "commander.missingArgument" });
-    }
-    optionMissingArgument(option) {
-      const message = `error: option '${option.flags}' argument missing`;
-      this.error(message, { code: "commander.optionMissingArgument" });
-    }
-    missingMandatoryOptionValue(option) {
-      const message = `error: required option '${option.flags}' not specified`;
-      this.error(message, { code: "commander.missingMandatoryOptionValue" });
-    }
-    _conflictingOption(option, conflictingOption) {
-      const findBestOptionFromValue = (option2) => {
-        const optionKey = option2.attributeName();
-        const optionValue = this.getOptionValue(optionKey);
-        const negativeOption = this.options.find((target) => target.negate && optionKey === target.attributeName());
-        const positiveOption = this.options.find((target) => !target.negate && optionKey === target.attributeName());
-        if (negativeOption && (negativeOption.presetArg === undefined && optionValue === false || negativeOption.presetArg !== undefined && optionValue === negativeOption.presetArg)) {
-          return negativeOption;
-        }
-        return positiveOption || option2;
-      };
-      const getErrorMessage = (option2) => {
-        const bestOption = findBestOptionFromValue(option2);
-        const optionKey = bestOption.attributeName();
-        const source = this.getOptionValueSource(optionKey);
-        if (source === "env") {
-          return `environment variable '${bestOption.envVar}'`;
-        }
-        return `option '${bestOption.flags}'`;
-      };
-      const message = `error: ${getErrorMessage(option)} cannot be used with ${getErrorMessage(conflictingOption)}`;
-      this.error(message, { code: "commander.conflictingOption" });
-    }
-    unknownOption(flag) {
-      if (this._allowUnknownOption)
-        return;
-      let suggestion = "";
-      if (flag.startsWith("--") && this._showSuggestionAfterError) {
-        let candidateFlags = [];
-        let command = this;
-        do {
-          const moreFlags = command.createHelp().visibleOptions(command).filter((option) => option.long).map((option) => option.long);
-          candidateFlags = candidateFlags.concat(moreFlags);
-          command = command.parent;
-        } while (command && !command._enablePositionalOptions);
-        suggestion = suggestSimilar(flag, candidateFlags);
-      }
-      const message = `error: unknown option '${flag}'${suggestion}`;
-      this.error(message, { code: "commander.unknownOption" });
-    }
-    _excessArguments(receivedArgs) {
-      if (this._allowExcessArguments)
-        return;
-      const expected = this.registeredArguments.length;
-      const s = expected === 1 ? "" : "s";
-      const forSubcommand = this.parent ? ` for '${this.name()}'` : "";
-      const message = `error: too many arguments${forSubcommand}. Expected ${expected} argument${s} but got ${receivedArgs.length}.`;
-      this.error(message, { code: "commander.excessArguments" });
-    }
-    unknownCommand() {
-      const unknownName = this.args[0];
-      let suggestion = "";
-      if (this._showSuggestionAfterError) {
-        const candidateNames = [];
-        this.createHelp().visibleCommands(this).forEach((command) => {
-          candidateNames.push(command.name());
-          if (command.alias())
-            candidateNames.push(command.alias());
-        });
-        suggestion = suggestSimilar(unknownName, candidateNames);
-      }
-      const message = `error: unknown command '${unknownName}'${suggestion}`;
-      this.error(message, { code: "commander.unknownCommand" });
-    }
-    version(str, flags, description) {
-      if (str === undefined)
-        return this._version;
-      this._version = str;
-      flags = flags || "-V, --version";
-      description = description || "output the version number";
-      const versionOption = this.createOption(flags, description);
-      this._versionOptionName = versionOption.attributeName();
-      this._registerOption(versionOption);
-      this.on("option:" + versionOption.name(), () => {
-        this._outputConfiguration.writeOut(`${str}
-`);
-        this._exit(0, "commander.version", str);
-      });
-      return this;
-    }
-    description(str, argsDescription) {
-      if (str === undefined && argsDescription === undefined)
-        return this._description;
-      this._description = str;
-      if (argsDescription) {
-        this._argsDescription = argsDescription;
-      }
-      return this;
-    }
-    summary(str) {
-      if (str === undefined)
-        return this._summary;
-      this._summary = str;
-      return this;
-    }
-    alias(alias) {
-      if (alias === undefined)
-        return this._aliases[0];
-      let command = this;
-      if (this.commands.length !== 0 && this.commands[this.commands.length - 1]._executableHandler) {
-        command = this.commands[this.commands.length - 1];
-      }
-      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;
-    }
-    aliases(aliases) {
-      if (aliases === undefined)
-        return this._aliases;
-      aliases.forEach((alias) => this.alias(alias));
-      return this;
-    }
-    usage(str) {
-      if (str === undefined) {
-        if (this._usage)
-          return this._usage;
-        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(" ");
-      }
-      this._usage = str;
-      return this;
-    }
-    name(str) {
-      if (str === undefined)
-        return this._name;
-      this._name = str;
-      return this;
-    }
-    nameFromFilename(filename) {
-      this._name = path.basename(filename, path.extname(filename));
-      return this;
-    }
-    executableDir(path2) {
-      if (path2 === undefined)
-        return this._executableDir;
-      this._executableDir = path2;
-      return this;
-    }
-    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);
-    }
-    _getOutputContext(contextOptions) {
-      contextOptions = contextOptions || {};
-      const error = !!contextOptions.error;
-      let baseWrite;
-      let hasColors;
-      let helpWidth;
-      if (error) {
-        baseWrite = (str) => this._outputConfiguration.writeErr(str);
-        hasColors = this._outputConfiguration.getErrHasColors();
-        helpWidth = this._outputConfiguration.getErrHelpWidth();
-      } else {
-        baseWrite = (str) => this._outputConfiguration.writeOut(str);
-        hasColors = this._outputConfiguration.getOutHasColors();
-        helpWidth = this._outputConfiguration.getOutHelpWidth();
-      }
-      const write = (str) => {
-        if (!hasColors)
-          str = this._outputConfiguration.stripColor(str);
-        return baseWrite(str);
-      };
-      return { error, write, hasColors, helpWidth };
-    }
-    outputHelp(contextOptions) {
-      let deprecatedCallback;
-      if (typeof contextOptions === "function") {
-        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 });
-      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);
-      }
-      this.emit("afterHelp", eventContext);
-      this._getCommandAndAncestors().forEach((command) => command.emit("afterAllHelp", eventContext));
-    }
-    helpOption(flags, description) {
-      if (typeof flags === "boolean") {
-        if (flags) {
-          this._helpOption = this._helpOption ?? undefined;
-        } else {
-          this._helpOption = null;
-        }
-        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;
-      return this;
-    }
-    help(contextOptions) {
-      this.outputHelp(contextOptions);
-      let exitCode = Number(process2.exitCode ?? 0);
-      if (exitCode === 0 && contextOptions && typeof contextOptions !== "function" && contextOptions.error) {
-        exitCode = 1;
-      }
-      this._exit(exitCode, "commander.help", "(outputHelp)");
-    }
-    addHelpText(position, text) {
-      const allowedValues = ["beforeAll", "before", "after", "afterAll"];
-      if (!allowedValues.includes(position)) {
-        throw new Error(`Unexpected value for position to addHelpText.
-Expecting one of '${allowedValues.join("', '")}'`);
-      }
-      const helpEvent = `${position}Help`;
-      this.on(helpEvent, (context) => {
-        let helpStr;
-        if (typeof text === "function") {
-          helpStr = text({ error: context.error, command: context.command });
-        } else {
-          helpStr = text;
-        }
-        if (helpStr) {
-          context.write(`${helpStr}
-`);
-        }
-      });
-      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 incrementNodeInspectorPort(args) {
-    return args.map((arg) => {
-      if (!arg.startsWith("--inspect")) {
-        return arg;
-      }
-      let debugOption;
-      let debugHost = "127.0.0.1";
-      let debugPort = "9229";
-      let match;
-      if ((match = arg.match(/^(--inspect(-brk)?)$/)) !== null) {
-        debugOption = match[1];
-      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+)$/)) !== null) {
-        debugOption = match[1];
-        if (/^\d+$/.test(match[3])) {
-          debugPort = match[3];
-        } else {
-          debugHost = match[3];
-        }
-      } else if ((match = arg.match(/^(--inspect(-brk|-port)?)=([^:]+):(\d+)$/)) !== null) {
-        debugOption = match[1];
-        debugHost = match[3];
-        debugPort = match[4];
-      }
-      if (debugOption && debugPort !== "0") {
-        return `${debugOption}=${debugHost}:${parseInt(debugPort) + 1}`;
-      }
-      return arg;
-    });
-  }
-  function useColor() {
-    if (process2.env.NO_COLOR || process2.env.FORCE_COLOR === "0" || process2.env.FORCE_COLOR === "false")
-      return false;
-    if (process2.env.FORCE_COLOR || process2.env.CLICOLOR_FORCE !== undefined)
-      return true;
-    return;
-  }
-  exports.Command = Command;
-  exports.useColor = useColor;
-});
-
-// node_modules/commander/index.js
-var require_commander = __commonJS((exports) => {
-  var { Argument } = require_argument();
-  var { Command } = require_command();
-  var { CommanderError, InvalidArgumentError } = require_error();
-  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.Command = Command;
-  exports.Option = Option;
-  exports.Argument = Argument;
-  exports.Help = Help;
-  exports.CommanderError = CommanderError;
-  exports.InvalidArgumentError = InvalidArgumentError;
-  exports.InvalidOptionArgumentError = InvalidArgumentError;
-});
-
-// node_modules/commander/esm.mjs
-var import__ = __toESM(require_commander(), 1);
-var {
-  program,
-  createCommand,
-  createArgument,
-  createOption,
-  CommanderError,
-  InvalidArgumentError,
-  InvalidOptionArgumentError,
-  Command,
-  Argument,
-  Option,
-  Help
-} = import__.default;
-
-// node_modules/chalk/source/vendor/ansi-styles/index.js
-var ANSI_BACKGROUND_OFFSET = 10;
-var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
-var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
-var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
-var styles = {
-  modifier: {
-    reset: [0, 0],
-    bold: [1, 22],
-    dim: [2, 22],
-    italic: [3, 23],
-    underline: [4, 24],
-    overline: [53, 55],
-    inverse: [7, 27],
-    hidden: [8, 28],
-    strikethrough: [9, 29]
-  },
-  color: {
-    black: [30, 39],
-    red: [31, 39],
-    green: [32, 39],
-    yellow: [33, 39],
-    blue: [34, 39],
-    magenta: [35, 39],
-    cyan: [36, 39],
-    white: [37, 39],
-    blackBright: [90, 39],
-    gray: [90, 39],
-    grey: [90, 39],
-    redBright: [91, 39],
-    greenBright: [92, 39],
-    yellowBright: [93, 39],
-    blueBright: [94, 39],
-    magentaBright: [95, 39],
-    cyanBright: [96, 39],
-    whiteBright: [97, 39]
-  },
-  bgColor: {
-    bgBlack: [40, 49],
-    bgRed: [41, 49],
-    bgGreen: [42, 49],
-    bgYellow: [43, 49],
-    bgBlue: [44, 49],
-    bgMagenta: [45, 49],
-    bgCyan: [46, 49],
-    bgWhite: [47, 49],
-    bgBlackBright: [100, 49],
-    bgGray: [100, 49],
-    bgGrey: [100, 49],
-    bgRedBright: [101, 49],
-    bgGreenBright: [102, 49],
-    bgYellowBright: [103, 49],
-    bgBlueBright: [104, 49],
-    bgMagentaBright: [105, 49],
-    bgCyanBright: [106, 49],
-    bgWhiteBright: [107, 49]
-  }
-};
-var modifierNames = Object.keys(styles.modifier);
-var foregroundColorNames = Object.keys(styles.color);
-var backgroundColorNames = Object.keys(styles.bgColor);
-var colorNames = [...foregroundColorNames, ...backgroundColorNames];
-function assembleStyles() {
-  const codes = new Map;
-  for (const [groupName, group] of Object.entries(styles)) {
-    for (const [styleName, style] of Object.entries(group)) {
-      styles[styleName] = {
-        open: `\x1B[${style[0]}m`,
-        close: `\x1B[${style[1]}m`
-      };
-      group[styleName] = styles[styleName];
-      codes.set(style[0], style[1]);
-    }
-    Object.defineProperty(styles, groupName, {
-      value: group,
-      enumerable: false
-    });
-  }
-  Object.defineProperty(styles, "codes", {
-    value: codes,
-    enumerable: false
-  });
-  styles.color.close = "\x1B[39m";
-  styles.bgColor.close = "\x1B[49m";
-  styles.color.ansi = wrapAnsi16();
-  styles.color.ansi256 = wrapAnsi256();
-  styles.color.ansi16m = wrapAnsi16m();
-  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
-  Object.defineProperties(styles, {
-    rgbToAnsi256: {
-      value(red, green, blue) {
-        if (red === green && green === blue) {
-          if (red < 8) {
-            return 16;
-          }
-          if (red > 248) {
-            return 231;
-          }
-          return Math.round((red - 8) / 247 * 24) + 232;
-        }
-        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
-      },
-      enumerable: false
-    },
-    hexToRgb: {
-      value(hex) {
-        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
-        if (!matches) {
-          return [0, 0, 0];
-        }
-        let [colorString] = matches;
-        if (colorString.length === 3) {
-          colorString = [...colorString].map((character) => character + character).join("");
-        }
-        const integer = Number.parseInt(colorString, 16);
-        return [
-          integer >> 16 & 255,
-          integer >> 8 & 255,
-          integer & 255
-        ];
-      },
-      enumerable: false
-    },
-    hexToAnsi256: {
-      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
-      enumerable: false
-    },
-    ansi256ToAnsi: {
-      value(code) {
-        if (code < 8) {
-          return 30 + code;
-        }
-        if (code < 16) {
-          return 90 + (code - 8);
-        }
-        let red;
-        let green;
-        let blue;
-        if (code >= 232) {
-          red = ((code - 232) * 10 + 8) / 255;
-          green = red;
-          blue = red;
-        } else {
-          code -= 16;
-          const remainder = code % 36;
-          red = Math.floor(code / 36) / 5;
-          green = Math.floor(remainder / 6) / 5;
-          blue = remainder % 6 / 5;
-        }
-        const value = Math.max(red, green, blue) * 2;
-        if (value === 0) {
-          return 30;
-        }
-        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
-        if (value === 2) {
-          result += 60;
-        }
-        return result;
-      },
-      enumerable: false
-    },
-    rgbToAnsi: {
-      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
-      enumerable: false
-    },
-    hexToAnsi: {
-      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
-      enumerable: false
-    }
-  });
-  return styles;
-}
-var ansiStyles = assembleStyles();
-var ansi_styles_default = ansiStyles;
-
-// node_modules/chalk/source/vendor/supports-color/index.js
-import process2 from "process";
-import os from "os";
-import tty from "tty";
-function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
-  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
-  const position = argv.indexOf(prefix + flag);
-  const terminatorPosition = argv.indexOf("--");
-  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
-}
-var { env } = process2;
-var flagForceColor;
-if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-  flagForceColor = 0;
-} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-  flagForceColor = 1;
-}
-function envForceColor() {
-  if ("FORCE_COLOR" in env) {
-    if (env.FORCE_COLOR === "true") {
-      return 1;
-    }
-    if (env.FORCE_COLOR === "false") {
-      return 0;
-    }
-    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
-  }
-}
-function translateLevel(level) {
-  if (level === 0) {
-    return false;
-  }
-  return {
-    level,
-    hasBasic: true,
-    has256: level >= 2,
-    has16m: level >= 3
-  };
-}
-function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
-  const noFlagForceColor = envForceColor();
-  if (noFlagForceColor !== undefined) {
-    flagForceColor = noFlagForceColor;
-  }
-  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
-  if (forceColor === 0) {
-    return 0;
-  }
-  if (sniffFlags) {
-    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-      return 3;
-    }
-    if (hasFlag("color=256")) {
-      return 2;
-    }
-  }
-  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
-    return 1;
-  }
-  if (haveStream && !streamIsTTY && forceColor === undefined) {
-    return 0;
-  }
-  const min = forceColor || 0;
-  if (env.TERM === "dumb") {
-    return min;
-  }
-  if (process2.platform === "win32") {
-    const osRelease = os.release().split(".");
-    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
-      return Number(osRelease[2]) >= 14931 ? 3 : 2;
-    }
-    return 1;
-  }
-  if ("CI" in env) {
-    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env))) {
-      return 3;
-    }
-    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
-      return 1;
-    }
-    return min;
-  }
-  if ("TEAMCITY_VERSION" in env) {
-    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
-  }
-  if (env.COLORTERM === "truecolor") {
-    return 3;
-  }
-  if (env.TERM === "xterm-kitty") {
-    return 3;
-  }
-  if (env.TERM === "xterm-ghostty") {
-    return 3;
-  }
-  if (env.TERM === "wezterm") {
-    return 3;
-  }
-  if ("TERM_PROGRAM" in env) {
-    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-    switch (env.TERM_PROGRAM) {
-      case "iTerm.app": {
-        return version >= 3 ? 3 : 2;
-      }
-      case "Apple_Terminal": {
-        return 2;
-      }
-    }
-  }
-  if (/-256(color)?$/i.test(env.TERM)) {
-    return 2;
-  }
-  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
-    return 1;
-  }
-  if ("COLORTERM" in env) {
-    return 1;
-  }
-  return min;
-}
-function createSupportsColor(stream, options = {}) {
-  const level = _supportsColor(stream, {
-    streamIsTTY: stream && stream.isTTY,
-    ...options
-  });
-  return translateLevel(level);
-}
-var supportsColor = {
-  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
-  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
-};
-var supports_color_default = supportsColor;
-
-// node_modules/chalk/source/utilities.js
-function stringReplaceAll(string, substring, replacer) {
-  let index = string.indexOf(substring);
-  if (index === -1) {
-    return string;
-  }
-  const substringLength = substring.length;
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    returnValue += string.slice(endIndex, index) + substring + replacer;
-    endIndex = index + substringLength;
-    index = string.indexOf(substring, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
-}
-function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    const gotCR = string[index - 1] === "\r";
-    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? `\r
-` : `
-`) + postfix;
-    endIndex = index + 1;
-    index = string.indexOf(`
-`, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
-}
-
-// node_modules/chalk/source/index.js
-var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
-var GENERATOR = Symbol("GENERATOR");
-var STYLER = Symbol("STYLER");
-var IS_EMPTY = Symbol("IS_EMPTY");
-var levelMapping = [
-  "ansi",
-  "ansi",
-  "ansi256",
-  "ansi16m"
-];
-var styles2 = Object.create(null);
-var applyOptions = (object, options = {}) => {
-  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
-    throw new Error("The `level` option should be an integer from 0 to 3");
-  }
-  const colorLevel = stdoutColor ? stdoutColor.level : 0;
-  object.level = options.level === undefined ? colorLevel : options.level;
-};
-var chalkFactory = (options) => {
-  const chalk = (...strings) => strings.join(" ");
-  applyOptions(chalk, options);
-  Object.setPrototypeOf(chalk, createChalk.prototype);
-  return chalk;
-};
-function createChalk(options) {
-  return chalkFactory(options);
-}
-Object.setPrototypeOf(createChalk.prototype, Function.prototype);
-for (const [styleName, style] of Object.entries(ansi_styles_default)) {
-  styles2[styleName] = {
-    get() {
-      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
-      Object.defineProperty(this, styleName, { value: builder });
-      return builder;
-    }
-  };
-}
-styles2.visible = {
-  get() {
-    const builder = createBuilder(this, this[STYLER], true);
-    Object.defineProperty(this, "visible", { value: builder });
-    return builder;
-  }
-};
-var getModelAnsi = (model, level, type, ...arguments_) => {
-  if (model === "rgb") {
-    if (level === "ansi16m") {
-      return ansi_styles_default[type].ansi16m(...arguments_);
-    }
-    if (level === "ansi256") {
-      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
-    }
-    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
-  }
-  if (model === "hex") {
-    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
-  }
-  return ansi_styles_default[type][model](...arguments_);
-};
-var usedModels = ["rgb", "hex", "ansi256"];
-for (const model of usedModels) {
-  styles2[model] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
-  };
-  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
-  styles2[bgModel] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
-  };
-}
-var proto = Object.defineProperties(() => {}, {
-  ...styles2,
-  level: {
-    enumerable: true,
-    get() {
-      return this[GENERATOR].level;
-    },
-    set(level) {
-      this[GENERATOR].level = level;
-    }
-  }
-});
-var createStyler = (open, close, parent) => {
-  let openAll;
-  let closeAll;
-  if (parent === undefined) {
-    openAll = open;
-    closeAll = close;
-  } else {
-    openAll = parent.openAll + open;
-    closeAll = close + parent.closeAll;
-  }
-  return {
-    open,
-    close,
-    openAll,
-    closeAll,
-    parent
-  };
-};
-var createBuilder = (self, _styler, _isEmpty) => {
-  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
-  Object.setPrototypeOf(builder, proto);
-  builder[GENERATOR] = self;
-  builder[STYLER] = _styler;
-  builder[IS_EMPTY] = _isEmpty;
-  return builder;
-};
-var applyStyle = (self, string) => {
-  if (self.level <= 0 || !string) {
-    return self[IS_EMPTY] ? "" : string;
-  }
-  let styler = self[STYLER];
-  if (styler === undefined) {
-    return string;
-  }
-  const { openAll, closeAll } = styler;
-  if (string.includes("\x1B")) {
-    while (styler !== undefined) {
-      string = stringReplaceAll(string, styler.close, styler.open);
-      styler = styler.parent;
-    }
-  }
-  const lfIndex = string.indexOf(`
-`);
-  if (lfIndex !== -1) {
-    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
-  }
-  return openAll + string + closeAll;
-};
-Object.defineProperties(createChalk.prototype, styles2);
-var chalk = createChalk();
-var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
-var source_default = chalk;
-
-// src/cli/index.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3 } from "fs";
-import { dirname as dirname3, join as join5 } from "path";
-import { fileURLToPath } from "url";
-import { spawnSync as spawnSync3 } from "child_process";
-
-// src/store.ts
-import { createHash } from "crypto";
-
-// src/database.ts
-import { Database } from "bun:sqlite";
-import { mkdirSync as mkdirSync2 } from "fs";
-import { dirname as dirname2 } from "path";
-
-// src/config.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import { dirname, join, resolve } from "path";
-var SERVICE_NAME = "shortlinks";
-var DEFAULT_DATA_DIR = join(homedir(), ".hasna", SERVICE_NAME);
-function getDataDir() {
-  return resolve(process.env.SHORTLINKS_HOME || DEFAULT_DATA_DIR);
-}
-function ensureDataDir() {
-  const dir = getDataDir();
-  mkdirSync(dir, { recursive: true });
-  return dir;
-}
-function getConfigPath() {
-  return join(ensureDataDir(), "config.json");
-}
-function getDatabasePath(explicitPath) {
-  if (explicitPath)
-    return resolve(explicitPath);
-  if (process.env.SHORTLINKS_DB)
-    return resolve(process.env.SHORTLINKS_DB);
-  return join(ensureDataDir(), `${SERVICE_NAME}.db`);
-}
-function loadConfig() {
-  const path = getConfigPath();
-  if (!existsSync(path))
-    return {};
-  try {
-    const parsed = JSON.parse(readFileSync(path, "utf-8"));
-    return parsed && typeof parsed === "object" ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-function saveConfig(config) {
-  const path = getConfigPath();
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(config, null, 2)}
-`);
-}
-function updateConfig(patch) {
-  const next = {
-    ...loadConfig(),
-    ...patch,
-    cloudflare: {
-      ...loadConfig().cloudflare,
-      ...patch.cloudflare
-    }
-  };
-  saveConfig(next);
-  return next;
-}
-function normalizeHostname(input) {
-  const raw = input.trim().toLowerCase();
-  if (!raw)
-    throw new Error("Domain is required.");
-  const withProtocol = raw.includes("://") ? raw : `https://${raw}`;
-  let hostname;
-  try {
-    hostname = new URL(withProtocol).hostname;
-  } catch {
-    throw new Error(`Invalid domain: ${input}`);
-  }
-  hostname = hostname.replace(/\.$/, "");
-  if (!/^[a-z0-9.-]+$/.test(hostname) || hostname.includes("..")) {
-    throw new Error(`Invalid domain: ${input}`);
-  }
-  return hostname;
-}
-function formatShortUrl(hostname, slug, publicBaseUrl) {
-  if (publicBaseUrl) {
-    const base = publicBaseUrl.endsWith("/") ? publicBaseUrl : `${publicBaseUrl}/`;
-    return new URL(slug, base).toString();
-  }
-  return `https://${hostname}/${slug}`;
-}
-
-// src/database.ts
-function now() {
-  return new Date().toISOString();
-}
-function makeId(prefix) {
-  const bytes = crypto.getRandomValues(new Uint8Array(12));
-  const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0")).join("");
-  return `${prefix}_${hex}`;
-}
-var SQLITE_MIGRATIONS = [
-  `
-  CREATE TABLE IF NOT EXISTS domains (
-    id TEXT PRIMARY KEY,
-    hostname TEXT NOT NULL UNIQUE,
-    provider TEXT NOT NULL DEFAULT 'manual',
-    default_domain INTEGER NOT NULL DEFAULT 0,
-    cloudflare_zone_id TEXT,
-    cloudflare_account_id TEXT,
-    cloudflare_worker_name TEXT,
-    origin_url TEXT,
-    notes TEXT,
-    metadata TEXT NOT NULL DEFAULT '{}',
-    machine_id TEXT,
-    synced_at TEXT,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL
-  );
-
-  CREATE TABLE IF NOT EXISTS links (
-    id TEXT PRIMARY KEY,
-    domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-    slug TEXT NOT NULL,
-    destination_url TEXT NOT NULL,
-    title TEXT,
-    active INTEGER NOT NULL DEFAULT 1,
-    expires_at TEXT,
-    metadata TEXT NOT NULL DEFAULT '{}',
-    machine_id TEXT,
-    synced_at TEXT,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL,
-    UNIQUE(domain_id, slug)
-  );
-
-  CREATE TABLE IF NOT EXISTS clicks (
-    id TEXT PRIMARY KEY,
-    link_id TEXT NOT NULL REFERENCES links(id) ON DELETE CASCADE,
-    domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-    slug TEXT NOT NULL,
-    clicked_at TEXT NOT NULL,
-    ip_hash TEXT,
-    user_agent TEXT,
-    referer TEXT,
-    country TEXT,
-    city TEXT,
-    metadata TEXT NOT NULL DEFAULT '{}',
-    machine_id TEXT,
-    synced_at TEXT,
-    created_at TEXT NOT NULL,
-    updated_at TEXT NOT NULL
-  );
-
-  CREATE INDEX IF NOT EXISTS idx_domains_hostname ON domains(hostname);
-  CREATE INDEX IF NOT EXISTS idx_domains_default ON domains(default_domain);
-  CREATE INDEX IF NOT EXISTS idx_links_domain_slug ON links(domain_id, slug);
-  CREATE INDEX IF NOT EXISTS idx_links_active ON links(active);
-  CREATE INDEX IF NOT EXISTS idx_links_updated ON links(updated_at);
-  CREATE INDEX IF NOT EXISTS idx_clicks_link ON clicks(link_id);
-  CREATE INDEX IF NOT EXISTS idx_clicks_domain ON clicks(domain_id);
-  CREATE INDEX IF NOT EXISTS idx_clicks_clicked_at ON clicks(clicked_at);
-  CREATE INDEX IF NOT EXISTS idx_clicks_updated ON clicks(updated_at);
-  `
-];
-
-class ShortlinksDatabase {
-  db;
-  path;
-  constructor(path) {
-    this.path = getDatabasePath(path);
-    mkdirSync2(dirname2(this.path), { recursive: true });
-    this.db = new Database(this.path);
-    this.db.exec("PRAGMA foreign_keys = ON;");
-    this.applyMigrations();
-  }
-  close() {
-    this.db.close();
-  }
-  applyMigrations() {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS _migrations (
-        id INTEGER PRIMARY KEY,
-        applied_at TEXT NOT NULL
-      );
-    `);
-    for (let i = 0;i < SQLITE_MIGRATIONS.length; i += 1) {
-      const id = i + 1;
-      const applied = this.db.query("SELECT id FROM _migrations WHERE id = ?").get(id);
-      if (applied)
-        continue;
-      const migration = SQLITE_MIGRATIONS[i];
-      const apply = this.db.transaction(() => {
-        this.db.exec(migration);
-        this.db.query("INSERT INTO _migrations (id, applied_at) VALUES (?, ?)").run(id, now());
-      });
-      apply();
-    }
-  }
-}
-
-// src/machine.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
-import { hostname } from "os";
-import { join as join2 } from "path";
-
-// src/slug.ts
-import { randomBytes } from "crypto";
-var SLUG_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-var DEFAULT_SLUG_LENGTH = 7;
-function randomToken(length = DEFAULT_SLUG_LENGTH) {
-  if (length < 1 || length > 128)
-    throw new Error("Token length must be between 1 and 128.");
-  const bytes = randomBytes(length);
-  let out = "";
-  for (let i = 0;i < length; i += 1) {
-    out += SLUG_ALPHABET[bytes[i] % SLUG_ALPHABET.length];
-  }
-  return out;
-}
-function normalizeSlug(slug) {
-  const normalized = slug.trim().replace(/^\/+/, "").replace(/\/+$/, "");
-  if (!normalized)
-    throw new Error("Slug is required.");
-  if (!/^[A-Za-z0-9_-]{1,96}$/.test(normalized)) {
-    throw new Error("Slug can only contain letters, numbers, underscores, and dashes.");
-  }
-  return normalized;
-}
-
-// src/machine.ts
-function getMachineId() {
-  const path = join2(ensureDataDir(), "machine-id");
-  if (existsSync2(path)) {
-    const existing = readFileSync2(path, "utf-8").trim();
-    if (existing)
-      return existing;
-  }
-  const safeHost = hostname().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
-  const id = `${safeHost || "machine"}-${randomToken(8).toLowerCase()}`;
-  writeFileSync2(path, `${id}
-`);
-  return id;
-}
-
-// src/store.ts
-function parseJsonObject(value) {
-  if (!value)
-    return {};
-  try {
-    const parsed = JSON.parse(value);
-    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-function domainFromRow(row) {
-  return {
-    ...row,
-    default_domain: Boolean(row.default_domain),
-    metadata: parseJsonObject(row.metadata)
-  };
-}
-function linkFromRow(row) {
-  const config = loadConfig();
-  const publicBaseUrl = config.defaultDomain === row.hostname ? config.publicBaseUrl : undefined;
-  return {
-    ...row,
-    active: Boolean(row.active),
-    metadata: parseJsonObject(row.metadata),
-    short_url: formatShortUrl(row.hostname, row.slug, publicBaseUrl)
-  };
-}
-function clickFromRow(row) {
-  return {
-    ...row,
-    metadata: parseJsonObject(row.metadata)
-  };
-}
-function validateDestinationUrl(url) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    throw new Error(`Invalid destination URL: ${url}`);
-  }
-  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-    throw new Error("Destination URL must start with http:// or https://.");
-  }
-  return parsed.toString();
-}
-function isoOrNull(input) {
-  if (!input)
-    return null;
-  const date = new Date(input);
-  if (Number.isNaN(date.getTime()))
-    throw new Error(`Invalid date: ${input}`);
-  return date.toISOString();
-}
-
-class ShortlinksStore {
-  database;
-  constructor(dbPath) {
-    this.database = new ShortlinksDatabase(dbPath);
-  }
-  close() {
-    this.database.close();
-  }
-  addDomain(input) {
-    const hostname2 = normalizeHostname(input.hostname);
-    const timestamp = now();
-    const machineId = getMachineId();
-    const existing = this.getDomain(hostname2);
-    const id = existing?.id || makeId("dom");
-    if (input.defaultDomain) {
-      this.database.db.query("UPDATE domains SET default_domain = 0, updated_at = ?, synced_at = NULL").run(timestamp);
-      updateConfig({ defaultDomain: hostname2, publicBaseUrl: `https://${hostname2}` });
-    }
-    this.database.db.query(`
-      INSERT INTO domains (
-        id, hostname, provider, default_domain, cloudflare_zone_id, cloudflare_account_id,
-        cloudflare_worker_name, origin_url, notes, metadata, machine_id, synced_at, created_at, updated_at
-      )
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)
-      ON CONFLICT(hostname) DO UPDATE SET
-        provider = excluded.provider,
-        default_domain = excluded.default_domain,
-        cloudflare_zone_id = COALESCE(excluded.cloudflare_zone_id, domains.cloudflare_zone_id),
-        cloudflare_account_id = COALESCE(excluded.cloudflare_account_id, domains.cloudflare_account_id),
-        cloudflare_worker_name = COALESCE(excluded.cloudflare_worker_name, domains.cloudflare_worker_name),
-        origin_url = COALESCE(excluded.origin_url, domains.origin_url),
-        notes = COALESCE(excluded.notes, domains.notes),
-        metadata = excluded.metadata,
-        machine_id = excluded.machine_id,
-        synced_at = NULL,
-        updated_at = excluded.updated_at
-    `).run(id, hostname2, input.provider || existing?.provider || "manual", input.defaultDomain ?? existing?.default_domain ? 1 : 0, input.cloudflareZoneId || existing?.cloudflare_zone_id || null, input.cloudflareAccountId || existing?.cloudflare_account_id || null, input.cloudflareWorkerName || existing?.cloudflare_worker_name || null, input.originUrl || existing?.origin_url || null, input.notes || existing?.notes || null, JSON.stringify(input.metadata || existing?.metadata || {}), machineId, existing?.created_at || timestamp, timestamp);
-    return this.getDomain(hostname2);
-  }
-  listDomains() {
-    const rows = this.database.db.query(`
-      SELECT * FROM domains
-      ORDER BY default_domain DESC, hostname ASC
-    `).all();
-    return rows.map(domainFromRow);
-  }
-  getDomain(hostnameOrId) {
-    const normalized = hostnameOrId.includes(".") || hostnameOrId.includes("://") ? normalizeHostname(hostnameOrId) : hostnameOrId;
-    const row = this.database.db.query(`
-      SELECT * FROM domains WHERE hostname = ? OR id = ? LIMIT 1
-    `).get(normalized, hostnameOrId);
-    return row ? domainFromRow(row) : null;
-  }
-  getDefaultDomain() {
-    const config = loadConfig();
-    if (config.defaultDomain) {
-      const configured = this.getDomain(config.defaultDomain);
-      if (configured)
-        return configured;
-    }
-    const row = this.database.db.query(`
-      SELECT * FROM domains ORDER BY default_domain DESC, created_at ASC LIMIT 1
-    `).get();
-    return row ? domainFromRow(row) : null;
-  }
-  createLink(input) {
-    const domain = input.domain ? this.getDomain(input.domain) : this.getDefaultDomain();
-    if (!domain) {
-      throw new Error("No domain configured. Run `shortlinks domain add <domain> --default` first.");
-    }
-    const destinationUrl = validateDestinationUrl(input.destinationUrl);
-    const timestamp = now();
-    const machineId = getMachineId();
-    const expiresAt = isoOrNull(input.expiresAt);
-    const slug = input.slug ? normalizeSlug(input.slug) : this.generateAvailableSlug(domain.id, input.slugLength || DEFAULT_SLUG_LENGTH);
-    try {
-      this.database.db.query(`
-        INSERT INTO links (
-          id, domain_id, slug, destination_url, title, active, expires_at, metadata,
-          machine_id, synced_at, created_at, updated_at
-        )
-        VALUES (?, ?, ?, ?, ?, 1, ?, ?, ?, NULL, ?, ?)
-      `).run(makeId("lnk"), domain.id, slug, destinationUrl, input.title || null, expiresAt, JSON.stringify(input.metadata || {}), machineId, timestamp, timestamp);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      if (message.includes("UNIQUE")) {
-        throw new Error(`Slug already exists for ${domain.hostname}: ${slug}`);
-      }
-      throw error;
-    }
-    return this.getLink(domain.hostname, slug);
-  }
-  listLinks(options = {}) {
-    const params = [];
-    let where = "WHERE 1 = 1";
-    if (options.domain) {
-      where += " AND d.hostname = ?";
-      params.push(normalizeHostname(options.domain));
-    }
-    if (options.activeOnly) {
-      where += " AND l.active = 1";
-    }
-    params.push(options.limit || 100);
-    const rows = this.database.db.query(`
-      SELECT l.*, d.hostname
-      FROM links l
-      JOIN domains d ON d.id = l.domain_id
-      ${where}
-      ORDER BY l.created_at DESC
-      LIMIT ?
-    `).all(...params);
-    return rows.map(linkFromRow);
-  }
-  getLink(domainOrSlug, maybeSlug) {
-    const slug = normalizeSlug(maybeSlug || domainOrSlug);
-    const params = [slug];
-    let domainClause = "";
-    if (maybeSlug) {
-      domainClause = "AND d.hostname = ?";
-      params.push(normalizeHostname(domainOrSlug));
-    }
-    const row = this.database.db.query(`
-      SELECT l.*, d.hostname
-      FROM links l
-      JOIN domains d ON d.id = l.domain_id
-      WHERE l.slug = ? ${domainClause}
-      ORDER BY d.default_domain DESC, l.created_at ASC
-      LIMIT 1
-    `).get(...params);
-    return row ? linkFromRow(row) : null;
-  }
-  resolve(hostname2, slug) {
-    const normalizedSlug = normalizeSlug(slug);
-    const normalizedHost = normalizeHostname(hostname2);
-    const row = this.database.db.query(`
-      SELECT l.*, d.hostname
-      FROM links l
-      JOIN domains d ON d.id = l.domain_id
-      WHERE d.hostname = ? AND l.slug = ?
-      LIMIT 1
-    `).get(normalizedHost, normalizedSlug);
-    if (row)
-      return linkFromRow(row);
-    const fallback = this.getDefaultDomain();
-    if (!fallback || fallback.hostname === normalizedHost)
-      return null;
-    return this.getLink(fallback.hostname, normalizedSlug);
-  }
-  setLinkActive(domainOrSlug, maybeSlugOrActive, maybeActive) {
-    const active = typeof maybeSlugOrActive === "boolean" ? maybeSlugOrActive : Boolean(maybeActive);
-    const link = typeof maybeSlugOrActive === "boolean" ? this.getLink(domainOrSlug) : this.getLink(domainOrSlug, maybeSlugOrActive);
-    if (!link)
-      throw new Error("Link not found.");
-    const timestamp = now();
-    this.database.db.query(`
-      UPDATE links SET active = ?, updated_at = ?, synced_at = NULL WHERE id = ?
-    `).run(active ? 1 : 0, timestamp, link.id);
-    return this.getLink(link.hostname, link.slug);
-  }
-  deleteLink(domainOrSlug, maybeSlug) {
-    const link = maybeSlug ? this.getLink(domainOrSlug, maybeSlug) : this.getLink(domainOrSlug);
-    if (!link)
-      throw new Error("Link not found.");
-    this.database.db.query("DELETE FROM links WHERE id = ?").run(link.id);
-    return link;
-  }
-  recordClick(link, input = {}) {
-    const timestamp = now();
-    const machineId = getMachineId();
-    const ipHash = input.ip ? this.hashIp(input.ip) : null;
-    const id = makeId("clk");
-    this.database.db.query(`
-      INSERT INTO clicks (
-        id, link_id, domain_id, slug, clicked_at, ip_hash, user_agent, referer,
-        country, city, metadata, machine_id, synced_at, created_at, updated_at
-      )
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?)
-    `).run(id, link.id, link.domain_id, link.slug, timestamp, ipHash, input.userAgent || null, input.referer || null, input.country || null, input.city || null, JSON.stringify(input.metadata || {}), machineId, timestamp, timestamp);
-    const row = this.database.db.query("SELECT * FROM clicks WHERE id = ?").get(id);
-    return clickFromRow(row);
-  }
-  getStats(domainOrSlug, maybeSlug) {
-    const link = maybeSlug ? this.getLink(domainOrSlug, maybeSlug) : this.getLink(domainOrSlug);
-    if (!link)
-      throw new Error("Link not found.");
-    const summary = this.database.db.query(`
-      SELECT COUNT(*) AS clicks, MAX(clicked_at) AS last_clicked_at FROM clicks WHERE link_id = ?
-    `).get(link.id);
-    const topReferrers = this.database.db.query(`
-      SELECT referer, COUNT(*) AS clicks
-      FROM clicks
-      WHERE link_id = ?
-      GROUP BY referer
-      ORDER BY clicks DESC
-      LIMIT 10
-    `).all(link.id);
-    const topUserAgents = this.database.db.query(`
-      SELECT user_agent, COUNT(*) AS clicks
-      FROM clicks
-      WHERE link_id = ?
-      GROUP BY user_agent
-      ORDER BY clicks DESC
-      LIMIT 10
-    `).all(link.id);
-    return {
-      link,
-      clicks: summary.clicks,
-      last_clicked_at: summary.last_clicked_at,
-      top_referrers: topReferrers,
-      top_user_agents: topUserAgents
-    };
-  }
-  totalStats() {
-    const row = this.database.db.query(`
-      SELECT
-        (SELECT COUNT(*) FROM domains) AS domains,
-        (SELECT COUNT(*) FROM links) AS links,
-        (SELECT COUNT(*) FROM clicks) AS clicks
-    `).get();
-    return row;
-  }
-  generateAvailableSlug(domainId, length) {
-    for (let attempt = 0;attempt < 32; attempt += 1) {
-      const slug = randomToken(length);
-      const exists = this.database.db.query(`
-        SELECT 1 FROM links WHERE domain_id = ? AND slug = ? LIMIT 1
-      `).get(domainId, slug);
-      if (!exists)
-        return slug;
-    }
-    throw new Error("Could not generate an unused slug after 32 attempts.");
-  }
-  hashIp(ip) {
-    const salt = process.env.SHORTLINKS_CLICK_SALT || "shortlinks-local";
-    return createHash("sha256").update(`${salt}:${ip}`).digest("hex");
-  }
-}
-
-// src/server.ts
-function json(data, status = 200) {
-  return new Response(JSON.stringify(data, null, 2), {
-    status,
-    headers: { "content-type": "application/json; charset=utf-8" }
-  });
-}
-function getHost(request, fallback) {
-  const forwarded = request.headers.get("x-forwarded-host");
-  const host = forwarded || request.headers.get("host") || fallback || "";
-  return host.split(",")[0].trim().split(":")[0];
-}
-function getClientIp(request) {
-  const forwarded = request.headers.get("x-forwarded-for");
-  if (forwarded)
-    return forwarded.split(",")[0].trim();
-  return request.headers.get("cf-connecting-ip") || request.headers.get("x-real-ip");
-}
-function isExpired(link) {
-  return Boolean(link.expires_at && new Date(link.expires_at).getTime() <= Date.now());
-}
-function createShortlinksHandler(options = {}) {
-  const store = options.store || new ShortlinksStore(options.dbPath);
-  const redirectStatus = options.redirectStatus || 302;
-  return async (request) => {
-    const url = new URL(request.url);
-    if (url.pathname === "/healthz") {
-      return json({ ok: true, service: "shortlinks", stats: store.totalStats() });
-    }
-    if (url.pathname === "/" || url.pathname === "") {
-      return json({ service: "shortlinks", ok: true });
-    }
-    let slug = "";
-    try {
-      slug = decodeURIComponent(url.pathname.replace(/^\/+/, "").split("/")[0] || "");
-    } catch {
-      return json({ error: "Invalid slug." }, 400);
-    }
-    if (!slug)
-      return json({ error: "Missing slug." }, 404);
-    const host = getHost(request, options.defaultHost);
-    if (!host)
-      return json({ error: "Missing Host header." }, 400);
-    let link = null;
-    try {
-      link = store.resolve(host, slug);
-    } catch {
-      return json({ error: "Shortlink not found.", slug, host }, 404);
-    }
-    if (!link)
-      return json({ error: "Shortlink not found.", slug, host }, 404);
-    if (!link.active)
-      return json({ error: "Shortlink is disabled.", slug, host }, 410);
-    if (isExpired(link))
-      return json({ error: "Shortlink is expired.", slug, host }, 410);
-    store.recordClick(link, {
-      ip: getClientIp(request),
-      userAgent: request.headers.get("user-agent"),
-      referer: request.headers.get("referer"),
-      country: request.headers.get("cf-ipcountry"),
-      metadata: {
-        path: url.pathname,
-        query: url.search
-      }
-    });
-    return Response.redirect(link.destination_url, redirectStatus);
-  };
-}
-function serveShortlinks(options = {}) {
-  const host = options.host || "127.0.0.1";
-  const port = options.port || 8787;
-  const fetch2 = createShortlinksHandler(options);
-  return Bun.serve({ hostname: host, port, fetch: fetch2 });
-}
-
-// src/cloudflare.ts
-import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync3 } from "fs";
-import { join as join3 } from "path";
-function createCloudflarePlan(input) {
-  const hostname2 = normalizeHostname(input.hostname);
-  const target = normalizeHostname(input.target);
-  const workerName = input.workerName || "shortlinks";
-  const proxied = input.proxied ?? true;
-  return {
-    hostname: hostname2,
-    target,
-    proxied,
-    workerName,
-    origin: input.origin,
-    dnsRecord: {
-      type: "CNAME",
-      name: hostname2,
-      content: target,
-      proxied
-    },
-    wranglerCommand: `wrangler deploy cloudflare/${workerName}.js --name ${workerName}`
-  };
-}
-function generateWorkerScript() {
-  return `export default {
-  async fetch(request, env) {
-    const origin = env.SHORTLINKS_ORIGIN;
-    if (!origin) {
-      return new Response("SHORTLINKS_ORIGIN is not configured", { status: 500 });
-    }
-
-    const incoming = new URL(request.url);
-    const upstream = new URL(incoming.pathname + incoming.search, origin);
-    const headers = new Headers(request.headers);
-    headers.set("x-forwarded-host", incoming.host);
-    headers.set("x-shortlinks-worker", "cloudflare");
-
-    return fetch(upstream.toString(), {
-      method: request.method,
-      headers,
-      body: request.method === "GET" || request.method === "HEAD" ? undefined : request.body,
-      redirect: "manual"
-    });
-  }
-};
-`;
-}
-function writeWorkerFiles(options = {}) {
-  const outDir = options.outDir || "cloudflare";
-  const workerName = options.workerName || "shortlinks";
-  mkdirSync3(outDir, { recursive: true });
-  const workerPath = join3(outDir, `${workerName}.js`);
-  const wranglerPath = join3(outDir, "wrangler.example.toml");
-  writeFileSync3(workerPath, generateWorkerScript());
-  writeFileSync3(wranglerPath, `name = "${workerName}"
-main = "${workerName}.js"
-compatibility_date = "2026-05-01"
-
-[vars]
-SHORTLINKS_ORIGIN = "${options.origin || "https://shortlinks.example.com"}"
-`);
-  return { workerPath, wranglerPath };
-}
-function cloudflareAuthHeaders(token) {
-  const apiToken = token || process.env.CLOUDFLARE_API_TOKEN;
-  if (apiToken)
-    return { authorization: `Bearer ${apiToken}` };
-  const apiKey = process.env.CLOUDFLARE_API_KEY;
-  const email = process.env.CLOUDFLARE_EMAIL;
-  if (apiKey && email) {
-    return {
-      "x-auth-key": apiKey,
-      "x-auth-email": email
-    };
-  }
-  throw new Error("Cloudflare auth is required: set CLOUDFLARE_API_TOKEN, or CLOUDFLARE_API_KEY plus CLOUDFLARE_EMAIL.");
-}
-async function cloudflareRequest(token, path, init = {}) {
-  const response = await fetch(`https://api.cloudflare.com/client/v4${path}`, {
-    ...init,
-    headers: {
-      ...cloudflareAuthHeaders(token),
-      "content-type": "application/json",
-      ...init.headers || {}
-    }
-  });
-  const body = await response.json();
-  if (!response.ok || body.success === false) {
-    const message = body.errors?.map((e) => e.message).join("; ") || response.statusText;
-    throw new Error(`Cloudflare API failed: ${message}`);
-  }
-  return body.result;
-}
-function candidateZones(hostname2) {
-  const parts = normalizeHostname(hostname2).split(".");
-  const candidates = [];
-  for (let i = 0;i < parts.length - 1; i += 1) {
-    candidates.push(parts.slice(i).join("."));
-  }
-  return candidates;
-}
-async function findCloudflareZoneId(hostname2, token) {
-  for (const zone of candidateZones(hostname2)) {
-    const result = await cloudflareRequest(token, `/zones?name=${encodeURIComponent(zone)}`);
-    if (result[0]?.id)
-      return result[0].id;
-  }
-  throw new Error(`Could not find a Cloudflare zone for ${hostname2}. Pass --zone-id explicitly.`);
-}
-async function upsertCloudflareDnsRecord(options) {
-  const token = options.token || process.env.CLOUDFLARE_API_TOKEN;
-  const plan = createCloudflarePlan({
-    hostname: options.hostname,
-    target: options.target,
-    origin: process.env.SHORTLINKS_ORIGIN || "https://shortlinks.example.com",
-    proxied: options.proxied
-  });
-  if (options.dryRun)
-    return plan;
-  const zoneId = options.zoneId || await findCloudflareZoneId(plan.hostname, token);
-  const existing = await cloudflareRequest(token, `/zones/${zoneId}/dns_records?type=CNAME&name=${encodeURIComponent(plan.hostname)}`);
-  const payload = JSON.stringify(plan.dnsRecord);
-  if (existing[0]?.id) {
-    const updated = await cloudflareRequest(token, `/zones/${zoneId}/dns_records/${existing[0].id}`, {
-      method: "PUT",
-      body: payload
-    });
-    return { id: updated.id, action: "updated" };
-  }
-  const created = await cloudflareRequest(token, `/zones/${zoneId}/dns_records`, {
-    method: "POST",
-    body: payload
-  });
-  return { id: created.id, action: "created" };
-}
-
-// src/domains-cli.ts
-import { spawnSync } from "child_process";
-function buildDomainsArgs(action, domain) {
-  switch (action) {
-    case "check":
-      return ["domain", "check", domain];
-    case "buy":
-      return ["domain", "buy", domain];
-    case "setup":
-      return ["domain", "setup", domain];
-  }
-}
-function runDomains(action, domain, options = {}) {
-  const args = buildDomainsArgs(action, domain);
-  const command = `domains ${args.join(" ")}`;
-  if (options.dryRun) {
-    return { command, status: 0, stdout: command, stderr: "" };
-  }
-  const result = spawnSync("domains", args, { encoding: "utf-8" });
-  return {
-    command,
-    status: result.status,
-    stdout: result.stdout || "",
-    stderr: result.stderr || ""
-  };
-}
-
-// src/local.ts
-import { spawnSync as spawnSync2 } from "child_process";
-import { homedir as homedir2 } from "os";
-import { join as join4 } from "path";
-function createLocalSetupPlan(input) {
-  const domain = normalizeHostname(input.domain);
-  const targetHost = input.targetHost || "127.0.0.1";
-  const port = input.port || 8787;
-  const certDir = input.certDir || join4(homedir2(), ".hasna", "machines", "certs");
-  const certPath = join4(certDir, `${domain}.pem`);
-  const keyPath = join4(certDir, `${domain}-key.pem`);
-  return {
-    domain,
-    targetHost,
-    port,
-    hostsEntry: `${targetHost} ${domain}`,
-    caddySnippet: `${domain} {
-  reverse_proxy ${targetHost}:${port}
-  tls ${certPath} ${keyPath}
-}`,
-    certPath,
-    keyPath,
-    machinesCommand: `machines dns add --domain ${domain} --target-host ${targetHost} --port ${port} --json`,
-    sudoRequired: true
-  };
-}
-function registerMachinesDns(input) {
-  const plan = createLocalSetupPlan(input);
-  const args = [
-    "dns",
-    "add",
-    "--domain",
-    plan.domain,
-    "--target-host",
-    plan.targetHost,
-    "--port",
-    String(plan.port),
-    "--json"
-  ];
-  const result = spawnSync2("machines", args, { encoding: "utf-8" });
-  return {
-    command: `machines ${args.join(" ")}`,
-    status: result.status,
-    stdout: result.stdout || "",
-    stderr: result.stderr || ""
-  };
-}
-
-// src/pg-migrations.ts
-var PG_MIGRATIONS = [
-  `
-  CREATE TABLE IF NOT EXISTS domains (
-    id TEXT PRIMARY KEY,
-    hostname TEXT NOT NULL UNIQUE,
-    provider TEXT NOT NULL DEFAULT 'manual',
-    default_domain INTEGER NOT NULL DEFAULT 0,
-    cloudflare_zone_id TEXT,
-    cloudflare_account_id TEXT,
-    cloudflare_worker_name TEXT,
-    origin_url TEXT,
-    notes TEXT,
-    metadata TEXT NOT NULL DEFAULT '{}',
-    machine_id TEXT,
-    synced_at TIMESTAMPTZ,
-    created_at TIMESTAMPTZ NOT NULL,
-    updated_at TIMESTAMPTZ NOT NULL
-  );
-
-  CREATE TABLE IF NOT EXISTS links (
-    id TEXT PRIMARY KEY,
-    domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-    slug TEXT NOT NULL,
-    destination_url TEXT NOT NULL,
-    title TEXT,
-    active INTEGER NOT NULL DEFAULT 1,
-    expires_at TIMESTAMPTZ,
-    metadata TEXT NOT NULL DEFAULT '{}',
-    machine_id TEXT,
-    synced_at TIMESTAMPTZ,
-    created_at TIMESTAMPTZ NOT NULL,
-    updated_at TIMESTAMPTZ NOT NULL,
-    UNIQUE(domain_id, slug)
-  );
-
-  CREATE TABLE IF NOT EXISTS clicks (
-    id TEXT PRIMARY KEY,
-    link_id TEXT NOT NULL REFERENCES links(id) ON DELETE CASCADE,
-    domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
-    slug TEXT NOT NULL,
-    clicked_at TIMESTAMPTZ NOT NULL,
-    ip_hash TEXT,
-    user_agent TEXT,
-    referer TEXT,
-    country TEXT,
-    city TEXT,
-    metadata TEXT NOT NULL DEFAULT '{}',
-    machine_id TEXT,
-    synced_at TIMESTAMPTZ,
-    created_at TIMESTAMPTZ NOT NULL,
-    updated_at TIMESTAMPTZ NOT NULL
-  );
-
-  CREATE INDEX IF NOT EXISTS idx_domains_hostname ON domains(hostname);
-  CREATE INDEX IF NOT EXISTS idx_domains_default ON domains(default_domain);
-  CREATE INDEX IF NOT EXISTS idx_links_domain_slug ON links(domain_id, slug);
-  CREATE INDEX IF NOT EXISTS idx_links_active ON links(active);
-  CREATE INDEX IF NOT EXISTS idx_links_updated ON links(updated_at);
-  CREATE INDEX IF NOT EXISTS idx_clicks_link ON clicks(link_id);
-  CREATE INDEX IF NOT EXISTS idx_clicks_domain ON clicks(domain_id);
-  CREATE INDEX IF NOT EXISTS idx_clicks_clicked_at ON clicks(clicked_at);
-  CREATE INDEX IF NOT EXISTS idx_clicks_updated ON clicks(updated_at);
-  `
-];
-
-// src/cli/index.ts
-function getPackageVersion() {
-  try {
-    const pkgPath = join5(dirname3(fileURLToPath(import.meta.url)), "..", "..", "package.json");
-    return JSON.parse(readFileSync3(pkgPath, "utf-8")).version || "0.0.0";
-  } catch {
-    return "0.0.0";
-  }
-}
-var program2 = new Command;
-function useJson(localOpts) {
-  return Boolean(localOpts?.json || program2.opts().json);
-}
-function print(data, localOpts, human) {
-  if (useJson(localOpts)) {
-    console.log(JSON.stringify(data, null, 2));
-    return;
-  }
-  if (human)
-    human();
-}
-function handleError(error) {
-  const message = error instanceof Error ? error.message : String(error);
-  if (useJson()) {
-    console.log(JSON.stringify({ error: message }));
-  } else {
-    console.error(source_default.red(message));
-  }
-  process.exit(1);
-}
-function withStore(fn) {
-  const store = new ShortlinksStore(program2.opts().db);
-  try {
-    return fn(store);
-  } finally {
-    store.close();
-  }
-}
-async function withStoreAsync(fn) {
-  const store = new ShortlinksStore(program2.opts().db);
-  try {
-    return await fn(store);
-  } finally {
-    store.close();
-  }
-}
-function formatLink(link) {
-  return `${source_default.green(link.short_url || `${link.hostname}/${link.slug}`)} ${source_default.dim("->")} ${link.destination_url}`;
-}
-function commandExists(command) {
-  const result = spawnSync3("which", [command], { encoding: "utf-8" });
-  return result.status === 0;
-}
-program2.name("shortlinks").description("CLI-only shortlink manager with custom domains, click tracking, Cloudflare helpers, and cloud sync").version(getPackageVersion()).option("--db <path>", "SQLite database path").option("-j, --json", "Output JSON for agents and scripts");
-program2.command("init").description("Initialize local shortlinks storage").option("--domain <hostname>", "Add a default shortlink domain").option("--public-base-url <url>", "Public URL base for generated links").option("-j, --json", "Output JSON").action((opts) => {
-  try {
-    const result = withStore((store) => {
-      const config = loadConfig();
-      if (opts.publicBaseUrl)
-        config.publicBaseUrl = opts.publicBaseUrl;
-      if (opts.domain) {
-        const domain = store.addDomain({
-          hostname: opts.domain,
-          provider: "manual",
-          defaultDomain: true
-        });
-        config.defaultDomain = domain.hostname;
-        config.publicBaseUrl = opts.publicBaseUrl || `https://${domain.hostname}`;
-      }
-      saveConfig(config);
-      return {
-        data_dir: getDataDir(),
-        config_path: getConfigPath(),
-        db_path: getDatabasePath(program2.opts().db),
-        config,
-        stats: store.totalStats()
-      };
-    });
-    print(result, opts, () => {
-      console.log(source_default.green("shortlinks initialized"));
-      console.log(`  Data: ${result.data_dir}`);
-      console.log(`  DB: ${result.db_path}`);
-      if (result.config.defaultDomain)
-        console.log(`  Default domain: ${result.config.defaultDomain}`);
-    });
-  } catch (error) {
-    handleError(error);
-  }
-});
-var configCmd = program2.command("config").description("View and update local config");
-configCmd.command("show").description("Show local config").option("-j, --json", "Output JSON").action((opts) => {
-  const data = { path: getConfigPath(), config: loadConfig() };
-  print(data, opts, () => console.log(JSON.stringify(data, null, 2)));
-});
-configCmd.command("set <key> <value>").description("Set config value: default-domain, public-base-url, cloudflare-account-id, cloudflare-worker-name, cloudflare-origin").option("-j, --json", "Output JSON").action((key, value, opts) => {
-  try {
-    let config = loadConfig();
-    switch (key) {
-      case "default-domain":
-        config = updateConfig({ defaultDomain: value, publicBaseUrl: config.publicBaseUrl || `https://${value}` });
-        break;
-      case "public-base-url":
-        config = updateConfig({ publicBaseUrl: value });
-        break;
-      case "cloudflare-account-id":
-        config = updateConfig({ cloudflare: { accountId: value } });
-        break;
-      case "cloudflare-worker-name":
-        config = updateConfig({ cloudflare: { workerName: value } });
-        break;
-      case "cloudflare-origin":
-        config = updateConfig({ cloudflare: { origin: value } });
-        break;
-      default:
-        throw new Error(`Unknown config key: ${key}`);
-    }
-    print({ path: getConfigPath(), config }, opts, () => console.log(source_default.green(`Set ${key}.`)));
-  } catch (error) {
-    handleError(error);
-  }
-});
-var domainCmd = program2.command("domain").alias("domains").description("Manage custom shortlink domains");
-domainCmd.command("add <hostname>").description("Add or update a custom domain").option("--provider <provider>", "Provider label", "manual").option("--default", "Make this the default domain").option("--cloudflare-zone-id <id>", "Cloudflare zone ID").option("--cloudflare-account-id <id>", "Cloudflare account ID").option("--cloudflare-worker-name <name>", "Cloudflare Worker name").option("--origin <url>", "Origin redirect server URL").option("--notes <text>", "Notes").option("-j, --json", "Output JSON").action((hostname2, opts) => {
-  try {
-    const domain = withStore((store) => store.addDomain({
-      hostname: hostname2,
-      provider: opts.provider,
-      defaultDomain: opts.default,
-      cloudflareZoneId: opts.cloudflareZoneId,
-      cloudflareAccountId: opts.cloudflareAccountId,
-      cloudflareWorkerName: opts.cloudflareWorkerName,
-      originUrl: opts.origin,
-      notes: opts.notes
-    }));
-    print(domain, opts, () => {
-      console.log(source_default.green(`Domain ready: ${domain.hostname}`));
-      if (domain.default_domain)
-        console.log(source_default.dim("Default domain updated."));
-    });
-  } catch (error) {
-    handleError(error);
-  }
-});
-domainCmd.command("list").description("List configured domains").option("-j, --json", "Output JSON").action((opts) => {
-  try {
-    const domains = withStore((store) => store.listDomains());
-    print(domains, opts, () => {
-      if (domains.length === 0) {
-        console.log(source_default.dim("No domains configured."));
-        return;
-      }
-      for (const domain of domains) {
-        const marker = domain.default_domain ? source_default.green("*") : " ";
-        console.log(`${marker} ${domain.hostname} ${source_default.dim(domain.provider)}`);
-      }
-    });
-  } catch (error) {
-    handleError(error);
-  }
-});
-domainCmd.command("get <hostname>").description("Show a configured domain").option("-j, --json", "Output JSON").action((hostname2, opts) => {
-  try {
-    const domain = withStore((store) => store.getDomain(hostname2));
-    if (!domain)
-      throw new Error("Domain not found.");
-    print(domain, opts, () => console.log(JSON.stringify(domain, null, 2)));
-  } catch (error) {
-    handleError(error);
-  }
-});
-domainCmd.command("setup <hostname>").description("Add a domain locally and optionally prepare Cloudflare DNS").option("--default", "Make this the default domain").option("--origin <url>", "Origin redirect server URL").option("--cloudflare", "Upsert Cloudflare CNAME record").option("--target <hostname>", "CNAME target for Cloudflare DNS").option("--zone-id <id>", "Cloudflare zone ID").option("--dry-run", "Show the Cloudflare plan without changing DNS").option("-j, --json", "Output JSON").action(async (hostname2, opts) => {
-  try {
-    const result = await withStoreAsync(async (store) => {
-      const domain = store.addDomain({
-        hostname: hostname2,
-        provider: opts.cloudflare ? "cloudflare" : "manual",
-        defaultDomain: opts.default,
-        originUrl: opts.origin
-      });
-      const cloudflare = opts.cloudflare ? await upsertCloudflareDnsRecord({
-        hostname: hostname2,
-        target: opts.target || hostname2,
-        zoneId: opts.zoneId,
-        dryRun: opts.dryRun
-      }) : null;
-      return { domain, cloudflare };
-    });
-    print(result, opts, () => {
-      console.log(source_default.green(`Domain ready: ${result.domain.hostname}`));
-      if (result.cloudflare)
-        console.log(JSON.stringify(result.cloudflare, null, 2));
-    });
-  } catch (error) {
-    handleError(error);
-  }
-});
-domainCmd.command("check <hostname>").description("Check domain availability through @hasna/domains").option("--dry-run", "Print the command without running it").option("-j, --json", "Output JSON").action((hostname2, opts) => {
-  const result = runDomains("check", hostname2, { dryRun: opts.dryRun });
-  print(result, opts, () => {
-    if (result.stdout.trim())
-      console.log(result.stdout.trim());
-    if (result.stderr.trim())
-      console.error(result.stderr.trim());
-    if (result.status !== 0)
-      process.exit(result.status || 1);
-  });
-});
-domainCmd.command("buy <hostname>").description("Buy a domain through @hasna/domains / Route 53").option("--dry-run", "Print the command without running it").option("-j, --json", "Output JSON").action((hostname2, opts) => {
-  const result = runDomains("buy", hostname2, { dryRun: opts.dryRun });
-  print(result, opts, () => {
-    if (result.stdout.trim())
-      console.log(result.stdout.trim());
-    if (result.stderr.trim())
-      console.error(result.stderr.trim());
-    if (result.status !== 0)
-      process.exit(result.status || 1);
-  });
-});
-var linkCmd = program2.command("link").alias("links").description("Manage shortlinks");
-function createLinkAction(url, opts) {
-  try {
-    const link = withStore((store) => store.createLink({
-      destinationUrl: url,
-      domain: opts.domain,
-      slug: opts.slug,
-      title: opts.title,
-      expiresAt: opts.expires,
-      slugLength: opts.length ? Number(opts.length) : undefined
-    }));
-    print(link, opts, () => console.log(formatLink(link)));
-  } catch (error) {
-    handleError(error);
-  }
-}
-linkCmd.command("create <url>").description("Create a shortlink").option("--domain <hostname>", "Domain to use").option("--slug <slug>", "Custom slug").option("--title <title>", "Human title").option("--expires <date>", "Expiration date").option("--length <n>", "Generated slug length", "7").option("-j, --json", "Output JSON").action(createLinkAction);
-program2.command("create <url>").description("Create a shortlink").option("--domain <hostname>", "Domain to use").option("--slug <slug>", "Custom slug").option("--title <title>", "Human title").option("--expires <date>", "Expiration date").option("--length <n>", "Generated slug length", "7").option("-j, --json", "Output JSON").action(createLinkAction);
-linkCmd.command("list").description("List shortlinks").option("--domain <hostname>", "Filter by domain").option("--active", "Only active links").option("--limit <n>", "Maximum rows", "100").option("-j, --json", "Output JSON").action((opts) => {
-  try {
-    const links = withStore((store) => store.listLinks({
-      domain: opts.domain,
-      activeOnly: opts.active,
-      limit: Number(opts.limit)
-    }));
-    print(links, opts, () => {
-      if (links.length === 0) {
-        console.log(source_default.dim("No links yet."));
-        return;
-      }
-      for (const link of links)
-        console.log(formatLink(link));
-    });
-  } catch (error) {
-    handleError(error);
-  }
-});
-linkCmd.command("get <slug>").description("Show a shortlink").option("--domain <hostname>", "Domain to use").option("-j, --json", "Output JSON").action((slug, opts) => {
-  try {
-    const link = withStore((store) => opts.domain ? store.getLink(opts.domain, slug) : store.getLink(slug));
-    if (!link)
-      throw new Error("Link not found.");
-    print(link, opts, () => console.log(JSON.stringify(link, null, 2)));
-  } catch (error) {
-    handleError(error);
-  }
-});
-linkCmd.command("disable <slug>").description("Disable a shortlink").option("--domain <hostname>", "Domain to use").option("-j, --json", "Output JSON").action((slug, opts) => {
-  try {
-    const link = withStore((store) => opts.domain ? store.setLinkActive(opts.domain, slug, false) : store.setLinkActive(slug, false));
-    print(link, opts, () => console.log(source_default.green(`Disabled ${link.short_url}`)));
-  } catch (error) {
-    handleError(error);
-  }
-});
-linkCmd.command("enable <slug>").description("Enable a shortlink").option("--domain <hostname>", "Domain to use").option("-j, --json", "Output JSON").action((slug, opts) => {
-  try {
-    const link = withStore((store) => opts.domain ? store.setLinkActive(opts.domain, slug, true) : store.setLinkActive(slug, true));
-    print(link, opts, () => console.log(source_default.green(`Enabled ${link.short_url}`)));
-  } catch (error) {
-    handleError(error);
-  }
-});
-linkCmd.command("delete <slug>").description("Delete a shortlink").option("--domain <hostname>", "Domain to use").option("-j, --json", "Output JSON").action((slug, opts) => {
-  try {
-    const link = withStore((store) => opts.domain ? store.deleteLink(opts.domain, slug) : store.deleteLink(slug));
-    print(link, opts, () => console.log(source_default.green(`Deleted ${link.short_url}`)));
-  } catch (error) {
-    handleError(error);
-  }
-});
-program2.command("resolve <slug>").description("Resolve a slug to its destination without recording a click").option("--domain <hostname>", "Domain to use").option("-j, --json", "Output JSON").action((slug, opts) => {
-  try {
-    const link = withStore((store) => opts.domain ? store.getLink(opts.domain, slug) : store.getLink(slug));
-    if (!link)
-      throw new Error("Link not found.");
-    print(link, opts, () => console.log(link.destination_url));
-  } catch (error) {
-    handleError(error);
-  }
-});
-program2.command("stats [slug]").description("Show overall stats or stats for a shortlink").option("--domain <hostname>", "Domain to use").option("-j, --json", "Output JSON").action((slug, opts) => {
-  try {
-    const result = withStore((store) => {
-      if (slug)
-        return opts.domain ? store.getStats(opts.domain, slug) : store.getStats(slug);
-      return store.totalStats();
-    });
-    print(result, opts, () => console.log(JSON.stringify(result, null, 2)));
-  } catch (error) {
-    handleError(error);
-  }
-});
-program2.command("serve").description("Run the redirect server that records clicks").option("--host <host>", "Bind host", "127.0.0.1").option("--port <port>", "Port", "8787").option("--default-host <hostname>", "Fallback host if the request has no Host header").action((opts) => {
-  try {
-    const server = serveShortlinks({
-      dbPath: program2.opts().db,
-      host: opts.host,
-      port: Number(opts.port),
-      defaultHost: opts.defaultHost
-    });
-    console.log(source_default.green(`shortlinks redirect server listening on http://${server.hostname}:${server.port}`));
-  } catch (error) {
-    handleError(error);
-  }
-});
-var cfCmd = program2.command("cloudflare").description("Cloudflare DNS and Worker helpers");
-cfCmd.command("plan <hostname>").description("Print the Cloudflare setup plan").requiredOption("--target <hostname>", "CNAME target").option("--origin <url>", "Origin redirect server URL", process.env.SHORTLINKS_ORIGIN || "https://shortlinks.example.com").option("--worker <name>", "Worker name", "shortlinks").option("--no-proxied", "Create unproxied DNS record").option("-j, --json", "Output JSON").action((hostname2, opts) => {
-  try {
-    const plan = createCloudflarePlan({
-      hostname: hostname2,
-      target: opts.target,
-      origin: opts.origin,
-      workerName: opts.worker,
-      proxied: opts.proxied
-    });
-    print(plan, opts, () => console.log(JSON.stringify(plan, null, 2)));
-  } catch (error) {
-    handleError(error);
-  }
-});
-cfCmd.command("worker").description("Write Cloudflare Worker files").option("--out-dir <dir>", "Output directory", "cloudflare").option("--worker <name>", "Worker name", "shortlinks").option("--origin <url>", "Origin redirect server URL", process.env.SHORTLINKS_ORIGIN || "https://shortlinks.example.com").option("-j, --json", "Output JSON").action((opts) => {
-  try {
-    const result = writeWorkerFiles({ outDir: opts.outDir, workerName: opts.worker, origin: opts.origin });
-    print(result, opts, () => {
-      console.log(source_default.green(`Wrote ${result.workerPath}`));
-      console.log(source_default.green(`Wrote ${result.wranglerPath}`));
-    });
-  } catch (error) {
-    handleError(error);
-  }
-});
-cfCmd.command("dns <hostname>").description("Create or update the Cloudflare CNAME record").requiredOption("--target <hostname>", "CNAME target").option("--zone-id <id>", "Cloudflare zone ID").option("--dry-run", "Show plan without changing DNS").option("--no-proxied", "Create unproxied DNS record").option("-j, --json", "Output JSON").action(async (hostname2, opts) => {
-  try {
-    const result = await upsertCloudflareDnsRecord({
-      hostname: hostname2,
-      target: opts.target,
-      zoneId: opts.zoneId,
-      dryRun: opts.dryRun,
-      proxied: opts.proxied
-    });
-    print(result, opts, () => console.log(JSON.stringify(result, null, 2)));
-  } catch (error) {
-    handleError(error);
-  }
-});
-var cloudCmd = program2.command("cloud").description("@hasna/cloud sync helpers");
-cloudCmd.command("migrate").description("Apply shortlinks PostgreSQL migrations").option("--connection-string <url>", "PostgreSQL connection string").option("-j, --json", "Output JSON").action(async (opts) => {
-  try {
-    const { getConnectionString, applyPgMigrations } = await import("@hasna/cloud");
-    const conn = opts.connectionString || getConnectionString("shortlinks");
-    const result = await applyPgMigrations(conn, PG_MIGRATIONS, "shortlinks");
-    print(result, opts, () => console.log(JSON.stringify(result, null, 2)));
-  } catch (error) {
-    handleError(error);
-  }
-});
-async function syncCloud(direction, opts) {
-  const {
-    getCloudConfig,
-    getConnectionString,
-    SqliteAdapter,
-    PgAdapterAsync,
-    listSqliteTables,
-    listPgTables,
-    syncPush,
-    syncPull
-  } = await import("@hasna/cloud");
-  const config = getCloudConfig();
-  if (config.mode === "local")
-    throw new Error("Cloud mode is local. Run `cloud setup` first.");
-  const local = new SqliteAdapter(getDatabasePath(program2.opts().db));
-  const remote = new PgAdapterAsync(getConnectionString("shortlinks"));
-  try {
-    const requestedTables = opts.tables ? opts.tables.split(",").map((t) => t.trim()).filter(Boolean) : null;
-    const localTables = requestedTables || listSqliteTables(local).filter((t) => !t.startsWith("_"));
-    const remoteTables = requestedTables || await listPgTables(remote).catch(() => localTables);
-    const tables = [...new Set(direction === "pull" ? remoteTables : direction === "push" ? localTables : [...localTables, ...remoteTables])];
-    const results = [];
-    if (direction === "pull" || direction === "sync") {
-      results.push({ direction: "pull", tables: await syncPull(remote, local, { tables }) });
-    }
-    if (direction === "push" || direction === "sync") {
-      results.push({ direction: "push", tables: await syncPush(local, remote, { tables }) });
-    }
-    print({ service: "shortlinks", results }, opts, () => console.log(JSON.stringify({ service: "shortlinks", results }, null, 2)));
-  } finally {
-    local.close?.();
-    await remote.close?.();
-  }
-}
-for (const direction of ["push", "pull", "sync"]) {
-  cloudCmd.command(direction).description(`${direction === "sync" ? "Bidirectionally sync" : direction === "push" ? "Push" : "Pull"} shortlinks data ${direction === "pull" ? "from" : "to"} PostgreSQL`).option("--tables <tables>", "Comma-separated table names").option("-j, --json", "Output JSON").action((opts) => syncCloud(direction, opts).catch(handleError));
-}
-cloudCmd.command("status").description("Show local and cloud configuration health").option("-j, --json", "Output JSON").action(async (opts) => {
-  try {
-    const { getCloudConfig } = await import("@hasna/cloud");
-    const stats = withStore((store) => store.totalStats());
-    const config = getCloudConfig();
-    const data = {
-      service: "shortlinks",
-      db_path: getDatabasePath(program2.opts().db),
-      local: stats,
-      cloud_mode: config.mode,
-      rds_host: config.rds?.host || null
-    };
-    print(data, opts, () => console.log(JSON.stringify(data, null, 2)));
-  } catch (error) {
-    handleError(error);
-  }
-});
-var localCmd = program2.command("local").description("Local domain setup helpers");
-localCmd.command("plan <domain>").description("Render hosts and reverse-proxy setup for a local shortlink domain").option("--port <port>", "Local redirect server port", "8787").option("--target-host <host>", "Local target host", "127.0.0.1").option("-j, --json", "Output JSON").action((domain, opts) => {
-  try {
-    const plan = createLocalSetupPlan({
-      domain,
-      port: Number(opts.port),
-      targetHost: opts.targetHost
-    });
-    print(plan, opts, () => console.log(JSON.stringify(plan, null, 2)));
-  } catch (error) {
-    handleError(error);
-  }
-});
-localCmd.command("setup <domain>").description("Record local domain mapping with machines and print remaining sudo-only setup").option("--port <port>", "Local redirect server port", "8787").option("--target-host <host>", "Local target host", "127.0.0.1").option("--skip-machines", "Do not call machines dns add").option("-j, --json", "Output JSON").action((domain, opts) => {
-  try {
-    const plan = createLocalSetupPlan({
-      domain,
-      port: Number(opts.port),
-      targetHost: opts.targetHost
-    });
-    const machines = opts.skipMachines ? null : registerMachinesDns({
-      domain,
-      port: Number(opts.port),
-      targetHost: opts.targetHost
-    });
-    const result = { plan, machines };
-    print(result, opts, () => {
-      if (machines && machines.status !== 0) {
-        console.error(source_default.yellow(machines.stderr.trim() || "machines dns add failed"));
-      }
-      console.log(JSON.stringify(result, null, 2));
-    });
-  } catch (error) {
-    handleError(error);
-  }
-});
-program2.command("doctor").description("Check local shortlinks tooling and integration readiness").option("-j, --json", "Output JSON").action((opts) => {
-  try {
-    const stats = withStore((store) => store.totalStats());
-    const data = {
-      service: "shortlinks",
-      data_dir: getDataDir(),
-      config_path: getConfigPath(),
-      db_path: getDatabasePath(program2.opts().db),
-      db_exists: existsSync3(getDatabasePath(program2.opts().db)),
-      stats,
-      commands: {
-        domains: commandExists("domains"),
-        cloud: commandExists("cloud"),
-        wrangler: commandExists("wrangler"),
-        secrets: commandExists("secrets")
-      },
-      environment: {
-        cloudflare_api_token_present: Boolean(process.env.CLOUDFLARE_API_TOKEN),
-        cloudflare_api_key_present: Boolean(process.env.CLOUDFLARE_API_KEY),
-        cloudflare_email_present: Boolean(process.env.CLOUDFLARE_EMAIL),
-        shortlinks_origin_present: Boolean(process.env.SHORTLINKS_ORIGIN)
-      }
-    };
-    print(data, opts, () => console.log(JSON.stringify(data, null, 2)));
-  } catch (error) {
-    handleError(error);
-  }
-});
-program2.parseAsync(process.argv).catch(handleError);