webfox 0.0.0-test.0 → 4.0.0

package/dist/chunk-SMF5ALX7.js

@@ -0,0 +1,762 @@
+import {
+  deadline,
+  orderedMap,
+  sleep,
+  withSignal
+} from "./chunk-WCTOYZVB.js";
+import {
+  configurationSchema,
+  effectiveOptions,
+  optionSchema,
+  providers,
+  selectProvider,
+  validateConfiguredOptions
+} from "./chunk-L425U55P.js";
+import {
+  cancelProcessGroup,
+  killProcessGroup
+} from "./chunk-ZVTVERW5.js";
+import {
+  CAPABILITIES
+} from "./chunk-G2YAQEET.js";
+import {
+  WebfoxError,
+  asWebfoxError
+} from "./chunk-U4BLULLV.js";
+
+// src/application.ts
+import { resolve as resolve3 } from "node:path";
+
+// src/configuration/file.ts
+import { readFile } from "node:fs/promises";
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { parseDocument, visit, isAlias, isMap, isScalar } from "yaml";
+import { Check, Errors } from "typebox/value";
+function resolveConfigPath(options = {}) {
+  const env = options.env ?? process.env;
+  const cwd = options.cwd ?? process.cwd();
+  if (options.configPath) return resolve(cwd, options.configPath);
+  if (env.WEBFOX_CONFIG) return resolve(cwd, env.WEBFOX_CONFIG);
+  if ((options.platform ?? process.platform) === "win32" && env.APPDATA)
+    return join(env.APPDATA, "webfox", "config.yaml");
+  return join(
+    env.XDG_CONFIG_HOME ?? join(options.home ?? homedir(), ".config"),
+    "webfox",
+    "config.yaml"
+  );
+}
+async function loadConfig(options = {}) {
+  const path = resolveConfigPath(options);
+  try {
+    return parseConfig(await readFile(path, "utf8"), path);
+  } catch (error) {
+    return readFailure(error, options, path);
+  }
+}
+function loadConfigSync(options = {}) {
+  const path = resolveConfigPath(options);
+  try {
+    return parseConfig(readFileSync(path, "utf8"), path);
+  } catch (error) {
+    return readFailure(error, options, path);
+  }
+}
+function readFailure(error, options, path) {
+  if (error.code === "ENOENT" && !options.configPath && !(options.env ?? process.env).WEBFOX_CONFIG)
+    return {};
+  if (error instanceof WebfoxError) throw error;
+  throw new WebfoxError(
+    "INVALID_CONFIG",
+    `Could not read configuration: ${path}. Check the path and file permissions.`
+  );
+}
+function parseConfigDocument(text, source = "config.yaml") {
+  try {
+    const document = parseDocument(text, { version: "1.2", schema: "core" });
+    if (document.errors.length || document.warnings.length || document.directives?.yaml.version !== "1.2")
+      throw new Error("Invalid YAML 1.2");
+    visit(document, (_key, node) => {
+      if (isAlias(node) || node && typeof node === "object" && "tag" in node && node.tag)
+        throw new Error("Aliases and explicit tags are not supported");
+      if (isMap(node) && node.items.some(
+        ({ key }) => !isScalar(key) || typeof key.value !== "string"
+      ))
+        throw new Error("Mapping keys must be strings");
+      if (isScalar(node) && typeof node.value === "number" && !Number.isFinite(node.value))
+        throw new Error("Numbers must be finite");
+    });
+    return document;
+  } catch {
+    throw new WebfoxError(
+      "INVALID_CONFIG",
+      `Invalid YAML in ${source}. Use one YAML 1.2 document with unique keys, with string keys and finite numbers, without aliases or explicit tags.`
+    );
+  }
+}
+function parseConfig(text, source = "config.yaml") {
+  const document = parseConfigDocument(text, source);
+  return validateConfig(
+    document.contents === null ? {} : document.toJS({ maxAliasCount: 0 }),
+    source
+  );
+}
+function validateConfig(value, source = "configuration") {
+  const schema = configurationSchema;
+  if (!Check(schema, value)) {
+    const detail = Errors(schema, value).slice(0, 3).map((error) => `${error.instancePath || "/"}: ${error.message}`).join("; ");
+    throw new WebfoxError(
+      "INVALID_CONFIG",
+      `Invalid ${source}: ${detail}. Provider options belong under providers.<id>.options.<capability>.`
+    );
+  }
+  return structuredClone(value);
+}
+function redactConfig(config) {
+  const visit2 = (entry) => {
+    if (Array.isArray(entry)) return entry.map(visit2);
+    if (!entry || typeof entry !== "object") return entry;
+    if ("value" in entry) return { value: "[redacted]" };
+    if ("command" in entry) return { command: ["[redacted]"] };
+    return Object.fromEntries(
+      Object.entries(entry).map(([key, child]) => [key, visit2(child)])
+    );
+  };
+  return visit2(config);
+}
+
+// src/runtime/credentials.ts
+import { spawn } from "node:child_process";
+import { resolve as resolve2 } from "node:path";
+var CredentialResolver = class {
+  constructor(cwd, env) {
+    this.cwd = cwd;
+    this.env = env;
+  }
+  cwd;
+  env;
+  cache = /* @__PURE__ */ new Map();
+  async prepare(definition, stored, capability, signal, outward) {
+    const {
+      credentials: sources,
+      commands,
+      options: _options,
+      accountId,
+      ...settings
+    } = stored ?? {};
+    const credentials = {};
+    for (const requirement of definition.credentials) {
+      if (requirement.capabilities && !requirement.capabilities.includes(capability))
+        continue;
+      const source = sources?.[requirement.name] ?? {
+        env: requirement.environmentVariable
+      };
+      const value = await this.resolve(source, signal, outward);
+      if (!value && !requirement.optional) {
+        throw new WebfoxError(
+          "PROVIDER_UNAVAILABLE",
+          `${definition.label} ${capability} needs a credential. Set ${"env" in source ? source.env : `providers.${definition.id}.credentials.${requirement.name}`} and try again.`
+        );
+      }
+      if (value) credentials[requirement.name] = value;
+    }
+    const extra = {};
+    for (const [key, fallback] of Object.entries(
+      definition.credentialDefaults
+    )) {
+      const value = await this.resolve(
+        key === "accountId" ? accountId ?? fallback : fallback,
+        signal,
+        outward
+      );
+      if (!value)
+        throw new WebfoxError(
+          "PROVIDER_UNAVAILABLE",
+          `${definition.label} requires ${key}. Set ${"env" in fallback ? fallback.env : key} and try again.`
+        );
+      extra[key] = value;
+    }
+    const command = commands?.[capability];
+    if (definition.fields.includes("commands") && !command)
+      throw new WebfoxError(
+        "PROVIDER_UNAVAILABLE",
+        `Configure providers.${definition.id}.commands.${capability}.argv before executing ${capability}.`
+      );
+    const resolvedCommands = command ? {
+      [capability]: {
+        ...command,
+        cwd: resolve2(this.cwd, command.cwd ?? "."),
+        env: await this.resolveMap(command.env, signal, outward)
+      }
+    } : void 0;
+    return {
+      ...settings,
+      ...extra,
+      credentials,
+      ...resolvedCommands ? { commands: resolvedCommands } : {}
+    };
+  }
+  async resolveMap(sources, signal, outward) {
+    const result = {};
+    for (const [key, source] of Object.entries(sources ?? {})) {
+      const value = await this.resolve(source, signal, outward);
+      if (value !== void 0) result[key] = value;
+    }
+    return result;
+  }
+  async resolve(source, signal, outward) {
+    signal.throwIfAborted();
+    let value;
+    if ("value" in source) value = source.value;
+    else if ("env" in source) value = this.env[source.env];
+    else {
+      const key = JSON.stringify(source.command);
+      value = this.cache.get(key);
+      if (value === void 0) {
+        value = await credentialCommand(
+          source.command,
+          this.cwd,
+          this.env,
+          signal
+        );
+        this.cache.set(key, value);
+      }
+    }
+    if (value) outward.addSecret(value);
+    return value;
+  }
+};
+function credentialCommand(argv, cwd, env, signal) {
+  signal.throwIfAborted();
+  return new Promise((resolvePromise, reject) => {
+    const child = spawn(argv[0], argv.slice(1), {
+      cwd,
+      env,
+      detached: process.platform !== "win32",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    let output = "";
+    const abort = () => {
+      cancelProcessGroup(child);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      output += chunk;
+      if (Buffer.byteLength(output) > 64 * 1024) {
+        killProcessGroup(child, "SIGKILL");
+        reject(
+          new WebfoxError(
+            "INVALID_CONFIG",
+            "Credential command output exceeded 64 KiB. Return only the credential."
+          )
+        );
+      }
+    });
+    child.on(
+      "error",
+      () => reject(
+        new WebfoxError(
+          "INVALID_CONFIG",
+          "Could not start credential command. Check its executable and working directory."
+        )
+      )
+    );
+    child.on("close", (code) => {
+      signal.removeEventListener("abort", abort);
+      if (signal.aborted) reject(signal.reason);
+      else if (code !== 0)
+        reject(
+          new WebfoxError(
+            "INVALID_CONFIG",
+            `Credential command failed (exit ${code}). Check the credential command independently.`
+          )
+        );
+      else resolvePromise(output.trim());
+    });
+  });
+}
+
+// src/runtime/outward.ts
+var OutwardBoundary = class {
+  secrets = /* @__PURE__ */ new Set();
+  addSecret(secret) {
+    if (secret) this.secrets.add(secret);
+  }
+  text(value) {
+    return [...this.secrets].sort((a, b) => b.length - a.length).reduce((text, secret) => text.split(secret).join("[redacted]"), value);
+  }
+  value(value) {
+    const seen = /* @__PURE__ */ new WeakSet();
+    const visit2 = (entry) => {
+      if (typeof entry === "string") return this.text(entry);
+      if (!entry || typeof entry !== "object") return entry;
+      if (seen.has(entry)) return "[Circular]";
+      seen.add(entry);
+      const result = Array.isArray(entry) ? entry.map(visit2) : Object.fromEntries(
+        Object.entries(entry).map(([key, child]) => [
+          this.text(key),
+          /authorization|api[-_]?key|token|credential|password|secret|headers?/i.test(
+            key
+          ) ? "[redacted]" : visit2(child)
+        ])
+      );
+      seen.delete(entry);
+      return result;
+    };
+    return visit2(value);
+  }
+  error(error) {
+    return this.value(asWebfoxError(error).toJSON());
+  }
+  exception(error) {
+    const safe = this.error(error);
+    return new WebfoxError(safe.code, safe.message, {
+      retryable: safe.retryable
+    });
+  }
+};
+
+// src/runtime/execute.ts
+var ExecutionRuntime = class {
+  constructor(cwd, env) {
+    this.cwd = cwd;
+    this.env = env;
+    this.credentials = new CredentialResolver(cwd, env);
+  }
+  cwd;
+  env;
+  credentials;
+  async execute(plan, request) {
+    const { capability, definition, inputs } = plan;
+    const timeoutMs = request.timeoutMs ?? (capability === "research" ? plan.policy.researchTimeoutMs ?? 18e5 : plan.policy.timeoutMs ?? 3e4);
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs <= 0 || timeoutMs > 2147483647)
+      throw new WebfoxError(
+        "INVALID_INPUT",
+        "timeoutMs must be a positive integer no larger than 2147483647."
+      );
+    const scope = deadline(timeoutMs, request.signal);
+    const outward = new OutwardBoundary();
+    let active = true;
+    const notify = (event) => {
+      if (!active) return;
+      try {
+        request.onProgress?.(outward.value(event));
+      } catch {
+      }
+    };
+    const inputState = (input, inputIndex, state) => notify({
+      capability,
+      provider: definition.id,
+      message: `${state}: ${input}`,
+      input,
+      inputIndex,
+      state
+    });
+    const context = {
+      cwd: this.cwd,
+      env: this.env,
+      signal: scope.signal,
+      retryPolicy: {
+        retries: plan.policy.retries ?? 0,
+        delayMs: plan.policy.retryDelayMs ?? 2e3
+      },
+      onProgress: (message) => {
+        if (!scope.signal.aborted)
+          notify({ capability, provider: definition.id, message });
+      }
+    };
+    const fail = (input, error) => ({
+      input,
+      ok: false,
+      error: outward.error(scope.signal.aborted ? scope.signal.reason : error)
+    });
+    try {
+      scope.signal.throwIfAborted();
+      const config = await this.credentials.prepare(
+        definition,
+        plan.stored,
+        capability,
+        scope.signal,
+        outward
+      );
+      const adapter = await withSignal(
+        definition.load(),
+        scope.signal
+      );
+      const run = async (input) => {
+        try {
+          if (capability === "contents") {
+            const response = await this.run(
+              adapter,
+              config,
+              {
+                capability: "contents",
+                urls: [input],
+                options: plan.options
+              },
+              plan,
+              context
+            );
+            if (response.answers.length !== 1 || response.answers[0].inputIndex !== 0)
+              throw new WebfoxError(
+                "PROVIDER_FAILURE",
+                "Provider returned missing, duplicate, or invalid contents input indexes."
+              );
+            const answer = response.answers[0];
+            if (answer.error)
+              throw new WebfoxError(answer.error.code, answer.error.message, {
+                retryable: answer.error.retryable
+              });
+            const { inputIndex: _index, error: _error, ...value2 } = answer;
+            return { input, ok: true, value: value2 };
+          }
+          const operation = capability === "search" ? {
+            capability,
+            query: input,
+            maxResults: plan.maxResults,
+            options: plan.options
+          } : capability === "answer" ? { capability, query: input, options: plan.options } : { capability: "research", input, options: plan.options };
+          const result = await this.run(
+            adapter,
+            config,
+            operation,
+            plan,
+            context
+          );
+          const value = capability === "search" ? {
+            results: result.results.slice(
+              0,
+              plan.maxResults
+            )
+          } : textValue(result);
+          return { input, ok: true, value };
+        } catch (error) {
+          return fail(input, error);
+        }
+      };
+      inputs.forEach((input, index) => inputState(input, index, "queued"));
+      const results = await orderedMap(
+        inputs,
+        plan.policy.concurrency ?? 4,
+        async (input, inputIndex) => {
+          if (!scope.signal.aborted) inputState(input, inputIndex, "running");
+          const result = await run(input);
+          inputState(
+            input,
+            inputIndex,
+            result.ok ? "done" : result.error.code === "CANCELLED" ? "cancelled" : "failed"
+          );
+          return result;
+        }
+      );
+      return outward.value({
+        schemaVersion: 1,
+        capability,
+        provider: definition.id,
+        status: results.every((result) => result.ok) ? "ok" : "partial",
+        results
+      });
+    } catch (error) {
+      if (scope.signal.aborted)
+        return outward.value({
+          schemaVersion: 1,
+          capability,
+          provider: definition.id,
+          status: "partial",
+          results: inputs.map((input) => fail(input, error))
+        });
+      throw outward.exception(error);
+    } finally {
+      active = false;
+      scope.dispose();
+    }
+  }
+  async run(adapter, config, request, plan, context) {
+    const execute = adapter[request.capability];
+    if (!execute)
+      throw new WebfoxError(
+        "PROVIDER_UNAVAILABLE",
+        `Provider does not implement ${request.capability}.`
+      );
+    const retries = plan.definition.capabilities[request.capability]?.retrySafe ? context.retryPolicy?.retries ?? 0 : 0;
+    for (let attempt = 0; ; attempt++) {
+      context.signal.throwIfAborted();
+      try {
+        const result = await withSignal(
+          execute(request, config, context),
+          context.signal
+        );
+        if (request.capability === "contents") {
+          const page = result.answers[0];
+          if (page?.error)
+            throw new WebfoxError(page.error.code, page.error.message, {
+              retryable: page.error.retryable
+            });
+        }
+        return result;
+      } catch (error) {
+        if (context.signal.aborted) throw context.signal.reason;
+        const normalized = asWebfoxError(error);
+        if (!normalized.options.retryable || attempt >= retries)
+          throw normalized;
+        const delay = Math.min(
+          (context.retryPolicy?.delayMs ?? 2e3) * 2 ** attempt,
+          3e4
+        );
+        context.onProgress?.(
+          `Retrying ${request.capability} in ${delay}ms (attempt ${attempt + 2}).`
+        );
+        await sleep(delay, context.signal);
+      }
+    }
+  }
+};
+function textValue(value) {
+  return {
+    text: value.text,
+    ...value.itemCount === void 0 ? {} : { itemCount: value.itemCount },
+    ...value.metadata === void 0 ? {} : { metadata: value.metadata }
+  };
+}
+
+// src/application.ts
+function createWebfox(options = {}) {
+  const cwd = resolve3(options.cwd ?? process.cwd());
+  const env = { ...options.env ?? process.env };
+  const config = options.config ? validateConfig(structuredClone(options.config), "createWebfox config") : loadConfigSync({ configPath: options.configPath, env, cwd });
+  validateConfiguredOptions(config);
+  const runtime = new ExecutionRuntime(cwd, env);
+  const outward = new OutwardBoundary();
+  const collect = (value) => {
+    if (!value || typeof value !== "object") return;
+    if ("value" in value && typeof value.value === "string")
+      outward.addSecret(value.value);
+    if ("env" in value && typeof value.env === "string" && env[value.env])
+      outward.addSecret(env[value.env]);
+    for (const child of Object.values(value)) collect(child);
+  };
+  collect(config.providers);
+  for (const definition of Object.values(providers))
+    for (const credential of definition.credentials)
+      if (env[credential.environmentVariable])
+        outward.addSecret(env[credential.environmentVariable]);
+  const configured = (definition, capability) => {
+    const stored = config.providers?.[definition.id];
+    if (!definition.capabilities[capability]) return false;
+    if (definition.fields.includes("commands"))
+      return !!stored?.commands?.[capability];
+    if (definition.credentials.every((c) => c.optional))
+      return !!stored || definition.credentials.some((c) => !!env[c.environmentVariable]);
+    const present = (source) => !!source && typeof source === "object" && ("env" in source ? !!env[String(source.env)] : true);
+    return definition.credentials.filter(
+      (c) => !c.optional && (!c.capabilities || c.capabilities.includes(capability))
+    ).every(
+      (c) => present(
+        stored?.credentials?.[c.name] ?? { env: c.environmentVariable }
+      )
+    ) && Object.entries(definition.credentialDefaults).every(
+      ([key, source]) => present(key === "accountId" ? stored?.accountId ?? source : source)
+    );
+  };
+  const inspectProvider = (definition) => ({
+    id: definition.id,
+    label: definition.label,
+    docsUrl: definition.docsUrl,
+    local: definition.local,
+    configurationRequirements: Object.fromEntries(
+      Object.entries(definition.credentialDefaults).flatMap(
+        ([key, source]) => "env" in source ? [[key, source.env]] : []
+      )
+    ),
+    capabilities: CAPABILITIES.filter((c) => !!definition.capabilities[c]),
+    credentials: structuredClone(definition.credentials),
+    configured: CAPABILITIES.filter((c) => configured(definition, c)),
+    selectedDefaults: CAPABILITIES.filter(
+      (c) => config.defaults?.[c]?.provider === definition.id
+    )
+  });
+  const execute = (capability, inputs, request, maxResults) => {
+    const definition = selectProvider(config, capability, request.provider);
+    const options2 = effectiveOptions(
+      config,
+      definition,
+      capability,
+      request.options
+    );
+    return runtime.execute(
+      {
+        capability,
+        definition,
+        inputs,
+        options: options2,
+        maxResults,
+        stored: config.providers?.[definition.id],
+        policy: config.execution ?? {}
+      },
+      request
+    );
+  };
+  return {
+    async search(request) {
+      const inputs = batch(request.queries, "queries", 10);
+      const maxResults = request.maxResults ?? config.defaults?.search?.maxResults ?? 5;
+      if (!Number.isSafeInteger(maxResults) || maxResults < 1)
+        throw new WebfoxError(
+          "INVALID_INPUT",
+          "maxResults must be a positive integer."
+        );
+      return execute("search", inputs, request, maxResults);
+    },
+    async contents(request) {
+      const urls = batch(request.urls, "urls");
+      for (const url of urls) {
+        try {
+          if (!["http:", "https:"].includes(new URL(url).protocol))
+            throw new Error();
+        } catch {
+          throw new WebfoxError(
+            "INVALID_INPUT",
+            "contents requires HTTP or HTTPS URLs."
+          );
+        }
+      }
+      return execute("contents", urls, request);
+    },
+    async answer(request) {
+      return execute("answer", batch(request.queries, "queries", 10), request);
+    },
+    async research(request) {
+      return execute("research", batch([request.input], "input", 1), request);
+    },
+    listProviders: () => Object.values(providers).map(inspectProvider),
+    getProvider: (id) => Object.hasOwn(providers, id) ? inspectProvider(providers[id]) : void 0,
+    inspectCapability(capability, requested) {
+      const selected = requested ?? config.defaults?.[capability]?.provider;
+      if (!selected)
+        return {
+          capability,
+          configured: false,
+          defaults: {
+            options: {},
+            ...capability === "search" ? { maxResults: config.defaults?.search?.maxResults ?? 5 } : {}
+          }
+        };
+      const definition = selectProvider(config, capability, selected);
+      return outward.value({
+        capability,
+        provider: selected,
+        configured: configured(definition, capability),
+        optionSchema: optionSchema(
+          definition,
+          capability,
+          "defaults"
+        ),
+        defaults: {
+          options: effectiveOptions(
+            config,
+            definition,
+            capability,
+            {},
+            "defaults"
+          ),
+          ...capability === "search" ? { maxResults: config.defaults?.search?.maxResults ?? 5 } : {}
+        }
+      });
+    }
+  };
+}
+function batch(values, name, max = Infinity) {
+  if (!Array.isArray(values) || values.length === 0 || values.length > max)
+    throw new WebfoxError(
+      "INVALID_INPUT",
+      `${name} requires ${max === Infinity ? "one or more inputs" : `between 1 and ${max} inputs`}.`
+    );
+  return values.map((value) => {
+    if (typeof value !== "string" || !value.trim())
+      throw new WebfoxError(
+        "INVALID_INPUT",
+        `${name} must contain non-empty strings.`
+      );
+    return value.trim();
+  });
+}
+
+// src/configuration/defaults.ts
+import { readFile as readFile2, mkdir, writeFile, rename, rm } from "node:fs/promises";
+import { dirname } from "node:path";
+import { randomUUID } from "node:crypto";
+var updates = /* @__PURE__ */ new Map();
+async function setCapabilityDefault(capability, provider, options = {}) {
+  if (!CAPABILITIES.includes(capability))
+    throw new WebfoxError(
+      "INVALID_INPUT",
+      `Unknown capability '${capability}'. Choose ${CAPABILITIES.join(", ")}.`
+    );
+  try {
+    selectProvider({}, capability, provider);
+  } catch (error) {
+    throw new WebfoxError(
+      "INVALID_INPUT",
+      error instanceof WebfoxError ? error.message : "Invalid provider selection."
+    );
+  }
+  const path = resolveConfigPath(options);
+  const previous = updates.get(path) ?? Promise.resolve();
+  const operation = previous.catch(() => {
+  }).then(async () => {
+    let config = {};
+    let text = "";
+    try {
+      text = await readFile2(path, "utf8");
+      config = parseConfig(text, path);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    config.defaults = {
+      ...config.defaults,
+      [capability]: { ...config.defaults?.[capability], provider }
+    };
+    validateConfiguredOptions(config);
+    const document = parseConfigDocument(text, path);
+    document.setIn(["defaults", capability, "provider"], provider);
+    const serialized = document.toString();
+    parseConfig(serialized, path);
+    await mkdir(dirname(path), { recursive: true });
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+      await writeFile(temporary, serialized, {
+        mode: 384,
+        flag: "wx"
+      });
+      await rename(temporary, path);
+    } finally {
+      await rm(temporary, { force: true });
+    }
+    return path;
+  });
+  updates.set(path, operation);
+  try {
+    return await operation;
+  } catch (error) {
+    if (error instanceof WebfoxError) throw error;
+    throw new WebfoxError(
+      "INVALID_CONFIG",
+      `Could not save provider default to ${path}. Check the path and file permissions.`
+    );
+  } finally {
+    if (updates.get(path) === operation) updates.delete(path);
+  }
+}
+
+export {
+  resolveConfigPath,
+  loadConfig,
+  parseConfig,
+  validateConfig,
+  redactConfig,
+  createWebfox,
+  setCapabilityDefault
+};