@introspection-ai/recipes 0.25.0 → 0.26.0

package/dist/mcp-chunks/chunk-LG3GLOSA.js

@@ -0,0 +1,513 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  launchDaemonDetached
+} from "./chunk-GK4LA4E6.js";
+import {
+  BrokerError,
+  DAEMON_PROTOCOL_VERSION,
+  DaemonBroker,
+  DaemonClient,
+  ProcessObservationError,
+  SocketFrames,
+  assertLegacyDrained,
+  authenticateServer,
+  daemonKey,
+  idleTimerDelay,
+  legacyDaemons,
+  requestDaemon,
+  resolveDaemonPaths,
+  resolveProgressInterval,
+  stopVerifiedLegacyDaemons,
+  waitForDaemonReady
+} from "./chunk-BTU34BUG.js";
+import {
+  canonicalUserConfiguration,
+  getDaemonLogPath,
+  secureDaemonDirectory
+} from "./chunk-Y3L5LWBY.js";
+import {
+  withFileLock,
+  writeJsonFile
+} from "./chunk-QIBGY4IX.js";
+import {
+  expandHome
+} from "./chunk-EP22XMWK.js";
+
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/cli/daemon-command.js
+import fsPromises from "node:fs/promises";
+import path2 from "node:path";
+
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/daemon/host.js
+import fs from "node:fs/promises";
+import net from "node:net";
+import { randomUUID } from "node:crypto";
+
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/daemon/log-context.js
+import fsSync from "node:fs";
+import path from "node:path";
+function createLogContext(options) {
+  const derivedEnabled = options.enabled || options.logAllServers || options.servers.size > 0;
+  const context = {
+    enabled: derivedEnabled,
+    logAllServers: options.logAllServers,
+    servers: options.servers
+  };
+  if (derivedEnabled && options.logPath) {
+    try {
+      fsSync.mkdirSync(path.dirname(options.logPath), { recursive: true });
+      const writer = fsSync.createWriteStream(options.logPath, {
+        flags: "a"
+      });
+      writer.on("error", (error) => {
+        console.warn(`[daemon] Log file write error (${options.logPath}): ${error.message}`);
+        if (context.writer === writer) {
+          context.writer = void 0;
+        }
+      });
+      context.writer = writer;
+    } catch (error) {
+      console.warn(`[daemon] Failed to open log file ${options.logPath}: ${error.message}`);
+    }
+  }
+  return context;
+}
+function logEvent(context, message) {
+  if (!context.enabled) {
+    return;
+  }
+  const line = `[daemon] ${(/* @__PURE__ */ new Date()).toISOString()} ${message}`;
+  console.log(line);
+  try {
+    context.writer?.write(`${line}
+`);
+  } catch {
+  }
+}
+async function disposeLogContext(context) {
+  const writer = context.writer;
+  if (!writer) {
+    return;
+  }
+  await new Promise((resolve) => {
+    writer.end(() => resolve());
+    writer.on("error", () => resolve());
+  });
+}
+
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/daemon/host.js
+async function runDaemonHost(options) {
+  await secureDaemonDirectory();
+  await assertLegacyDrained();
+  const key = await daemonKey();
+  const canonical = await canonicalUserConfiguration();
+  const broker = new DaemonBroker(canonical.definitions);
+  const log = createLogContext({
+    enabled: Boolean(options.logPath),
+    logPath: options.logPath,
+    logAllServers: options.logAllServers ?? false,
+    servers: options.logServers ?? /* @__PURE__ */ new Set()
+  });
+  const startedAt = Date.now();
+  const status = () => ({
+    pid: process.pid,
+    protocolVersion: DAEMON_PROTOCOL_VERSION,
+    startedAt,
+    configPath: "",
+    socketPath: options.socketPath,
+    logPath: options.logPath,
+    ...broker.status(),
+    idleTimeoutMs: canonical.idleTimeoutMs,
+    idleShutdownBlocked: !broker.canIdleShutdown()
+  });
+  let shuttingDown = false;
+  let closing;
+  let lastActivity = Date.now();
+  let idleTimer;
+  const scheduleIdle = () => {
+    clearTimeout(idleTimer);
+    if (!canonical.idleTimeoutMs || shuttingDown)
+      return;
+    idleTimer = setTimeout(checkIdle, idleTimerDelay(canonical.idleTimeoutMs, lastActivity));
+    idleTimer.unref();
+  };
+  const checkIdle = () => {
+    if (shuttingDown || !canonical.idleTimeoutMs)
+      return;
+    if (Date.now() - lastActivity >= canonical.idleTimeoutMs && broker.canIdleShutdown()) {
+      void close().catch(() => logEvent(log, "idle shutdown blocked: transport retirement failed"));
+      return;
+    }
+    scheduleIdle();
+  };
+  const onSignal = () => {
+    void close().catch(() => {
+    });
+  };
+  const close = () => {
+    closing ??= (async () => {
+      await broker.close();
+      shuttingDown = true;
+      clearTimeout(idleTimer);
+      process.off("SIGINT", onSignal);
+      process.off("SIGTERM", onSignal);
+      server.close();
+      await cleanupDaemonArtifactsIfOwned(options, process.pid);
+      await disposeLogContext(log);
+      key.fill(0);
+    })().catch((error) => {
+      closing = void 0;
+      throw error;
+    });
+    return closing;
+  };
+  const server = net.createServer((socket) => {
+    const frames = new SocketFrames(socket);
+    socket.setTimeout(3e4, () => socket.destroy());
+    void (async () => {
+      try {
+        await authenticateServer(frames, key);
+      } catch {
+        socket.destroy();
+        return;
+      }
+      let timer;
+      let id = "invalid";
+      try {
+        const request = await frames.read();
+        id = typeof request?.id === "string" && request.id.length <= 256 ? request.id : "invalid";
+        if (id === "invalid" || !request || typeof request.params !== "object" || !request.params)
+          throw new BrokerError("invalid_request", "Invalid daemon request.");
+        if (request.protocolVersion !== DAEMON_PROTOCOL_VERSION)
+          throw new BrokerError("incompatible_daemon", "Upgrade all invoking clients before cutover.");
+        socket.setTimeout(0);
+        lastActivity = Date.now();
+        scheduleIdle();
+        if (typeof request.progressIntervalMs === "number" && Number.isFinite(request.progressIntervalMs))
+          timer = setInterval(() => {
+            if (!socket.destroyed)
+              frames.write({ type: "progress", id });
+          }, resolveProgressInterval(request.progressIntervalMs));
+        let result;
+        let notices = [];
+        switch (request.method) {
+          case "status":
+            result = status();
+            break;
+          case "registerView":
+            result = broker.register(request.params);
+            break;
+          case "releaseView":
+            broker.release(request);
+            result = true;
+            break;
+          case "stop":
+            await close();
+            result = true;
+            break;
+          default:
+            logEvent(log, `${request.method} start`);
+            ({ result, notices } = await broker.invokeWithNotices(request));
+            logEvent(log, `${request.method} success`);
+        }
+        frames.write({ id, ok: true, result, notices });
+        socket.end();
+      } catch (error) {
+        const code = error && typeof error === "object" && "code" in error ? String(error.code) : "runtime_error";
+        const message = error instanceof BrokerError || error instanceof ProcessObservationError || code === "browser_owner_conflict" ? error.message : `MCP operation failed (${code}); the request was not replayed.`;
+        frames.write({ id, ok: false, error: { code, message } });
+        socket.end();
+      } finally {
+        lastActivity = Date.now();
+        scheduleIdle();
+        if (timer)
+          clearInterval(timer);
+      }
+    })().catch(() => socket.destroy());
+  });
+  let claimed = false;
+  await withFileLock(options.metadataPath, async () => {
+    let live;
+    try {
+      const response = await requestDaemon(options.socketPath, { id: randomUUID(), method: "status", params: {}, protocolVersion: DAEMON_PROTOCOL_VERSION }, 1e3);
+      if (!response.ok || response.result?.protocolVersion !== DAEMON_PROTOCOL_VERSION)
+        throw new Error("Incompatible daemon owns the socket.");
+      live = response.result;
+    } catch (error) {
+      const code = error.code;
+      if (code !== "ENOENT" && code !== "ECONNREFUSED")
+        throw error;
+    }
+    if (live) {
+      await writeJsonFile(options.metadataPath, live);
+      return;
+    }
+    const metadata = await fs.readFile(options.metadataPath, "utf8").then((value) => JSON.parse(value)).catch((error) => {
+      if (error.code !== "ENOENT")
+        throw error;
+      return void 0;
+    });
+    if (metadata)
+      throw new BrokerError("daemon_unresponsive", "Previous daemon retirement is unverified; inspect its transports before deliberate recovery.");
+    if (process.platform !== "win32")
+      await fs.unlink(options.socketPath).catch((error) => {
+        if (error.code !== "ENOENT")
+          throw error;
+      });
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(options.socketPath, () => {
+        server.off("error", reject);
+        resolve();
+      });
+    });
+    if (process.platform !== "win32")
+      await fs.chmod(options.socketPath, 384);
+    await writeJsonFile(options.metadataPath, status());
+    claimed = true;
+  });
+  if (!claimed) {
+    server.close();
+    await disposeLogContext(log);
+    key.fill(0);
+    return { close: async () => {
+    }, status };
+  }
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+  scheduleIdle();
+  return { close, status };
+}
+async function cleanupDaemonArtifactsIfOwned(paths, ownerPid) {
+  const metadata = await fs.readFile(paths.metadataPath, "utf8").then((raw) => JSON.parse(raw)).catch(() => void 0);
+  if (metadata?.pid !== ownerPid || metadata.socketPath !== paths.socketPath)
+    return;
+  if (process.platform !== "win32")
+    await fs.unlink(paths.socketPath).catch((error) => {
+      if (error.code !== "ENOENT")
+        throw error;
+    });
+  await fs.unlink(paths.metadataPath);
+}
+
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/cli/daemon-command.js
+async function handleDaemonCli(args, options) {
+  const subcommand = args.shift();
+  if (!subcommand || subcommand === "help" || subcommand === "--help") {
+    printDaemonHelp();
+    return;
+  }
+  const client = new DaemonClient({
+    configPath: options.configPath,
+    configExplicit: options.configExplicit,
+    rootDir: options.rootDir
+  });
+  if (subcommand === "migrate") {
+    if (args.includes("--stop-legacy")) {
+      if (!args.includes("--confirmed-drained"))
+        throw new Error("Drain all legacy clients first, then pass --confirmed-drained.");
+      await stopVerifiedLegacyDaemons();
+      console.log("Daemon directory permissions verified; legacy daemons and observed owned children have retired.");
+    } else
+      console.log(JSON.stringify((await legacyDaemons()).map(({ pid, verified }) => ({ pid, verified }))));
+    return;
+  }
+  if (subcommand === "start") {
+    await handleDaemonStart(args, options, client);
+    return;
+  }
+  if (subcommand === "status") {
+    if (args.includes("--json"))
+      console.log(JSON.stringify(await client.status()));
+    else
+      await handleDaemonStatus(client);
+    return;
+  }
+  if (subcommand === "stop") {
+    await client.stop();
+    console.log("Daemon stopped (if it was running).");
+    return;
+  }
+  if (subcommand === "restart") {
+    await handleDaemonRestart(args, options, client);
+    return;
+  }
+  throw new Error(`Unknown daemon subcommand '${subcommand}'.`);
+}
+function printDaemonHelp() {
+  console.log(`Usage: mcporter daemon <start|status|stop|restart|migrate>
+
+Commands:
+  start    Start the single-user daemon (configuration views register on demand).
+  status   Show whether the daemon is running and which servers are active.
+  stop     Shut down the daemon and all managed servers.
+  restart  Drain and stop the daemon, then start a fresh instance.
+  migrate  Inspect legacy ownership without changing directory permissions.
+           --stop-legacy --confirmed-drained upgrades owned legacy 0755 directories
+           and retires verified owners (also works when old daemons are already stopped).
+
+Flags:
+  --foreground        Run the daemon in the current process (debug only).
+  --json              Print machine-readable status.
+  --log               Enable bounded operation logging (OS-user .mcporter/daemon/user.log).
+  --log-file <path>   Write daemon stdout/stderr to a specific log file.
+  --log-servers <csv> Only log call activity for the listed servers (implies --log).`);
+}
+async function handleDaemonStart(args, options, client) {
+  const foregroundFlag = consumeFlag(args, "--foreground");
+  const isChildLaunch = process.env.MCPORTER_DAEMON_CHILD === "1";
+  const foreground = foregroundFlag || isChildLaunch;
+  const paths = resolveDaemonPaths(options.configPath);
+  const socketPath = paths.socketPath;
+  const metadataPath = paths.metadataPath;
+  await secureDaemonDirectory();
+  const logging = await resolveDaemonLoggingOptions(args, paths.key);
+  if (foreground) {
+    await runDaemonHost({
+      socketPath,
+      metadataPath,
+      configPath: options.configPath,
+      configExplicit: options.configExplicit,
+      rootDir: options.rootDir,
+      logPath: logging.enabled ? logging.logPath : void 0,
+      logServers: logging.serverFilter,
+      logAllServers: logging.logAllServers
+    });
+    return;
+  }
+  const existing = await client.status();
+  if (existing) {
+    console.log(`Daemon already running (pid ${existing.pid}).`);
+    return;
+  }
+  const forwardedArgs = [];
+  if (logging.enabled && logging.logPath) {
+    forwardedArgs.push("--log-file", logging.logPath);
+  }
+  if (logging.serverFilter.size > 0) {
+    forwardedArgs.push("--log-servers", Array.from(logging.serverFilter).join(","));
+  }
+  await launchDaemonDetached({
+    configPath: options.configPath,
+    configExplicit: options.configExplicit,
+    rootDir: options.rootDir,
+    metadataPath,
+    socketPath,
+    extraArgs: forwardedArgs
+  });
+  await waitForDaemonReady((timeoutMs) => client.status(timeoutMs));
+  console.log("Single-user daemon started.");
+}
+async function handleDaemonRestart(args, options, client) {
+  await client.stop();
+  console.log("Daemon stopped (if it was running).");
+  const stopped = await waitFor(async () => {
+    const status = await client.status();
+    return status ? null : true;
+  }, 5e3, 100);
+  if (!stopped) {
+    throw new Error("Daemon did not stop before restart could begin.");
+  }
+  await handleDaemonStart(args, options, client);
+}
+async function handleDaemonStatus(client) {
+  const status = await client.status();
+  if (!status) {
+    console.log("Daemon is not running.");
+    return;
+  }
+  console.log(`Daemon pid ${status.pid} \u2014 socket: ${status.socketPath}`);
+  if (status.logPath) {
+    console.log(`Log file: ${status.logPath}`);
+  }
+  if (status.servers.length === 0) {
+    console.log("No keep-alive servers registered.");
+    return;
+  }
+  status.servers.forEach((server) => {
+    const state = server.connected ? "connected" : "idle";
+    const lastUsed = server.lastUsedAt ? ` (last used ${new Date(server.lastUsedAt).toISOString()})` : "";
+    console.log(`- ${server.name}: ${state}${lastUsed}`);
+    if (server.chromeDevtoolsRelay) {
+      const relay = server.chromeDevtoolsRelay;
+      const endpoint = relay.endpoint ? ` endpoint=${relay.endpoint}` : "";
+      const probe = relay.probeDurationMs === void 0 ? "" : ` probe=${relay.probeStatus ?? "no-status"}/${relay.probeDurationMs}ms`;
+      console.log(`  chrome relay: route=${relay.route} policy=${relay.policy} reason=${relay.reason}${endpoint}${probe}`);
+    }
+  });
+}
+function consumeFlag(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) {
+    return false;
+  }
+  args.splice(index, 1);
+  return true;
+}
+function consumeValueFlag(args, flag) {
+  const index = args.indexOf(flag);
+  if (index === -1) {
+    return void 0;
+  }
+  if (index + 1 >= args.length) {
+    throw new Error(`Flag '${flag}' requires a value.`);
+  }
+  const value = args[index + 1];
+  args.splice(index, 2);
+  return value;
+}
+async function waitFor(probe, timeoutMs, intervalMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const result = await probe();
+    if (result) {
+      return result;
+    }
+    await delay(intervalMs);
+  }
+  return null;
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+async function resolveDaemonLoggingOptions(args, configKey) {
+  const logFlag = consumeFlag(args, "--log");
+  const logFileValue = consumeValueFlag(args, "--log-file");
+  const logServersValue = consumeValueFlag(args, "--log-servers");
+  const envLogEnabled = process.env.MCPORTER_DAEMON_LOG === "1";
+  const envLogPath = process.env.MCPORTER_DAEMON_LOG_PATH;
+  const envLogServers = process.env.MCPORTER_DAEMON_LOG_SERVERS;
+  const serverFilter = parseServerList(logServersValue ?? envLogServers);
+  const explicitServerLogging = serverFilter.size > 0;
+  const resolvedFileFlag = logFileValue ? path2.resolve(expandHome(logFileValue)) : void 0;
+  const resolvedEnvFile = envLogPath ? path2.resolve(expandHome(envLogPath)) : void 0;
+  const enabled = logFlag || Boolean(resolvedFileFlag) || envLogEnabled || Boolean(resolvedEnvFile) || explicitServerLogging;
+  if (!enabled) {
+    return {
+      enabled: false,
+      logPath: void 0,
+      logAllServers: false,
+      serverFilter
+    };
+  }
+  const logPath = resolvedFileFlag ?? resolvedEnvFile ?? getDaemonLogPath(configKey);
+  await fsPromises.mkdir(path2.dirname(logPath), { recursive: true });
+  return {
+    enabled: true,
+    logPath,
+    logAllServers: serverFilter.size === 0,
+    serverFilter
+  };
+}
+function parseServerList(value) {
+  if (!value) {
+    return /* @__PURE__ */ new Set();
+  }
+  const entries = value.split(",").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  return new Set(entries);
+}
+
+export {
+  handleDaemonCli
+};

package/dist/mcp-chunks/{chunk-CZKDJZER.js → chunk-LTR626QF.js}

@@ -1,6 +1,6 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 
-// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/cli/errors.js
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/cli/errors.js
 var CliUsageError = class extends Error {
   constructor(message) {
     super(message);

package/dist/mcp-chunks/{chunk-FS5JIKT6.js → chunk-LYWEATXZ.js}

@@ -1,9 +1,9 @@
 import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
 import {
   expandHome
-} from "./chunk-WTMJMM3B.js";
+} from "./chunk-EP22XMWK.js";
 
-// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/paths.js
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/paths.js
 import os from "node:os";
 import path from "node:path";
 var XDG_HOME_ENV = {
@@ -25,11 +25,11 @@ function mcporterDir(kind) {
   }
   return legacyMcporterDir();
 }
-function mcporterConfigCandidates() {
-  const base = mcporterDir("config");
+function mcporterConfigCandidates(context) {
+  const legacy = context ? path.join(context.home, ".mcporter") : legacyMcporterDir();
+  const base = context ? context.configHome ? path.join(context.configHome, "mcporter") : legacy : mcporterDir("config");
   const candidates = [path.join(base, "mcporter.json"), path.join(base, "mcporter.jsonc")];
-  if (base !== legacyMcporterDir()) {
-    const legacy = legacyMcporterDir();
+  if (base !== legacy) {
     candidates.push(path.join(legacy, "mcporter.json"), path.join(legacy, "mcporter.jsonc"));
   }
   return candidates;

package/dist/mcp-chunks/{chunk-YIRGLKDA.js → chunk-M62ESEOY.js}

@@ -7,26 +7,31 @@ import {
   reconcilePersistedTokens,
   withRefreshLock,
   withRefreshRequestTimeout
-} from "./chunk-ASG4OY3M.js";
+} from "./chunk-Z6QEOUMK.js";
 import {
+  runtimeEnvironment,
   sameOAuthTokenGeneration
-} from "./chunk-53NRFMB3.js";
+} from "./chunk-YI5SMRFH.js";
 import {
-  isUnauthorizedError
-} from "./chunk-IRTJXFWA.js";
+  isFileLockTimeoutError
+} from "./chunk-QIBGY4IX.js";
+import {
+  analyzeConnectionError
+} from "./chunk-GL4AA5QV.js";
 import {
   IssuerMismatchError,
   auth,
   validateClientMetadataUrl
-} from "./chunk-PZ323CXI.js";
-import {
-  suppressBrowserLaunchFromEnv
-} from "./chunk-DTZHEVKC.js";
-import {
-  isFileLockTimeoutError
-} from "./chunk-ITR7FQM3.js";
+} from "./chunk-CN5YF3IQ.js";
 
-// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/oauth.js
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/oauth-browser-suppression.js
+var TRUE_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes"]);
+function suppressBrowserLaunchFromEnv(env = runtimeEnvironment()) {
+  const raw = env.MCPORTER_OAUTH_NO_BROWSER;
+  return raw !== void 0 && TRUE_VALUES.has(raw.trim().toLowerCase());
+}
+
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/oauth.js
 import { spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import http from "node:http";
@@ -75,6 +80,8 @@ function openExternal(url, platform = process.platform, launch = spawn) {
   try {
     if (platform === "darwin") {
       const child = launch("open", [url], { stdio, detached: true });
+      child.on("error", () => {
+      });
       child.unref();
     } else if (platform === "win32") {
       const child = launch("rundll32", ["url.dll,FileProtocolHandler", url], {
@@ -82,6 +89,8 @@ function openExternal(url, platform = process.platform, launch = spawn) {
         detached: true,
         windowsHide: true
       });
+      child.on("error", () => {
+      });
       child.unref();
     } else {
       try {
@@ -537,7 +546,26 @@ var __oauthInternals = {
   openExternal
 };
 
-// node_modules/.pnpm/mcporter@0.13.8/node_modules/mcporter/dist/runtime/oauth.js
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/runtime-oauth-support.js
+function maybeEnableOAuth(definition, logger) {
+  if (definition.auth === "oauth" || definition.auth === "refreshable_bearer") {
+    return void 0;
+  }
+  if (definition.command.kind !== "http") {
+    return void 0;
+  }
+  logger.info(`Detected OAuth requirement for '${definition.name}'. Launching browser flow...`);
+  return {
+    ...definition,
+    auth: "oauth"
+  };
+}
+function isUnauthorizedError(error) {
+  const issue = analyzeConnectionError(error);
+  return issue.kind === "auth";
+}
+
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/runtime/oauth.js
 var DEFAULT_OAUTH_CODE_TIMEOUT_MS = 3e5;
 var OAUTH_FLOW_ERROR = /* @__PURE__ */ Symbol("oauth-flow-error");
 var POST_AUTH_CONNECT_ERROR = /* @__PURE__ */ Symbol("post-auth-connect-error");
@@ -810,11 +838,14 @@ function parseOAuthTimeout(raw) {
   return parsed;
 }
 function resolveOAuthTimeoutFromEnv() {
-  return parseOAuthTimeout(process.env.MCPORTER_OAUTH_TIMEOUT_MS ?? process.env.MCPORTER_OAUTH_TIMEOUT);
+  return parseOAuthTimeout(runtimeEnvironment().MCPORTER_OAUTH_TIMEOUT_MS ?? runtimeEnvironment().MCPORTER_OAUTH_TIMEOUT);
 }
 
 export {
+  suppressBrowserLaunchFromEnv,
   createOAuthSession,
+  maybeEnableOAuth,
+  isUnauthorizedError,
   OAuthTimeoutError,
   isOAuthFlowError,
   isPostAuthConnectError,