webfox 0.0.0-test.0 → 4.0.1

package/dist/cli.js

@@ -0,0 +1,641 @@
+#!/usr/bin/env node
+import {
+  formatDuration
+} from "./chunk-I2UIACY3.js";
+import {
+  renderTextDocument
+} from "./chunk-QRHDXM2L.js";
+import {
+  createWebfox,
+  loadConfig,
+  redactConfig,
+  resolveConfigPath,
+  setCapabilityDefault
+} from "./chunk-MVCCEPDF.js";
+import "./chunk-WCTOYZVB.js";
+import {
+  PACKAGE_VERSION,
+  validateConfiguredOptions
+} from "./chunk-GAWPRXAU.js";
+import "./chunk-ZVTVERW5.js";
+import {
+  CAPABILITIES,
+  PROVIDER_IDS
+} from "./chunk-G2YAQEET.js";
+import {
+  WebfoxError
+} from "./chunk-U4BLULLV.js";
+
+// src/cli.ts
+import { realpathSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import {
+  Command,
+  CommanderError,
+  InvalidArgumentError as InvalidArgumentError2,
+  Option
+} from "commander";
+import pc from "picocolors";
+import { stringify } from "yaml";
+
+// src/cli/diagnostics.ts
+function createDiagnostics(stderr, colors) {
+  const write = (glyph, message) => stderr.write(`${glyph} ${message.trimEnd()}
+`);
+  return {
+    success: (message) => write(colors.green("\u2714\uFE0E"), message),
+    progress: (message) => write(colors.yellow("\u25B6\uFE0E"), message),
+    error(error, input) {
+      const glyph = error.code === "CANCELLED" ? colors.dim("\u25A0") : colors.red("\u2718\uFE0E");
+      write(
+        glyph,
+        `${input === void 0 ? "" : `${input}: `}${error.code}: ${error.message}`
+      );
+    }
+  };
+}
+
+// src/cli/flags.ts
+import { InvalidArgumentError } from "commander";
+var RESERVED_FLAGS = /* @__PURE__ */ new Set([
+  "provider",
+  "config",
+  "cwd",
+  "timeout",
+  "format",
+  "options-json",
+  "quiet",
+  "help",
+  "max-results",
+  "version",
+  "color",
+  "no-color"
+]);
+function buildOptionFlags(schema) {
+  const candidates = [];
+  walkSchema(schema, [], candidates);
+  const counts = /* @__PURE__ */ new Map();
+  for (const flag of candidates) {
+    for (const name of [flag.flag, flag.negativeFlag].filter(
+      (name2) => !!name2
+    ))
+      counts.set(name, (counts.get(name) ?? 0) + 1);
+  }
+  return candidates.filter(
+    (entry) => counts.get(entry.flag) === 1 && (!entry.negativeFlag || counts.get(entry.negativeFlag) === 1) && !entry.flag.startsWith("--no-") && !RESERVED_FLAGS.has(entry.flag.slice(2))
+  );
+}
+function walkSchema(schema, path, output) {
+  const properties = schema.properties;
+  if (properties && typeof properties === "object" && !Array.isArray(properties)) {
+    for (const [name, child] of Object.entries(properties)) {
+      const childSchema = child;
+      const next = [...path, name];
+      if (childSchema.type === "object" && childSchema.properties) {
+        walkSchema(childSchema, next, output);
+        continue;
+      }
+      const descriptor = flagForSchema(childSchema, next);
+      if (descriptor) output.push(descriptor);
+    }
+  }
+}
+function flagForSchema(schema, path) {
+  const flag = `--${path.map(kebab).join("-")}`;
+  const enumValues = readEnum(schema);
+  const kind = schema.type ?? inferEnumKind(enumValues);
+  if (["string", "number", "integer", "boolean"].includes(kind)) {
+    return {
+      flag,
+      ...kind === "boolean" ? { negativeFlag: `--no-${flag.slice(2)}` } : {},
+      path,
+      kind,
+      ...enumValues ? { enumValues } : {},
+      ...schema.description ? { description: schema.description } : {}
+    };
+  }
+  if (kind === "array" && schema.items && ["string", "number", "integer", "boolean"].includes(
+    schema.items.type ?? inferEnumKind(readEnum(schema.items))
+  )) {
+    const itemKind = schema.items.type ?? inferEnumKind(readEnum(schema.items));
+    return {
+      flag,
+      path,
+      kind: "array",
+      itemKind,
+      ...readEnum(schema.items) ? { enumValues: readEnum(schema.items) } : {},
+      ...schema.description ? { description: schema.description } : {}
+    };
+  }
+  return void 0;
+}
+function readEnum(schema) {
+  if (Array.isArray(schema.enum)) return schema.enum;
+  if (Array.isArray(schema.anyOf) && schema.anyOf.every((entry) => "const" in entry)) {
+    return schema.anyOf.map((entry) => entry.const);
+  }
+  return void 0;
+}
+function inferEnumKind(values) {
+  const kind = typeof values?.[0];
+  return kind === "string" || kind === "number" || kind === "boolean" ? kind : void 0;
+}
+function parseTypedValue(raw, descriptor) {
+  const itemKind = descriptor.kind === "array" ? inferArrayKind(descriptor) : descriptor.kind;
+  let value = raw;
+  if (itemKind === "number" || itemKind === "integer") {
+    value = Number(raw);
+    if (!Number.isFinite(value) || itemKind === "integer" && !Number.isInteger(value))
+      throw new InvalidArgumentError(
+        `${descriptor.flag} requires a ${itemKind}`
+      );
+  } else if (itemKind === "boolean") {
+    if (raw !== "true" && raw !== "false")
+      throw new InvalidArgumentError(
+        `${descriptor.flag} requires true or false`
+      );
+    value = raw === "true";
+  }
+  if (descriptor.enumValues && !descriptor.enumValues.includes(value)) {
+    throw new InvalidArgumentError(
+      `${descriptor.flag} must be one of: ${descriptor.enumValues.join(", ")}`
+    );
+  }
+  return value;
+}
+function inferArrayKind(descriptor) {
+  if (descriptor.itemKind) return descriptor.itemKind;
+  if (descriptor.enumValues?.length) {
+    const type = typeof descriptor.enumValues[0];
+    if (type === "number") return "number";
+    if (type === "boolean") return "boolean";
+  }
+  return "string";
+}
+function setPath(target, path, value) {
+  let cursor = target;
+  for (const part of path.slice(0, -1)) {
+    const existing = cursor[part];
+    cursor[part] = existing && typeof existing === "object" && !Array.isArray(existing) ? existing : {};
+    cursor = cursor[part];
+  }
+  cursor[path.at(-1)] = value;
+}
+function kebab(value) {
+  return value.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/_/g, "-").toLowerCase();
+}
+
+// src/cli.ts
+var summaries = {
+  search: "Search the public web",
+  contents: "Extract readable pages",
+  answer: "Answer questions using web sources",
+  research: "Run research in the foreground"
+};
+async function runCli(argv, io = {
+  stdin: process.stdin,
+  stdout: process.stdout,
+  stderr: process.stderr,
+  env: process.env,
+  cwd: process.cwd()
+}) {
+  const beforeSeparator = argv.slice(
+    0,
+    argv.indexOf("--") < 0 ? argv.length : argv.indexOf("--")
+  );
+  const colors = pc.createColors(
+    Boolean(io.stderr.isTTY) && !("NO_COLOR" in io.env) && !beforeSeparator.includes("--no-color")
+  );
+  const helpColors = pc.createColors(
+    Boolean(io.stdout.isTTY) && !("NO_COLOR" in io.env) && !beforeSeparator.includes("--no-color")
+  );
+  const diagnostics = createDiagnostics(io.stderr, colors);
+  const controller = new AbortController();
+  const abort = () => controller.abort(new WebfoxError("CANCELLED", "Operation cancelled."));
+  const signals = io.signalSource ?? process;
+  signals.once("SIGINT", abort);
+  signals.once("SIGTERM", abort);
+  let exitCode = 0;
+  const output = (command) => command.exitOverride().configureHelp({
+    styleTitle: helpColors.bold,
+    styleCommandText: helpColors.cyan,
+    styleSubcommandText: helpColors.cyan,
+    styleOptionText: helpColors.cyan,
+    styleArgumentText: helpColors.yellow
+  }).configureOutput({
+    getOutHasColors: () => helpColors.isColorSupported,
+    getErrHasColors: () => colors.isColorSupported,
+    writeOut: (value) => io.stdout.write(value),
+    writeErr: (value) => io.stderr.write(value),
+    outputError: (value) => diagnostics.error({
+      code: "INVALID_INPUT",
+      message: value.replace(/^error: /, "")
+    })
+  });
+  try {
+    while (argv[0] === "--no-color") argv = argv.slice(1);
+    if (argv[0] === "help" && CAPABILITIES.includes(argv[1]))
+      argv = [argv[1], "--help", ...argv.slice(2)];
+    const root = output(new Command("web")).description(
+      "Webfox: search, extract pages, answer questions, and research with your chosen provider."
+    ).version(PACKAGE_VERSION, "--version").helpCommand(false);
+    root.addHelpText(
+      "after",
+      [
+        `
+${helpColors.bold("Examples:")}`,
+        `  ${helpColors.cyan("web search")} ${helpColors.yellow('"Node.js release notes"')} ${helpColors.cyan("--provider")} ${helpColors.yellow("brave")}`,
+        `  ${helpColors.cyan("web config default")} ${helpColors.yellow("search brave")}`,
+        `  ${helpColors.cyan("web search --help")}`,
+        `  ${helpColors.cyan("web search --provider")} ${helpColors.yellow("brave")} ${helpColors.cyan("--help")}`
+      ].join("\n")
+    );
+    for (const capability of CAPABILITIES) {
+      const command = root.command(capability).description(summaries[capability]).argument(
+        capability === "research" ? "[brief]" : capability === "contents" ? "[urls...]" : "[queries...]"
+      ).allowExcessArguments(false).helpOption(false);
+      addControls(command, capability);
+      command.addOption(new Option("-h, --help", "Show help"));
+      if (argv[0] !== capability) continue;
+      const route = output(new Command()).allowUnknownOption(true).helpOption(false);
+      addControls(route, capability);
+      route.addOption(new Option("-h, --help"));
+      route.parseOptions(argv.slice(1));
+      const controls = route.opts();
+      const cwd = resolve(io.cwd, controls.cwd ?? ".");
+      const help = controls.help;
+      const client = help && !controls.provider ? void 0 : createWebfox({
+        configPath: controls.config && resolve(io.cwd, controls.config),
+        cwd,
+        env: io.env
+      });
+      const inspection = client?.inspectCapability(
+        capability,
+        controls.provider
+      );
+      const flags = inspection?.optionSchema ? buildOptionFlags(inspection.optionSchema) : [];
+      for (const flag of flags)
+        addProviderOption(command, flag, !controls.provider && !!help);
+      command.addHelpText("after", capabilityHelp(capability, helpColors));
+      if (help) {
+        command.action(() => command.outputHelp());
+      } else
+        command.action(async function() {
+          const parsed = this.opts();
+          const values = this.processedArgs.flatMap(
+            (value) => Array.isArray(value) ? value : value === void 0 ? [] : [String(value)]
+          );
+          const inputs = await readInputs(
+            capability,
+            values,
+            io.stdin,
+            controller.signal
+          );
+          const providerOptions = await readOptions(parsed.optionsJson, cwd);
+          for (const flag of flags) {
+            const option = this.options.find(
+              (option2) => option2.long === flag.flag
+            );
+            if (this.getOptionValueSource(option.attributeName()) === "cli")
+              setPath(
+                providerOptions,
+                flag.path,
+                this.getOptionValue(option.attributeName())
+              );
+          }
+          const request = {
+            provider: inspection?.provider,
+            options: providerOptions,
+            timeoutMs: parsed.timeout,
+            signal: controller.signal,
+            onProgress: parsed.quiet ? void 0 : (event) => {
+              if (!event.state) diagnostics.progress(event.message);
+            }
+          };
+          const startedAt = Date.now();
+          const result = capability === "search" ? await client.search({
+            ...request,
+            queries: inputs,
+            maxResults: parsed.maxResults
+          }) : capability === "contents" ? await client.contents({ ...request, urls: inputs }) : capability === "answer" ? await client.answer({ ...request, queries: inputs }) : await client.research({ ...request, input: inputs[0] });
+          for (const entry of result.results) {
+            if (!entry.ok) diagnostics.error(entry.error, entry.input);
+            else if (!parsed.quiet)
+              diagnostics.success(
+                capability === "research" ? `Research via ${client.getProvider(result.provider).label} completed in ${formatDuration(Date.now() - startedAt)}.` : entry.input
+              );
+          }
+          const rendered = parsed.format === "json" ? JSON.stringify(result) : renderTextDocument(result, { includeErrors: false });
+          if (rendered) io.stdout.write(`${rendered}
+`);
+          exitCode = result.results.some(
+            (entry) => !entry.ok && entry.error.code === "CANCELLED"
+          ) ? 130 : result.status === "partial" ? 1 : 0;
+        });
+    }
+    root.command("providers").description(
+      "Inspect supported, configured, and selected capabilities (not verified)"
+    ).argument("[id]").option("--config <path>", "Advanced: read this configuration file").action((id, controls) => {
+      const client = createWebfox({
+        configPath: controls.config && resolve(io.cwd, controls.config),
+        cwd: io.cwd,
+        env: io.env
+      });
+      const entries = id ? [client.getProvider(parseProvider(id))] : client.listProviders().filter(
+        (entry) => entry.id !== "custom" || entry.configured.length > 0 || entry.selectedDefaults.length > 0
+      );
+      const rows = [
+        ["", "Provider", ...CAPABILITIES],
+        ...entries.map((entry) => [
+          entry.configured.length > 0 ? "\u2605" : "\u2606",
+          entry.id,
+          ...CAPABILITIES.map(
+            (capability) => entry.selectedDefaults.includes(capability) ? "\u25C9" : (entry.id === "custom" ? entry.configured : entry.capabilities).includes(capability) ? "\u2714\uFE0E" : "\u2718\uFE0E"
+          )
+        ])
+      ];
+      const width = (value) => value.replaceAll("\uFE0E", "").length;
+      const widths = rows[0].map(
+        (_, index) => Math.max(...rows.map((row) => width(row[index])))
+      );
+      io.stdout.write(
+        rows.map(
+          (row, rowIndex) => row.map((value, i) => {
+            const left = rowIndex > 0 && i > 1 ? Math.floor((widths[i] - width(value)) / 2) : 0;
+            const padded = " ".repeat(left) + value + (i === row.length - 1 ? "" : " ".repeat(widths[i] - left - width(value)));
+            if (rowIndex === 0) return helpColors.bold(padded);
+            return padded.replace("\u2714\uFE0E", helpColors.green("\u2714\uFE0E")).replace("\u2718\uFE0E", helpColors.dim("\u2718\uFE0E")).replace("\u25C9", helpColors.cyan("\u25C9")).replace("\u2605", helpColors.yellow("\u2605")).replace("\u2606", helpColors.dim("\u2606"));
+          }).join("  ").trimEnd()
+        ).join("\n") + "\n\n\u2606 Unconfigured  \u2605 Configured  \u2714\uFE0E Supported  \u2718\uFE0E Unsupported  \u25C9 Selected default\n"
+      );
+      if (id) {
+        const entry = entries[0];
+        if (entry.id === "custom") {
+          io.stdout.write(
+            "\nConfigure providers.custom.commands.<capability>.argv with the executable and arguments for each capability. Only configured commands are marked supported; \u25C9 marks selection independently.\n"
+          );
+        }
+        io.stdout.write(
+          `
+${entry.docsUrl}
+${entry.credentials.map((c) => `${c.name}: ${c.environmentVariable}${c.optional ? " (optional)" : ""}`).join("\n")}
+`
+        );
+        for (const [key, env] of Object.entries(
+          entry.configurationRequirements
+        ))
+          io.stdout.write(`${key}: ${env}
+`);
+        for (const capability of entry.capabilities)
+          io.stdout.write(
+            `
+${capability} defaults: ${JSON.stringify(client.inspectCapability(capability, entry.id).defaults)}
+Options: web ${capability} --provider ${entry.id} --help
+`
+          );
+      }
+    });
+    const config = root.command("config").description("Save provider choices or inspect YAML configuration");
+    config.command("default").description("Save one capability\u2019s provider choice").argument("<capability>").argument("<provider>").option("--config <path>", "Advanced: update this configuration file").action(
+      async (capability, provider, controls) => {
+        await setCapabilityDefault(
+          capability,
+          parseProvider(provider),
+          { configPath: controls.config, cwd: io.cwd, env: io.env }
+        );
+        diagnostics.success(`Saved ${capability} default: ${provider}`);
+      }
+    );
+    for (const action of ["path", "show", "validate"])
+      config.command(action).description(
+        {
+          path: "Print the configuration path",
+          show: "Show configuration with secrets redacted",
+          validate: "Validate without credentials or network requests"
+        }[action]
+      ).option("--config <path>", "Use this configuration file").action(async (controls) => {
+        const options = {
+          configPath: controls.config,
+          cwd: io.cwd,
+          env: io.env
+        };
+        if (action === "path")
+          io.stdout.write(`${resolveConfigPath(options)}
+`);
+        else {
+          const value = await loadConfig(options);
+          if (action === "show")
+            io.stdout.write(stringify(redactConfig(value)));
+          else {
+            validateConfiguredOptions(value);
+            diagnostics.success(
+              "Configuration is valid. Credentials and connectivity have not been verified."
+            );
+          }
+        }
+      });
+    config.action(() => config.outputHelp());
+    if (!argv.length) {
+      root.outputHelp();
+      return 0;
+    }
+    await root.parseAsync(argv, { from: "user" });
+    return exitCode;
+  } catch (error) {
+    if (error instanceof CommanderError && !(error instanceof InvalidArgumentError2))
+      return error.exitCode === 0 ? 0 : 2;
+    const normalized = error instanceof WebfoxError ? error : new WebfoxError(
+      "INVALID_INPUT",
+      error instanceof Error ? error.message : String(error)
+    );
+    diagnostics.error(normalized);
+    return normalized.code === "CANCELLED" ? 130 : ["INVALID_INPUT", "INVALID_CONFIG"].includes(normalized.code) ? 2 : 1;
+  } finally {
+    signals.removeListener("SIGINT", abort);
+    signals.removeListener("SIGTERM", abort);
+  }
+}
+function addControls(command, capability) {
+  command.addOption(
+    new Option(
+      "--provider <id>",
+      `Override the saved ${capability} provider`
+    ).argParser(parseProvider)
+  );
+  if (capability === "search")
+    command.addOption(
+      new Option("--max-results <n>", "Maximum results per query").argParser(
+        (value) => positiveInteger(value, "--max-results")
+      )
+    );
+  command.addOption(
+    new Option("--format <text|json>", "Result format (text even when piped)").choices(["text", "json"]).default("text")
+  );
+  command.addOption(
+    new Option(
+      "--timeout <duration>",
+      "Overall deadline including retries (30s, 20m)"
+    ).argParser(parseDuration)
+  );
+  command.option("--quiet", "Suppress progress and success notices on stderr");
+  command.addOption(new Option("--no-color", "Disable terminal colors"));
+  command.addOption(
+    new Option("--config <path>", "Read this YAML configuration file")
+  );
+  command.addOption(
+    new Option(
+      "--cwd <path>",
+      "Working directory for custom providers and option files"
+    )
+  );
+  command.addOption(
+    new Option(
+      "--options-json <json|@file>",
+      "Complex provider options; typed flags take precedence"
+    )
+  );
+}
+function addProviderOption(command, flag, hidden) {
+  const description = `${flag.description ?? flag.path.join(".")}${flag.enumValues ? ` (${flag.enumValues.join(" | ")})` : ""}`;
+  const option = new Option(
+    flag.kind === "boolean" ? flag.flag : `${flag.flag} <value>`,
+    description
+  ).helpGroup("Provider options").hideHelp(hidden);
+  if (flag.kind === "array")
+    option.argParser((value, previous = []) => [
+      ...previous,
+      parseTypedValue(value, flag)
+    ]);
+  else if (flag.kind !== "boolean")
+    option.argParser((value) => parseTypedValue(value, flag));
+  command.addOption(option);
+  if (flag.negativeFlag)
+    command.addOption(
+      new Option(flag.negativeFlag, `Disable ${flag.path.join(".")}`).helpGroup("Provider options").hideHelp(hidden)
+    );
+}
+function capabilityHelp(capability, colors) {
+  const examples = {
+    search: {
+      input: '"Node.js cancellation" "Bun cancellation"',
+      provider: "brave"
+    },
+    contents: { input: "https://example.com", provider: "tavily" },
+    answer: { input: '"What is MCP?" "What is A2A?"', provider: "openai" },
+    research: { input: '"Compare databases"', provider: "gemini" }
+  };
+  const { input, provider } = examples[capability];
+  const command = colors.cyan(`web ${capability}`);
+  const providerFlag = `${colors.cyan("--provider")} ${colors.yellow(provider)}`;
+  return [
+    "",
+    capability === "contents" ? "Omit URLs to read newline-separated URLs from piped or redirected stdin." : capability === "research" ? "Provide exactly one brief, or omit it to read piped or redirected stdin." : "Quote each independent input (up to ten), or omit inputs to read piped or redirected stdin.",
+    "Results preserve input order. Progress and errors go to stderr.",
+    "",
+    colors.bold("Examples:"),
+    `  ${command} ${colors.yellow(input)} ${providerFlag}${capability === "research" ? ` ${colors.cyan("--timeout")} ${colors.yellow("20m")}` : ""}`,
+    `  ${command} ${providerFlag} ${colors.cyan("--help")}`
+  ].join("\n");
+}
+function parseDuration(value) {
+  const match = /^(\d+(?:\.\d+)?)(ms|s|m|h)$/.exec(value);
+  const ms = match ? Number(match[1]) * { ms: 1, s: 1e3, m: 6e4, h: 36e5 }[match[2]] : NaN;
+  if (!Number.isSafeInteger(ms) || ms < 1 || ms > 2147483647)
+    throw new InvalidArgumentError2(
+      "Use a positive duration with ms, s, m, or h (for example 30s or 20m)."
+    );
+  return ms;
+}
+function positiveInteger(value, flag) {
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed < 1)
+    throw new InvalidArgumentError2(`${flag} requires a positive integer`);
+  return parsed;
+}
+function parseProvider(value) {
+  if (!PROVIDER_IDS.includes(value))
+    throw new InvalidArgumentError2(
+      `Unknown provider '${value}'. See web providers.`
+    );
+  return value;
+}
+async function readInputs(capability, inputs, stdin, signal) {
+  if (!inputs.length && stdin.isTTY || capability === "research" && inputs.length > 1)
+    throw new WebfoxError(
+      "INVALID_INPUT",
+      `${capability} requires ${capability === "research" ? "exactly one brief" : "one or more inputs"}. Supply arguments or pipe input to stdin.`
+    );
+  if (inputs.length && !inputs.includes("-")) return inputs;
+  if (inputs.includes("-") && inputs.length !== 1)
+    throw new WebfoxError("INVALID_INPUT", "Use '-' by itself for stdin.");
+  const text = await new Promise((resolvePromise, reject) => {
+    let text2 = "";
+    const cleanup = () => {
+      stdin.removeListener("data", data);
+      stdin.removeListener("end", end);
+      stdin.removeListener("error", error);
+      signal.removeEventListener("abort", abort);
+    };
+    const data = (chunk) => {
+      text2 += chunk;
+    };
+    const end = () => {
+      cleanup();
+      resolvePromise(text2.trim());
+    };
+    const error = (error2) => {
+      cleanup();
+      reject(error2);
+    };
+    const abort = () => {
+      cleanup();
+      stdin.pause();
+      reject(signal.reason);
+    };
+    if (signal.aborted) {
+      abort();
+      return;
+    }
+    if (stdin.readableEnded) {
+      end();
+      return;
+    }
+    stdin.setEncoding?.("utf8");
+    stdin.on("data", data);
+    stdin.once("end", end);
+    stdin.once("error", error);
+    signal.addEventListener("abort", abort, { once: true });
+  });
+  if (!text)
+    throw new WebfoxError(
+      "INVALID_INPUT",
+      "Stdin must contain non-empty input."
+    );
+  return capability === "contents" ? text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean) : [text];
+}
+async function readOptions(value, cwd) {
+  if (!value) return {};
+  try {
+    const parsed = JSON.parse(
+      value.startsWith("@") ? await readFile(resolve(cwd, value.slice(1)), "utf8") : value
+    );
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+      throw new Error();
+    return parsed;
+  } catch {
+    throw new WebfoxError(
+      "INVALID_INPUT",
+      "--options-json must contain a JSON object or name a readable @file."
+    );
+  }
+}
+var invokedPath = process.argv[1] ? pathToFileURL(realpathSync(resolve(process.argv[1]))).href : void 0;
+if (invokedPath === import.meta.url)
+  process.exitCode = await runCli(process.argv.slice(2));
+export {
+  buildOptionFlags,
+  parseDuration,
+  runCli
+};