perplexity-user-mcp 0.8.36

package/dist/checks/vault.mjs

@@ -0,0 +1,90 @@
+import "../chunk-4UEJOM6W.mjs";
+
+// src/checks/vault.js
+import { existsSync } from "fs";
+import { join } from "path";
+var CATEGORY = "vault";
+async function tryKeychain() {
+  try {
+    const mod = await import("keytar");
+    const keytar = mod.default ?? mod;
+    const hex = await keytar.getPassword("perplexity-user-mcp", "vault-master-key");
+    return { available: true, hasKey: !!hex };
+  } catch {
+    return { available: false, hasKey: false };
+  }
+}
+function keychainExpected() {
+  return process.platform === "win32" || process.platform === "darwin" || process.platform === "linux" && !process.env.CI;
+}
+async function run(opts = {}) {
+  const results = [];
+  const dir = opts.configDir;
+  const profile = opts.profile ?? "default";
+  const enc = join(dir, "profiles", profile, "vault.enc");
+  const plain = join(dir, "profiles", profile, "vault.json");
+  const envPass = process.env.PERPLEXITY_VAULT_PASSPHRASE;
+  const kc = await tryKeychain();
+  if (existsSync(plain)) {
+    results.push({
+      category: CATEGORY,
+      name: "encryption",
+      status: "warn",
+      message: "plaintext vault.json (security.encryptCookies=false)",
+      hint: "Re-run login without --plain-cookies to enable AES-256-GCM at rest."
+    });
+  } else if (existsSync(enc)) {
+    results.push({ category: CATEGORY, name: "encryption", status: "pass", message: "AES-256-GCM (vault.enc)" });
+  } else {
+    results.push({ category: CATEGORY, name: "encryption", status: "skip", message: "no vault yet" });
+  }
+  if (kc.hasKey) {
+    results.push({ category: CATEGORY, name: "unseal-path", status: "pass", message: "OS keychain holds master key" });
+    if (envPass) {
+      results.push({
+        category: CATEGORY,
+        name: "keychain-preferred",
+        status: "warn",
+        message: "PERPLEXITY_VAULT_PASSPHRASE is also set \u2014 keychain wins, but consider removing the env var"
+      });
+    }
+  } else if (envPass) {
+    const hasKc = kc.available;
+    results.push({
+      category: CATEGORY,
+      name: "unseal-path",
+      status: "pass",
+      message: `env var ${hasKc ? "(keychain available but empty)" : "(keychain unavailable \u2014 expected on headless Linux)"}`
+    });
+    if (hasKc) {
+      results.push({
+        category: CATEGORY,
+        name: "keychain-preferred",
+        status: "warn",
+        message: "keychain is available \u2014 moving the master key there would remove the passphrase from IDE config files",
+        hint: "Run `npx perplexity-user-mcp login` once with the env var unset; the key will be written to keychain."
+      });
+    } else {
+      results.push({ category: CATEGORY, name: "keychain-preferred", status: "skip", message: "keychain not applicable" });
+    }
+  } else {
+    if (!existsSync(enc) && !existsSync(plain)) {
+      results.push({ category: CATEGORY, name: "unseal-path", status: "skip", message: "no vault to unseal yet" });
+    } else if (existsSync(plain)) {
+      results.push({ category: CATEGORY, name: "unseal-path", status: "pass", message: "plaintext \u2014 no key required" });
+    } else {
+      const ttyLikely = process.stdin?.isTTY === true;
+      results.push({
+        category: CATEGORY,
+        name: "unseal-path",
+        status: ttyLikely ? "warn" : "fail",
+        message: ttyLikely ? "no keychain, no env var \u2014 TTY prompt will be required on next use" : "vault locked: no keychain, no env var, no TTY",
+        hint: keychainExpected() ? "Install libsecret+gnome-keyring (Linux), or set PERPLEXITY_VAULT_PASSPHRASE." : "Set PERPLEXITY_VAULT_PASSPHRASE in your MCP config env."
+      });
+    }
+  }
+  return results;
+}
+export {
+  run
+};

package/dist/chunk-3B276PGG.mjs

@@ -0,0 +1,115 @@
+import {
+  getConfigDir
+} from "./chunk-XKSWCEGI.mjs";
+
+// src/daemon/install-tunnel.ts
+import { createHash } from "crypto";
+import { gunzipSync } from "zlib";
+import { chmodSync, mkdirSync, renameSync, writeFileSync } from "fs";
+import { join } from "path";
+
+// src/daemon/cloudflared-pins.json
+var cloudflared_pins_default = {
+  version: "2026.3.0",
+  assets: {
+    "darwin-arm64": {
+      filename: "cloudflared-darwin-arm64.tgz",
+      sha256: "2aae4f69b0fc1c671b8353b4f594cbd902cd1e360c8eed2b8cad4602cb1546fb"
+    },
+    "darwin-x64": {
+      filename: "cloudflared-darwin-amd64.tgz",
+      sha256: "0f30140c4a5e213d22f951ef4c964cac5fb6a5f061ba6eba5ea932999f7c0394"
+    },
+    "linux-arm64": {
+      filename: "cloudflared-linux-arm64",
+      sha256: "0755ba4cbab59980e6148367fcf53a8f3ec85a97deefd63c2420cf7850769bee"
+    },
+    "linux-x64": {
+      filename: "cloudflared-linux-amd64",
+      sha256: "4a9e50e6d6d798e90fcd01933151a90bf7edd99a0a55c28ad18f2e16263a5c30"
+    },
+    "windows-x64": {
+      filename: "cloudflared-windows-amd64.exe",
+      sha256: "59b12880b24af581cf5b1013db601c7d843b9b097e9c78aa5957c7f39f741885"
+    }
+  }
+};
+
+// src/daemon/install-tunnel.ts
+async function installCloudflared(options = {}) {
+  const configDir = options.configDir ?? getConfigDir();
+  const assetKey = resolvePinnedAssetKey(options.platform ?? process.platform, options.arch ?? process.arch);
+  const asset = cloudflared_pins_default.assets[assetKey];
+  const downloadUrl = `https://github.com/cloudflare/cloudflared/releases/download/${cloudflared_pins_default.version}/${asset.filename}`;
+  const response = await (options.fetchImpl ?? fetch)(downloadUrl);
+  if (!response.ok) {
+    throw new Error(`Failed to download cloudflared (${response.status} ${response.statusText}).`);
+  }
+  const archiveBuffer = Buffer.from(await response.arrayBuffer());
+  const sha256 = createHash("sha256").update(archiveBuffer).digest("hex");
+  if (sha256 !== asset.sha256) {
+    throw new Error(`cloudflared checksum mismatch for ${asset.filename}. Expected ${asset.sha256}, received ${sha256}.`);
+  }
+  const binaryBuffer = asset.filename.endsWith(".tgz") ? extractCloudflaredBinaryFromTarGz(archiveBuffer) : archiveBuffer;
+  const binaryPath = getTunnelBinaryPath(configDir, options.platform ?? process.platform);
+  const tempPath = `${binaryPath}.tmp`;
+  mkdirSync(join(configDir, "bin"), { recursive: true });
+  writeFileSync(tempPath, binaryBuffer, { mode: 493 });
+  renameSync(tempPath, binaryPath);
+  if ((options.platform ?? process.platform) !== "win32") {
+    chmodSync(binaryPath, 493);
+  }
+  return {
+    binaryPath,
+    version: cloudflared_pins_default.version,
+    assetKey,
+    filename: asset.filename,
+    sha256
+  };
+}
+function getPinnedCloudflaredVersion() {
+  return cloudflared_pins_default.version;
+}
+function getTunnelBinaryPath(configDir = getConfigDir(), platform = process.platform) {
+  return join(configDir, "bin", platform === "win32" ? "cloudflared.exe" : "cloudflared");
+}
+function resolvePinnedAssetKey(platform, arch) {
+  if (platform === "darwin" && arch === "arm64") return "darwin-arm64";
+  if (platform === "darwin" && arch === "x64") return "darwin-x64";
+  if (platform === "linux" && arch === "arm64") return "linux-arm64";
+  if (platform === "linux" && arch === "x64") return "linux-x64";
+  if (platform === "win32" && arch === "x64") return "windows-x64";
+  throw new Error(`Unsupported cloudflared platform: ${platform}/${arch}`);
+}
+function extractCloudflaredBinaryFromTarGz(buffer) {
+  const tarBuffer = gunzipSync(buffer);
+  let offset = 0;
+  while (offset + 512 <= tarBuffer.length) {
+    const header = tarBuffer.subarray(offset, offset + 512);
+    if (header.every((value) => value === 0)) {
+      break;
+    }
+    const name = readTarString(header.subarray(0, 100));
+    const sizeText = readTarString(header.subarray(124, 136)).trim();
+    const size = Number.parseInt(sizeText || "0", 8);
+    const dataStart = offset + 512;
+    const dataEnd = dataStart + size;
+    if (name === "cloudflared" || name.endsWith("/cloudflared")) {
+      return tarBuffer.subarray(dataStart, dataEnd);
+    }
+    offset = dataStart + Math.ceil(size / 512) * 512;
+  }
+  throw new Error("Downloaded cloudflared archive did not contain the cloudflared binary.");
+}
+function readTarString(buffer) {
+  const nullIndex = buffer.indexOf(0);
+  const end = nullIndex === -1 ? buffer.length : nullIndex;
+  return buffer.subarray(0, end).toString("utf8");
+}
+
+export {
+  installCloudflared,
+  getPinnedCloudflaredVersion,
+  getTunnelBinaryPath,
+  resolvePinnedAssetKey
+};

package/dist/chunk-4UEJOM6W.mjs

@@ -0,0 +1,9 @@
+var __glob = (map) => (path) => {
+  var fn = map[path];
+  if (fn) return fn();
+  throw new Error("Module not found in bundle: " + path);
+};
+
+export {
+  __glob
+};

package/dist/chunk-6EP2BLTV.mjs

@@ -0,0 +1,205 @@
+import {
+  getConfigDir
+} from "./chunk-XKSWCEGI.mjs";
+
+// src/daemon/lockfile.ts
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+function getLockfilePath(configDir = getConfigDir()) {
+  return join(configDir, "daemon.lock");
+}
+function acquire(record, options = {}) {
+  const lockPath = options.lockPath ?? getLockfilePath();
+  const normalized = normalizeRecord(record);
+  mkdirSync(dirname(lockPath), { recursive: true });
+  for (let attempt = 0; attempt < 2; attempt++) {
+    let fd;
+    try {
+      fd = openSync(lockPath, "wx");
+    } catch (error) {
+      if (isExistsError(error)) {
+        if (attempt === 0 && tryReclaimStale(lockPath)) {
+          continue;
+        }
+        return false;
+      }
+      throw error;
+    }
+    let wrote = false;
+    try {
+      writeFileSync(fd, serialize(normalized), "utf8");
+      wrote = true;
+    } finally {
+      closeSync(fd);
+      if (!wrote) {
+        rmSync(lockPath, { force: true });
+      }
+    }
+    return true;
+  }
+  return false;
+}
+function tryReclaimStale(lockPath) {
+  let existing = null;
+  try {
+    existing = read({ lockPath });
+  } catch {
+    try {
+      rmSync(lockPath, { force: true });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  if (!isStale(existing)) {
+    return false;
+  }
+  try {
+    rmSync(lockPath, { force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function read(options = {}) {
+  const lockPath = options.lockPath ?? getLockfilePath();
+  if (!existsSync(lockPath)) {
+    return null;
+  }
+  const parsed = JSON.parse(readFileSync(lockPath, "utf8"));
+  return normalizeRecord(parsed);
+}
+function release(options = {}) {
+  const lockPath = options.lockPath ?? getLockfilePath();
+  if (!existsSync(lockPath)) {
+    return false;
+  }
+  if (options.expectedUuid) {
+    const current = read({ lockPath });
+    if (!current || current.uuid !== options.expectedUuid) {
+      return false;
+    }
+  }
+  rmSync(lockPath, { force: true });
+  return true;
+}
+function replace(record, options = {}) {
+  const lockPath = options.lockPath ?? getLockfilePath();
+  const normalized = normalizeRecord(record);
+  if (options.expectedUuid) {
+    const current = read({ lockPath });
+    if (!current || current.uuid !== options.expectedUuid) {
+      return false;
+    }
+  }
+  mkdirSync(dirname(lockPath), { recursive: true });
+  const tempPath = `${lockPath}.tmp`;
+  writeFileSync(tempPath, serialize(normalized), "utf8");
+  renameSync(tempPath, lockPath);
+  return true;
+}
+function isStale(record, options = {}) {
+  if (!record) {
+    return true;
+  }
+  if (!Number.isInteger(record.pid) || record.pid <= 0) {
+    return true;
+  }
+  if (!record.uuid || typeof record.uuid !== "string") {
+    return true;
+  }
+  if (options.echoedUuid && options.echoedUuid !== record.uuid) {
+    return true;
+  }
+  return !isProcessAlive(record.pid);
+}
+function normalizeRecord(value) {
+  if (!value || typeof value !== "object") {
+    throw new Error("Daemon lockfile must contain a JSON object.");
+  }
+  const record = value;
+  const pid = asPositiveInteger(record.pid, "pid");
+  const port = asPort(record.port);
+  const uuid = asRequiredString(record.uuid, "uuid");
+  const bearerToken = asRequiredString(record.bearerToken, "bearerToken");
+  const version = asRequiredString(record.version, "version");
+  const startedAt = asRequiredString(record.startedAt, "startedAt");
+  return {
+    pid,
+    port,
+    uuid,
+    bearerToken,
+    version,
+    startedAt,
+    cloudflaredPid: asOptionalInteger(record.cloudflaredPid, "cloudflaredPid"),
+    tunnelUrl: asOptionalString(record.tunnelUrl, "tunnelUrl")
+  };
+}
+function asPositiveInteger(value, name) {
+  if (!Number.isInteger(value) || Number(value) <= 0) {
+    throw new Error(`Daemon lockfile field '${name}' must be a positive integer.`);
+  }
+  return Number(value);
+}
+function asPort(value) {
+  if (!Number.isInteger(value) || Number(value) < 0 || Number(value) > 65535) {
+    throw new Error("Daemon lockfile field 'port' must be an integer between 0 and 65535.");
+  }
+  return Number(value);
+}
+function asRequiredString(value, name) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Daemon lockfile field '${name}' must be a non-empty string.`);
+  }
+  return value;
+}
+function asOptionalInteger(value, name) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === null) {
+    return null;
+  }
+  if (!Number.isInteger(value) || Number(value) <= 0) {
+    throw new Error(`Daemon lockfile field '${name}' must be a positive integer when present.`);
+  }
+  return Number(value);
+}
+function asOptionalString(value, name) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (value === null) {
+    return null;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`Daemon lockfile field '${name}' must be a string when present.`);
+  }
+  return value;
+}
+function serialize(record) {
+  return JSON.stringify(record, null, 2) + "\n";
+}
+function isExistsError(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "EEXIST";
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "EPERM") {
+      return true;
+    }
+    return false;
+  }
+}
+
+export {
+  getLockfilePath,
+  acquire,
+  read,
+  release,
+  replace,
+  isStale
+};

package/dist/chunk-6YMQVLFX.mjs

@@ -0,0 +1,146 @@
+// src/daemon/tunnel.ts
+import { spawn } from "child_process";
+import { createInterface } from "readline";
+import { execFile as execFileCallback } from "child_process";
+import { promisify } from "util";
+import { existsSync, mkdirSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+var execFile = promisify(execFileCallback);
+var NEUTRAL_CONFIG_FILENAME = "quick-tunnel.yml";
+var NEUTRAL_CONFIG_BODY = "# perplexity-user-mcp Quick Tunnel \u2014 routing handled by --url flag.\nno-autoupdate: true\n";
+function ensureNeutralConfig(binaryPath) {
+  try {
+    const configPath = join(dirname(binaryPath), NEUTRAL_CONFIG_FILENAME);
+    if (!existsSync(configPath)) {
+      mkdirSync(dirname(configPath), { recursive: true });
+      writeFileSync(configPath, NEUTRAL_CONFIG_BODY, { encoding: "utf8" });
+    }
+    return configPath;
+  } catch {
+    return null;
+  }
+}
+function startTunnel(options) {
+  const neutralConfigPath = ensureNeutralConfig(options.command);
+  const spawnArgs = [
+    ...options.args ?? [],
+    "tunnel",
+    "--no-autoupdate",
+    ...neutralConfigPath ? ["--config", neutralConfigPath] : [],
+    "--url",
+    `http://127.0.0.1:${options.port}`
+  ];
+  const child = spawn(
+    options.command,
+    spawnArgs,
+    {
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: false,
+      windowsHide: true,
+      env: options.env
+    }
+  );
+  let stopping = false;
+  let settled = false;
+  let resolveExited;
+  const exited = new Promise((resolve) => {
+    resolveExited = resolve;
+  });
+  let state = {
+    status: "starting",
+    url: null,
+    pid: child.pid ?? null,
+    error: null
+  };
+  const updateState = (next) => {
+    state = next;
+    options.onStateChange?.(state);
+  };
+  updateState(state);
+  let resolveReady;
+  let rejectReady;
+  const waitUntilReady = new Promise((resolve, reject) => {
+    resolveReady = resolve;
+    rejectReady = reject;
+  });
+  const handleLine = (line) => {
+    const url = extractTunnelUrl(line);
+    if (!url || settled) {
+      return;
+    }
+    settled = true;
+    updateState({
+      status: "enabled",
+      url,
+      pid: child.pid ?? null,
+      error: null
+    });
+    resolveReady(url);
+  };
+  createInterface({ input: child.stderr }).on("line", handleLine);
+  createInterface({ input: child.stdout }).on("line", handleLine);
+  child.on("error", (error) => {
+    if (!settled) {
+      settled = true;
+      rejectReady(error);
+    }
+    updateState({
+      status: stopping ? "disabled" : "crashed",
+      url: null,
+      pid: child.pid ?? null,
+      error: error.message
+    });
+  });
+  child.on("exit", (code, signal) => {
+    if (!settled) {
+      settled = true;
+      rejectReady(new Error(`cloudflared exited before publishing a tunnel URL (code=${code ?? "null"} signal=${signal ?? "null"}).`));
+    }
+    updateState({
+      status: stopping ? "disabled" : "crashed",
+      url: stopping ? null : state.url,
+      pid: null,
+      error: stopping ? null : `cloudflared exited (code=${code ?? "null"} signal=${signal ?? "null"}).`
+    });
+    resolveExited();
+  });
+  const stop = async () => {
+    if (stopping) {
+      return;
+    }
+    stopping = true;
+    if (child.exitCode !== null || child.killed) {
+      updateState({
+        status: "disabled",
+        url: null,
+        pid: null,
+        error: null
+      });
+      return;
+    }
+    if (process.platform === "win32") {
+      await execFile("taskkill", ["/PID", String(child.pid), "/T", "/F"], {
+        windowsHide: true
+      }).catch(() => void 0);
+      await exited;
+      return;
+    }
+    child.kill("SIGTERM");
+    await exited;
+  };
+  return {
+    pid: child.pid ?? 0,
+    waitUntilReady,
+    stop,
+    getState: () => state
+  };
+}
+function extractTunnelUrl(line) {
+  const match = line.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/iu);
+  return match?.[0] ?? null;
+}
+
+export {
+  startTunnel,
+  extractTunnelUrl
+};

package/dist/chunk-7JL36EBH.mjs

@@ -0,0 +1,118 @@
+import {
+  getConfigDir
+} from "./chunk-XKSWCEGI.mjs";
+import {
+  __glob
+} from "./chunk-4UEJOM6W.mjs";
+
+// import("./checks/**/*.js") in src/doctor.js
+var globImport_checks_js = __glob({
+  "./checks/browser.js": () => import("./checks/browser.mjs"),
+  "./checks/config.js": () => import("./checks/config.mjs"),
+  "./checks/ide.js": () => import("./checks/ide.mjs"),
+  "./checks/mcp.js": () => import("./checks/mcp.mjs"),
+  "./checks/native-deps.js": () => import("./checks/native-deps.mjs"),
+  "./checks/network.js": () => import("./checks/network.mjs"),
+  "./checks/probe.js": () => import("./checks/probe.mjs"),
+  "./checks/profiles.js": () => import("./checks/profiles.mjs"),
+  "./checks/runtime.js": () => import("./checks/runtime.mjs"),
+  "./checks/vault.js": () => import("./checks/vault.mjs")
+});
+
+// src/doctor.js
+var CATEGORIES = [
+  "runtime",
+  "config",
+  "profiles",
+  "vault",
+  "browser",
+  "native-deps",
+  "network",
+  "ide",
+  "mcp",
+  "probe"
+];
+var RANK = { skip: 0, pass: 1, warn: 2, fail: 3 };
+var INV = ["skip", "pass", "warn", "fail"];
+function rollupStatus(statuses) {
+  if (statuses.length === 0) return "skip";
+  const rank = statuses.reduce((acc, s) => Math.max(acc, RANK[s] ?? 0), 0);
+  return INV[rank];
+}
+function exitCodeFor(report) {
+  return report.overall === "fail" ? 10 : 0;
+}
+async function loadCheck(name) {
+  const mod = await globImport_checks_js(`./checks/${name}.js`);
+  return mod.run;
+}
+async function runAll(opts = {}) {
+  const t0 = Date.now();
+  const configDir = opts.configDir ?? getConfigDir();
+  const { getActiveName } = await import("./profiles.mjs");
+  const activeProfile = opts.profile ?? getActiveName() ?? "default";
+  const probe = !!opts.probe;
+  const allProfiles = !!opts.allProfiles;
+  const tasks = CATEGORIES.map(async (cat) => {
+    if (cat === "probe" && !probe && !opts.injected?.[cat]) {
+      return [cat, [{ category: "probe", name: "probe-search", status: "skip", message: "skipped (use --probe to enable)" }]];
+    }
+    if (opts.injected?.[cat]) return [cat, opts.injected[cat]];
+    try {
+      const runFn = await loadCheck(cat);
+      const results = await runFn({
+        configDir,
+        profile: activeProfile,
+        allProfiles,
+        probe,
+        ideStatuses: opts.ideStatuses,
+        baseDir: opts.baseDir
+      });
+      return [cat, results];
+    } catch (err) {
+      return [cat, [{ category: cat, name: `${cat}-runner`, status: "fail", message: `check crashed: ${err.message}` }]];
+    }
+  });
+  const settled = await Promise.all(tasks);
+  const byCategory = {};
+  for (const [cat, checks] of settled) {
+    const rollup = rollupStatus(checks.map((c) => c.status));
+    byCategory[cat] = { status: rollup, checks };
+  }
+  const overall = rollupStatus(Object.values(byCategory).map((b) => b.status));
+  return {
+    overall,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    durationMs: Date.now() - t0,
+    activeProfile,
+    probeRan: probe,
+    byCategory
+  };
+}
+function formatReportMarkdown(report) {
+  const lines = [];
+  const dot = { pass: "[OK]", warn: "[!]", fail: "[X]", skip: "[-]" };
+  lines.push(`# Perplexity Doctor report -- ${dot[report.overall]} **${report.overall.toUpperCase()}**`);
+  lines.push(`Generated ${report.generatedAt} in ${report.durationMs}ms`);
+  lines.push(`Active profile: \`${report.activeProfile}\`${report.probeRan ? " (probe ran)" : ""}`);
+  lines.push("");
+  for (const cat of CATEGORIES) {
+    const bucket = report.byCategory[cat];
+    if (!bucket) continue;
+    lines.push(`## ${dot[bucket.status]} ${cat} -- ${bucket.status}`);
+    for (const c of bucket.checks) {
+      lines.push(`- ${dot[c.status]} **${c.name}** -- ${c.message}${c.hint ? `
+  - *Hint:* ${c.hint}` : ""}`);
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+export {
+  CATEGORIES,
+  rollupStatus,
+  exitCodeFor,
+  runAll,
+  formatReportMarkdown
+};