@introspection-ai/recipes 0.25.1 → 0.26.0

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

@@ -0,0 +1,1182 @@
+import { createRequire as __createRequire } from "node:module"; const require = __createRequire(import.meta.url);
+import {
+  BrowserOwner,
+  authorizeBrokerDefinition,
+  connectionIdentity,
+  createRuntime,
+  daemonRunDir,
+  effectiveDefinition,
+  filterTools,
+  getChromeDevtoolsRelayDecision,
+  getDaemonMetadataPath,
+  getDaemonSocketPath,
+  inspectLegacyDaemonDirectory,
+  isChromeDefinition,
+  isToolAllowed,
+  resolveSystemPowerShellPath,
+  secureDaemonDirectory,
+  upgradeLegacyDaemonDirectory
+} from "./chunk-Y3L5LWBY.js";
+import {
+  NON_INTERACTIVE_ELICITATION_HINT,
+  createNonInteractiveElicitationResponder
+} from "./chunk-REEFOL44.js";
+import {
+  isOAuthFlowError,
+  resolveOAuthTimeoutFromEnv
+} from "./chunk-M62ESEOY.js";
+import {
+  withRuntimeEnvironment
+} from "./chunk-YI5SMRFH.js";
+import {
+  MCPORTER_VERSION
+} from "./chunk-NTABJCUL.js";
+import {
+  normalizeTimeout
+} from "./chunk-YVH36MGQ.js";
+import {
+  RawEntrySchema,
+  loadServerDefinitions
+} from "./chunk-J2WP6ERZ.js";
+import {
+  isProcessRunning,
+  withFileLock,
+  writeJsonFile
+} from "./chunk-QIBGY4IX.js";
+import {
+  mcporterDir
+} from "./chunk-LYWEATXZ.js";
+import {
+  isKeepAliveServer
+} from "./chunk-D2P2IV4H.js";
+import {
+  SdkErrorCode,
+  external_exports
+} from "./chunk-CN5YF3IQ.js";
+
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/daemon/socket-rpc.js
+import { createHmac, randomBytes, timingSafeEqual } from "node:crypto";
+import fs from "node:fs/promises";
+import net from "node:net";
+import path from "node:path";
+
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/daemon/protocol.js
+var DAEMON_PROTOCOL_VERSION = 3;
+var MAX_DAEMON_PAYLOAD_BYTES = 4 * 1024 * 1024;
+var DAEMON_PROGRESS_INTERVAL_MS = 250;
+var MIN_DAEMON_PROGRESS_INTERVAL_MS = 25;
+var DAEMON_PROGRESS_SCHEDULING_SLACK_MS = MIN_DAEMON_PROGRESS_INTERVAL_MS;
+function resolveProgressInterval(requestedIntervalMs) {
+  if (requestedIntervalMs >= DAEMON_PROGRESS_INTERVAL_MS)
+    return DAEMON_PROGRESS_INTERVAL_MS;
+  if (requestedIntervalMs >= 100)
+    return 100;
+  if (requestedIntervalMs >= 50)
+    return 50;
+  return MIN_DAEMON_PROGRESS_INTERVAL_MS;
+}
+function resolveProgressTiming(requestedIdleTimeoutMs) {
+  const idleTimeoutMs = normalizeTimeout(requestedIdleTimeoutMs) ?? DAEMON_PROGRESS_INTERVAL_MS * 3 + DAEMON_PROGRESS_SCHEDULING_SLACK_MS;
+  const progressIntervalMs = resolveProgressInterval(Math.floor(idleTimeoutMs / 3));
+  return {
+    progressIntervalMs,
+    // Keep three frame opportunities plus scheduler slack inside the socket idle budget.
+    idleTimeoutMs: Math.max(idleTimeoutMs, progressIntervalMs * 3 + DAEMON_PROGRESS_SCHEDULING_SLACK_MS)
+  };
+}
+
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/daemon/socket-rpc.js
+async function daemonKey() {
+  await secureDaemonDirectory();
+  const file = path.join(daemonRunDir(), "user.key");
+  return withFileLock(file, async () => {
+    try {
+      await fs.writeFile(file, randomBytes(32), { flag: "wx", mode: 384 });
+    } catch (error) {
+      if (error.code !== "EEXIST")
+        throw error;
+    }
+    const info = await fs.lstat(file);
+    if (!info.isFile() || info.isSymbolicLink() || process.platform !== "win32" && (info.uid !== process.getuid?.() || (info.mode & 63) !== 0))
+      throw new Error("Unsafe daemon authentication key ownership.");
+    const key = await fs.readFile(file);
+    if (key.length !== 32)
+      throw new Error("Invalid daemon authentication key.");
+    return key;
+  });
+}
+var SocketFrames = class {
+  socket;
+  buffer = "";
+  queue = [];
+  pending;
+  failure;
+  bytes = 0;
+  constructor(socket) {
+    this.socket = socket;
+    socket.setEncoding("utf8");
+    socket.on("data", (chunk) => {
+      this.bytes += Buffer.byteLength(chunk);
+      if (this.bytes > MAX_DAEMON_PAYLOAD_BYTES * 2) {
+        this.fail(new Error("Daemon frame limit exceeded."));
+        return;
+      }
+      this.buffer += chunk;
+      let newline;
+      while ((newline = this.buffer.indexOf("\n")) !== -1) {
+        const line = this.buffer.slice(0, newline);
+        this.buffer = this.buffer.slice(newline + 1);
+        this.bytes = Buffer.byteLength(this.buffer);
+        try {
+          const value = JSON.parse(line);
+          if (this.pending) {
+            const pending2 = this.pending;
+            this.pending = void 0;
+            pending2.resolve(value);
+          } else if (this.queue.length < 8)
+            this.queue.push(value);
+          else {
+            this.fail(new Error("Too many daemon frames."));
+            return;
+          }
+        } catch {
+          this.fail(new Error("Malformed daemon frame."));
+          return;
+        }
+      }
+    });
+    socket.on("error", (error) => this.fail(error));
+    socket.on("end", () => this.fail(new Error("Daemon connection ended.")));
+  }
+  fail(error) {
+    this.failure ??= error;
+    this.pending?.reject(error);
+    this.pending = void 0;
+    this.socket.destroy();
+  }
+  read() {
+    if (this.queue.length)
+      return Promise.resolve(this.queue.shift());
+    if (this.failure)
+      return Promise.reject(this.failure);
+    return new Promise((resolve, reject) => {
+      this.pending = { resolve, reject };
+    });
+  }
+  write(value) {
+    this.socket.write(`${JSON.stringify(value)}
+`);
+  }
+};
+function proof(key, role, client, server) {
+  return createHmac("sha256", key).update(`mcporter-v3\0${role}\0${client}\0${server}`).digest("hex");
+}
+function nonce(value) {
+  return typeof value === "string" && /^[a-f0-9]{64}$/.test(value);
+}
+function checkProof(actual, expected) {
+  if (!nonce(actual) || !timingSafeEqual(Buffer.from(actual, "hex"), Buffer.from(expected, "hex")))
+    throw new Error("Daemon authentication failed; no configuration sent.");
+}
+async function authenticateServer(frames, key) {
+  const hello = await frames.read();
+  if (!hello || !nonce(hello.hello))
+    throw new Error("Invalid daemon hello.");
+  const server = randomBytes(32).toString("hex");
+  frames.write({ nonce: server, proof: proof(key, "server", hello.hello, server) });
+  const auth = await frames.read();
+  checkProof(auth?.proof, proof(key, "client", hello.hello, server));
+  frames.write({ authenticated: true });
+}
+async function authenticateClient(frames, key) {
+  const client = randomBytes(32).toString("hex");
+  frames.write({ hello: client });
+  const hello = await frames.read();
+  if (!hello || !nonce(hello.nonce))
+    throw new Error("Invalid daemon authentication response.");
+  checkProof(hello.proof, proof(key, "server", client, hello.nonce));
+  frames.write({ proof: proof(key, "client", client, hello.nonce) });
+  const ack = await frames.read();
+  if (!ack?.authenticated)
+    throw new Error("Daemon authentication failed.");
+}
+async function requestDaemon(socketPath, request, idleTimeoutMs) {
+  const key = await daemonKey();
+  const socket = net.createConnection(socketPath);
+  const frames = new SocketFrames(socket);
+  socket.setTimeout(idleTimeoutMs, () => socket.destroy(Object.assign(new Error("Daemon request timed out; outcome unknown, not replayed."), { code: "ETIMEDOUT" })));
+  try {
+    await authenticateClient(frames, key);
+    frames.write(request);
+    for (; ; ) {
+      const response = await frames.read();
+      if (!response || response.id !== request.id)
+        throw new Error("Mismatched daemon response.");
+      if (response.type === "progress")
+        continue;
+      if (typeof response.ok !== "boolean")
+        throw new Error("Invalid daemon response.");
+      return response;
+    }
+  } finally {
+    key.fill(0);
+    socket.destroy();
+  }
+}
+
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/daemon/client.js
+import { randomUUID as randomUUID3 } from "node:crypto";
+import fs3 from "node:fs/promises";
+
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/daemon/process-retirement.js
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var exec = promisify(execFile);
+var MAX_TARGETS = 256;
+var MAX_TREE = 1024;
+var pending = [];
+var ProcessObservationError = class extends Error {
+  code = "process_observation_failed";
+};
+function observationFailure(detail) {
+  return new ProcessObservationError(`Windows process observation ${detail}; retirement remains blocked. Check Windows process query access and retry.`);
+}
+var sid = (candidate) => typeof candidate === "string" && /^S-\d+(?:-\d+)+$/.test(candidate);
+function decodeWindowsInventory(stdout) {
+  let value;
+  try {
+    value = JSON.parse(stdout.replace(/^\uFEFF/, ""));
+  } catch {
+    throw observationFailure("returned invalid or empty JSON");
+  }
+  if (!value || value.version !== 1 || !sid(value.owner) || !Array.isArray(value.processes) || value.processes.length > MAX_TREE)
+    throw observationFailure("returned an invalid completion envelope");
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of value.processes) {
+    if (!item || !Number.isSafeInteger(item.pid) || item.pid <= 0 || seen.has(item.pid) || !Number.isSafeInteger(item.parent) || item.parent < 0 || item.owner !== null && !sid(item.owner) || item.born !== null && (typeof item.born !== "string" || !/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{7}Z$/.test(item.born) || !Number.isFinite(Date.parse(item.born))))
+      throw observationFailure("returned an invalid process identity");
+    seen.add(item.pid);
+  }
+  return value;
+}
+async function windowsInventory(requests) {
+  const roots = [...new Set(requests.filter((r) => r.tree).flatMap((r) => r.pids))];
+  const targets = [...new Set(requests.flatMap((r) => r.pids))];
+  const query = "SELECT Handle,ProcessId,ParentProcessId,CreationDate FROM Win32_Process" + (roots.length ? "" : ` WHERE ${targets.map((pid) => `ProcessId=${pid}`).join(" OR ")}`);
+  const script = String.raw`
+$ErrorActionPreference='Stop'
+[Console]::OutputEncoding = New-Object System.Text.UTF8Encoding($false)
+try {
+Add-Type -AssemblyName System.Management
+$sid=[System.Security.Principal.WindowsIdentity]::GetCurrent().User.Value
+$searcher=New-Object System.Management.ManagementObjectSearcher('${query}')
+$rows=@($searcher.Get())
+$selected=@{}
+foreach ($target in @(${targets.join(",")})) { $selected[[int]$target]=$true }
+$frontier=@(${roots.join(",")})
+$descendants=@{}
+foreach ($root in $frontier) { $descendants[[int]$root]=$true }
+while ($frontier.Count -gt 0) {
+  $next=@()
+  foreach ($item in $rows) {
+    if ($frontier -contains [int]$item.ParentProcessId -and -not $descendants.ContainsKey([int]$item.ProcessId)) {
+      $descendants[[int]$item.ProcessId]=$true
+      $selected[[int]$item.ProcessId]=$true
+      $next+=([int]$item.ProcessId)
+      if ($selected.Count -gt ${MAX_TREE}) { throw 'tree limit' }
+    }
+  }
+  $frontier=$next
+}
+$items=@(foreach ($item in $rows) {
+  if (-not $selected.ContainsKey([int]$item.ProcessId)) { continue }
+  $born=$null
+  if ($null -ne $item.CreationDate) { $born=[System.Management.ManagementDateTimeConverter]::ToDateTime($item.CreationDate).ToUniversalTime().ToString('o') }
+  $owner=$null
+  try {
+    $ownerArgs=[object[]]@('')
+    if ($item.InvokeMethod('GetOwnerSid',$ownerArgs) -eq 0) { $owner=[string]$ownerArgs[0] }
+  } catch { $owner=$null }
+  @{pid=[int]$item.ProcessId;parent=[int]$item.ParentProcessId;owner=$owner;born=$born}
+})
+# Bind owner results to the same start identities; an exited process is definite absence.
+$filter=($selected.Keys | ForEach-Object { 'ProcessId='+$_ }) -join ' OR '
+$verify=New-Object System.Management.ManagementObjectSearcher("SELECT Handle,ProcessId,ParentProcessId,CreationDate FROM Win32_Process WHERE $filter")
+$current=@{}
+foreach ($item in $verify.Get()) { $current[[int]$item.ProcessId]=$item }
+$checked=@(foreach ($item in $items) {
+  $now=$current[$item.pid]
+  if ($null -eq $now) { continue }
+  $born=$null
+  if ($null -ne $now.CreationDate) { $born=[System.Management.ManagementDateTimeConverter]::ToDateTime($now.CreationDate).ToUniversalTime().ToString('o') }
+  if ($born -ne $item.born) { $item.owner=$null; $item.born=$null }
+  $item
+})
+[Console]::Write((@{version=1;owner=$sid;processes=$checked}|ConvertTo-Json -Compress -Depth 4))
+} catch { exit 1 }
+`;
+  let stdout;
+  try {
+    ({ stdout } = await exec(resolveSystemPowerShellPath(), [
+      "-NoLogo",
+      "-NoProfile",
+      "-NonInteractive",
+      "-EncodedCommand",
+      Buffer.from(script, "utf16le").toString("base64")
+    ], { timeout: 5e3, maxBuffer: 4 * 1024 * 1024, windowsHide: true, encoding: "utf8" }));
+  } catch {
+    throw observationFailure("failed");
+  }
+  return decodeWindowsInventory(stdout);
+}
+async function processInventory(pids, tree = false) {
+  if (!pids.length || pids.length > MAX_TARGETS || pids.some((pid) => !Number.isSafeInteger(pid) || pid <= 0))
+    throw new Error("Invalid process observation targets.");
+  if (process.platform === "win32") {
+    return new Promise((resolve, reject) => {
+      pending.push({ pids: [...pids], tree, resolve, reject });
+      if (pending.length !== 1)
+        return;
+      queueMicrotask(() => {
+        const requests = pending;
+        pending = [];
+        let batch = [];
+        let count = 0;
+        const run = (group) => {
+          void windowsInventory(group).then((inventory) => {
+            for (const request of group)
+              request.resolve(inventory);
+          }, (error) => {
+            for (const request of group)
+              request.reject(error);
+          });
+        };
+        for (const request of requests) {
+          if (count + request.pids.length > MAX_TARGETS) {
+            run(batch);
+            batch = [];
+            count = 0;
+          }
+          batch.push(request);
+          count += request.pids.length;
+        }
+        run(batch);
+      });
+    });
+  }
+  const { stdout } = await exec("/bin/ps", ["-axo", "pid=,ppid=,uid=,lstart="], {
+    timeout: 5e3,
+    maxBuffer: 4 * 1024 * 1024
+  });
+  const processes = stdout.trim().split("\n").map((line) => {
+    const match = /^\s*(\d+)\s+(\d+)\s+(-?\d+)\s+(.+)$/.exec(line);
+    if (!match)
+      throw new Error("Invalid process observation; retirement remains blocked.");
+    return { pid: Number(match[1]), parent: Number(match[2]), owner: match[3], born: match[4].trim() };
+  });
+  return { owner: String(process.getuid?.()), processes };
+}
+async function ownedProcessTree(pid) {
+  const inventory = await processInventory([pid], true);
+  const root = inventory.processes.find((p) => p.pid === pid);
+  if (!root || !root.born || root.owner !== inventory.owner)
+    throw new Error("Legacy daemon process ownership could not be verified.");
+  const result = [root];
+  for (let i = 0; i < result.length; i++)
+    for (const p of inventory.processes)
+      if (p.parent === result[i].pid && !result.some((item) => item.pid === p.pid)) {
+        if (!p.born || p.owner !== inventory.owner)
+          throw new Error("Legacy child ownership could not be verified.");
+        result.push(p);
+      }
+  return result;
+}
+async function awaitRetirement(identities) {
+  if (!identities.length)
+    return;
+  const deadline = Date.now() + 5e3;
+  while (Date.now() < deadline) {
+    let alive = false;
+    for (let offset = 0; offset < identities.length; offset += MAX_TARGETS) {
+      const batch = identities.slice(offset, offset + MAX_TARGETS);
+      const { processes } = await processInventory(batch.map((item) => item.pid));
+      for (const old of batch) {
+        const current = processes.find((item) => item.pid === old.pid);
+        if (!current)
+          continue;
+        if (!current.born || !current.owner)
+          throw new Error("Process ownership could not be verified; retirement remains blocked.");
+        if (current.born === old.born.trim()) {
+          if (current.owner !== old.owner)
+            throw new Error("Process ownership could not be verified; retirement remains blocked.");
+          alive = true;
+        }
+      }
+    }
+    if (!alive)
+      return;
+    await new Promise((r) => setTimeout(r, 50));
+  }
+  throw new Error("Verified legacy processes have not retired; cutover remains blocked. No process was signalled.");
+}
+
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/daemon/migration.js
+import fs2 from "node:fs/promises";
+import net2 from "node:net";
+import path2 from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/daemon/idle-timer.js
+var MAX_NATIVE_TIMER_MS = 2147483647;
+function idleTimerDelay(timeoutMs, lastActivity) {
+  const remaining = timeoutMs - (Date.now() - lastActivity);
+  return Math.min(MAX_NATIVE_TIMER_MS, Math.max(1, remaining > 0 ? remaining : timeoutMs));
+}
+
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/daemon/broker.js
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/daemon/view-codec.js
+var command = external_exports.discriminatedUnion("kind", [
+  external_exports.object({
+    kind: external_exports.literal("stdio"),
+    command: external_exports.string().min(1),
+    args: external_exports.array(external_exports.string()).max(1024),
+    cwd: external_exports.string().min(1)
+  }).strict(),
+  external_exports.object({ kind: external_exports.literal("http"), url: external_exports.string().url(), headers: external_exports.record(external_exports.string(), external_exports.string()).optional() }).strict()
+]);
+var definition = external_exports.object({
+  ...RawEntrySchema.shape,
+  name: external_exports.string().min(1).max(256),
+  configuredEnv: external_exports.record(external_exports.string(), external_exports.string()).optional(),
+  launchCommand: external_exports.string().min(1).optional(),
+  command,
+  lifecycle: external_exports.object({ mode: external_exports.enum(["keep-alive", "ephemeral"]), idleTimeoutMs: external_exports.number().positive().optional() }).optional(),
+  source: external_exports.unknown().optional(),
+  sources: external_exports.unknown().optional()
+}).strip();
+var registration = external_exports.object({
+  definitions: external_exports.array(definition).max(256),
+  clientInfo: external_exports.object({ name: external_exports.string().min(1).max(256), version: external_exports.string().min(1).max(256) }).optional()
+}).strict();
+function decodeView(value) {
+  const parsed = registration.parse(value);
+  const names = /* @__PURE__ */ new Set();
+  const definitions = parsed.definitions.map((entry) => {
+    if (names.has(entry.name))
+      throw new Error("Duplicate view alias.");
+    names.add(entry.name);
+    if (entry.allowedTools && entry.blockedTools)
+      throw new Error("Conflicting tool filters.");
+    const { source: _source, sources: _sources, ...rest } = entry;
+    const decodedCommand = entry.command.kind === "http" ? { kind: "http", url: new URL(entry.command.url), headers: entry.command.headers } : entry.command;
+    return Object.assign(rest, { command: decodedCommand });
+  });
+  return { definitions, clientInfo: parsed.clientInfo };
+}
+
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/daemon/broker.js
+var notices = new AsyncLocalStorage();
+var BrokerError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+};
+var DaemonBroker = class {
+  generation = randomUUID();
+  views = /* @__PURE__ */ new Map();
+  entries = /* @__PURE__ */ new Map();
+  owner;
+  draining = false;
+  activeRequests = 0;
+  constructor(canonical = []) {
+    this.owner = new BrowserOwner(canonical);
+  }
+  register(params) {
+    this.expireViews();
+    if (this.draining)
+      throw new BrokerError("daemon_draining", "Daemon is draining.");
+    if (this.views.size >= 1024)
+      throw new BrokerError("view_limit", "Too many active config views; release abandoned clients.");
+    const { definitions, clientInfo = { name: "mcporter", version: MCPORTER_VERSION } } = decodeView(params);
+    const view = randomUUID();
+    this.views.set(view, {
+      definitions: new Map(definitions.map((def) => [def.name, def])),
+      lastUsed: Date.now(),
+      active: 0,
+      clientInfo
+    });
+    return { view, generation: this.generation };
+  }
+  release(request) {
+    this.getView(request);
+    this.views.delete(request.view);
+  }
+  getView(request) {
+    if (request.generation !== this.generation)
+      throw new BrokerError("daemon_generation_changed", "Daemon generation changed; register before a new operation. The request was not replayed.");
+    const view = this.views.get(request.view ?? "");
+    if (!view)
+      throw new BrokerError("view_expired", "Config view expired; register before a new operation.");
+    view.lastUsed = Date.now();
+    return view;
+  }
+  async invokeWithNotices(request) {
+    const messages = /* @__PURE__ */ new Set();
+    const result = await notices.run(messages, () => this.invoke(request));
+    return { result, notices: [...messages] };
+  }
+  makeRuntime(definition2, clientInfo) {
+    return withRuntimeEnvironment(definition2.env ?? {}, () => createRuntime({
+      servers: [definition2],
+      clientInfo,
+      logger: { info() {
+      }, warn() {
+      }, error() {
+      } },
+      oauthTimeoutMs: resolveOAuthTimeoutFromEnv(),
+      elicitationHandler: createNonInteractiveElicitationResponder({
+        onDecline: () => notices.getStore()?.add(NON_INTERACTIVE_ELICITATION_HINT)
+      }).handler
+    }));
+  }
+  async invoke(request) {
+    if (this.draining)
+      throw new BrokerError("daemon_draining", "Daemon is draining.");
+    const view = this.getView(request);
+    const params = request.params;
+    if (!params || typeof params.server !== "string")
+      throw new BrokerError("invalid_params", "A view-local alias is required.");
+    const viewDefinition = view.definitions.get(params.server);
+    if (!viewDefinition)
+      throw new BrokerError("server_not_in_view", "Server is not authorized in this config view.");
+    if (request.method === "closeServer")
+      return true;
+    if (request.method === "callTool" && (typeof params.tool !== "string" || !isToolAllowed(params.tool, viewDefinition)))
+      throw new BrokerError("tool_not_allowed", "Tool is not accessible in this config view (blocked by configuration).");
+    if (params.timeoutMs !== void 0 && (!Number.isFinite(params.timeoutMs) || params.timeoutMs <= 0))
+      throw new BrokerError("invalid_params", "Invalid timeout.");
+    const chrome = isChromeDefinition(viewDefinition);
+    if (chrome && JSON.stringify(view.clientInfo) !== JSON.stringify({ name: "mcporter", version: MCPORTER_VERSION }))
+      throw new BrokerError("browser_owner_conflict", "Existing Chrome requires the canonical MCP client identity.");
+    const definition2 = this.owner.reserve(viewDefinition);
+    const identity = connectionIdentity(definition2);
+    view.active++;
+    this.activeRequests++;
+    try {
+      const relay = chrome ? await this.owner.resolveIdentity(definition2) : "";
+      const policy = definition2.command.kind === "stdio" ? { allowCachedAuth: true, disableOAuth: false } : {
+        allowCachedAuth: params.allowCachedAuth ?? true,
+        disableOAuth: params.disableOAuth === true || (request.method === "listTools" || request.method === "getServerMetadata") && params.autoAuthorize === false
+      };
+      const key = `${identity}:${relay}:${JSON.stringify(policy)}:${JSON.stringify(view.clientInfo)}`;
+      let entry = this.entries.get(key);
+      if (!entry) {
+        if (this.entries.size >= 256)
+          throw new BrokerError("transport_limit", "Transport capacity reached; drain unused transports with daemon stop.");
+        const pooled = { ...definition2, allowedTools: void 0, blockedTools: void 0 };
+        authorizeBrokerDefinition(pooled, chrome ? () => this.owner.resolveIdentity(definition2) : void 0);
+        entry = {
+          id: randomUUID(),
+          definition: pooled,
+          runtime: this.makeRuntime(pooled, view.clientInfo),
+          active: 0,
+          lastUsed: Date.now(),
+          state: "pending",
+          chrome,
+          serial: Promise.resolve(),
+          generation: 1,
+          policy,
+          clientInfo: view.clientInfo
+        };
+        this.entries.set(key, entry);
+      }
+      const target = entry;
+      const run = () => withRuntimeEnvironment(target.definition.env ?? {}, async () => {
+        if (chrome)
+          await this.owner.resolveIdentity(definition2);
+        if (target.state === "retirement-failed")
+          throw new BrokerError("transport_retirement_failed", "Old transport retirement is unverified; no replacement was launched.");
+        if (target.state === "disconnected" || target.state === "idle") {
+          try {
+            if (target.state !== "idle")
+              await this.retire(target);
+          } catch (error) {
+            target.state = "retirement-failed";
+            throw error;
+          }
+          target.runtime = this.makeRuntime(target.definition, target.clientInfo);
+          target.connection = void 0;
+          target.processes = void 0;
+          target.uncertain = false;
+          target.generation++;
+          target.state = "pending";
+        }
+        const runtime = await target.runtime;
+        if (!target.connection) {
+          target.connection = runtime.connect(target.definition.name, policy).then(async (context2) => {
+            const pid = context2.transport.pid;
+            const generation = target.generation;
+            const previous = context2.client.onclose;
+            context2.client.onclose = () => {
+              if (target.generation === generation && target.state !== "retirement-failed") {
+                target.state = "disconnected";
+              }
+              previous?.();
+            };
+            target.state = "connected";
+            if (pid) {
+              try {
+                target.processes = await ownedProcessTree(pid);
+              } catch (error) {
+                throw new BrokerError("transport_retirement_failed", error instanceof ProcessObservationError ? error.message : "Transport ownership could not be verified; inspect it before recovery.");
+              }
+            }
+            return context2;
+          }).catch((error) => {
+            target.connection = void 0;
+            if (error && typeof error === "object" && "code" in error && error.code === "transport_retirement_failed")
+              target.state = "retirement-failed";
+            throw error;
+          });
+        }
+        const context = await target.connection;
+        const server = target.definition.name;
+        try {
+          switch (request.method) {
+            case "getServerMetadata": {
+              if (chrome)
+                await this.owner.resolveIdentity(definition2);
+              const info = context.client.getServerVersion();
+              return {
+                instructions: context.client.getInstructions(),
+                serverInfo: info ? { name: info.name, version: info.version, title: info.title } : void 0
+              };
+            }
+            case "callTool":
+              return await runtime.callTool(server, params.tool, {
+                args: params.args,
+                timeoutMs: params.timeoutMs,
+                disableOAuth: policy.disableOAuth
+              });
+            case "listTools":
+              return filterTools(await runtime.listTools(server, {
+                includeSchema: params.includeSchema,
+                ...policy,
+                timeoutMs: params.timeoutMs
+              }), viewDefinition);
+            case "listResources":
+              return await runtime.listResources(server, { ...params.params, ...policy });
+            case "readResource":
+              if (typeof params.uri !== "string")
+                throw new BrokerError("invalid_params", "Resource URI required.");
+              return await runtime.readResource(server, params.uri, policy);
+            default:
+              throw new BrokerError("unknown_method", "Unknown daemon operation.");
+          }
+        } catch (error) {
+          const code = error && typeof error === "object" && "code" in error ? error.code : void 0;
+          if (code === SdkErrorCode.ConnectionClosed || code === SdkErrorCode.NotConnected) {
+            target.state = "disconnected";
+          }
+          if (code === SdkErrorCode.RequestTimeout || error instanceof Error && error.message === "Timeout") {
+            target.uncertain = true;
+            throw new BrokerError("operation_timeout", "Operation timed out; outcome unknown. It was not replayed and the connection was retained.");
+          }
+          if (isOAuthFlowError(error))
+            throw new BrokerError("oauth_flow_error", "Authorization failed. Authenticate this server explicitly; the operation was not replayed.");
+          throw error;
+        }
+      });
+      target.active++;
+      clearTimeout(target.idleTimer);
+      const operation = target.serial.then(run, run);
+      target.serial = operation.catch(() => {
+      });
+      try {
+        return await operation;
+      } finally {
+        target.active--;
+        target.lastUsed = Date.now();
+        this.scheduleIdle(target);
+      }
+    } finally {
+      view.active--;
+      this.activeRequests--;
+    }
+  }
+  status() {
+    this.expireViews();
+    const entries = [...this.entries.values()];
+    const owner = entries.find((entry) => entry.chrome);
+    return {
+      generation: this.generation,
+      views: this.views.size,
+      servers: entries.map((entry) => ({
+        name: entry.id,
+        connectionId: entry.id,
+        connectionGeneration: entry.generation,
+        connected: entry.state === "connected",
+        activeCalls: entry.active,
+        lastUsedAt: entry.lastUsed,
+        idleTimeoutMs: entry.definition.lifecycle?.mode === "keep-alive" ? entry.definition.lifecycle.idleTimeoutMs : void 0,
+        idleBlocked: entry.chrome ? "browser-owner" : entry.uncertain ? "unknown-outcome" : void 0,
+        chromeDevtoolsRelay: getChromeDevtoolsRelayDecision(entry.definition.name)
+      })),
+      browserOwner: owner ? { connectionId: owner.id, state: owner.state } : void 0
+    };
+  }
+  async close() {
+    this.draining = true;
+    if (this.activeRequests > 0)
+      throw new BrokerError("active_calls", "Active calls are still running; wait for completion before stopping.");
+    for (const entry of this.entries.values()) {
+      clearTimeout(entry.idleTimer);
+      await entry.serial;
+      if (entry.state === "retirement-failed" && !entry.processes)
+        throw new BrokerError("transport_retirement_failed", "Retirement is unverified; inspect the previous transport before stopping this owner.");
+      if (entry.state !== "idle")
+        await this.retire(entry);
+    }
+    this.entries.clear();
+    this.views.clear();
+  }
+  canIdleShutdown() {
+    return !this.draining && this.activeRequests === 0 && !this.owner.reserved && [...this.entries.values()].every((entry) => !entry.active && !entry.uncertain && entry.state !== "retirement-failed");
+  }
+  async retire(entry) {
+    await withRuntimeEnvironment(entry.definition.env ?? {}, async () => {
+      await (await entry.runtime).close();
+      if (entry.processes)
+        await awaitRetirement(entry.processes);
+    });
+  }
+  scheduleIdle(entry) {
+    if (this.draining || entry.chrome || entry.active || entry.uncertain || entry.state === "retirement-failed")
+      return;
+    const timeout = entry.definition.lifecycle?.mode === "keep-alive" ? entry.definition.lifecycle.idleTimeoutMs : void 0;
+    if (!timeout)
+      return;
+    clearTimeout(entry.idleTimer);
+    entry.idleTimer = setTimeout(() => {
+      if (Date.now() - entry.lastUsed < timeout) {
+        this.scheduleIdle(entry);
+        return;
+      }
+      entry.serial = entry.serial.then(async () => {
+        if (entry.active || this.draining)
+          return;
+        entry.state = "disconnected";
+        try {
+          await this.retire(entry);
+          entry.state = "idle";
+        } catch {
+          entry.state = "retirement-failed";
+        }
+      });
+    }, idleTimerDelay(timeout, entry.lastUsed));
+    entry.idleTimer.unref();
+  }
+  expireViews() {
+    const cutoff = Date.now() - 15 * 6e4;
+    for (const [id, view] of this.views)
+      if (!view.active && view.lastUsed < cutoff)
+        this.views.delete(id);
+  }
+};
+
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/daemon/migration.js
+async function probeDaemon(socketPath, method = "status") {
+  return new Promise((resolve) => {
+    const socket = net2.createConnection(socketPath);
+    let buffer = "";
+    let done = false;
+    const finish = (value) => {
+      if (!done) {
+        done = true;
+        socket.destroy();
+        resolve(value);
+      }
+    };
+    socket.setTimeout(1e3, () => finish(null));
+    socket.on("error", () => finish(null));
+    socket.on("connect", () => socket.write(JSON.stringify({ id: randomUUID2(), method, params: {} })));
+    socket.on("data", (chunk) => {
+      buffer += chunk.toString();
+      if (buffer.length > 1024 * 1024) {
+        finish(null);
+        return;
+      }
+      try {
+        const response = JSON.parse(buffer.trim());
+        finish(response.ok ? response.result ?? null : null);
+      } catch {
+      }
+    });
+    socket.on("end", () => finish(null));
+  });
+}
+function legacyDirectories() {
+  const dirs = /* @__PURE__ */ new Set([daemonRunDir()]);
+  if (!process.env.MCPORTER_DAEMON_DIR)
+    dirs.add(path2.join(mcporterDir("state"), "daemon"));
+  return dirs;
+}
+async function legacyDaemons() {
+  const result = [];
+  for (const dir of legacyDirectories()) {
+    if (!await inspectLegacyDaemonDirectory(dir))
+      continue;
+    const files = await fs2.readdir(dir).catch((error) => {
+      if (error.code === "ENOENT")
+        return [];
+      throw error;
+    });
+    for (const name of files.filter((file) => /^daemon-[a-f0-9]+\.json$/.test(file))) {
+      const file = path2.join(dir, name);
+      const info = await fs2.lstat(file);
+      if (!info.isFile() || process.platform !== "win32" && info.uid !== process.getuid?.())
+        throw new BrokerError("legacy_daemon_unverified", "Legacy daemon metadata ownership cannot be verified. Resolve it manually before cutover.");
+      const data = JSON.parse(await fs2.readFile(file, "utf8"));
+      if (!Number.isSafeInteger(data.pid) || data.pid <= 0 || typeof data.socketPath !== "string")
+        throw new BrokerError("legacy_daemon_unverified", "Malformed legacy metadata requires manual inspection.");
+      if (!isProcessRunning(data.pid))
+        continue;
+      const expected = process.platform === "win32" ? `\\\\.\\pipe\\mcporter-${name.slice(0, -5)}` : path2.join(dir, name.replace(/\.json$/, ".sock"));
+      const live = data.socketPath === expected ? await probeDaemon(expected) : null;
+      const verified = !!live && typeof live === "object" && live.pid === data.pid && live.socketPath === expected && (live.protocolVersion ?? 1) < 3;
+      result.push({ pid: data.pid, socketPath: expected, verified });
+    }
+  }
+  return result;
+}
+async function assertLegacyDrained() {
+  if (await fs2.stat(path2.join(daemonRunDir(), "legacy-retirement.json")).catch(() => void 0))
+    throw new BrokerError("legacy_retirement_pending", "Legacy retirement is unverified; inspect daemon migrate before cutover.");
+  if ((await legacyDaemons()).length)
+    throw new BrokerError("legacy_daemon_conflict", "Live legacy per-config daemon ownership remains. Upgrade all invoking clients, drain old calls, then run daemon migrate --stop-legacy --confirmed-drained. No process was stopped.");
+}
+async function stopVerifiedLegacyDaemons() {
+  const directories = legacyDirectories();
+  for (const directory of directories)
+    await inspectLegacyDaemonDirectory(directory);
+  for (const directory of directories)
+    await upgradeLegacyDaemonDirectory(directory);
+  await secureDaemonDirectory();
+  const marker = path2.join(daemonRunDir(), "legacy-retirement.json");
+  const pending2 = await fs2.readFile(marker, "utf8").then((raw) => JSON.parse(raw)).catch((error) => {
+    if (error.code !== "ENOENT")
+      throw error;
+    return void 0;
+  });
+  if (pending2) {
+    if (!Array.isArray(pending2.processes) || pending2.processes.length === 0 || !pending2.processes.every((p) => Number.isSafeInteger(p.pid) && p.pid > 0 && typeof p.born === "string" && typeof p.owner === "string"))
+      throw new Error("Invalid legacy retirement marker; manual inspection required.");
+    await awaitRetirement(pending2.processes);
+    await fs2.unlink(marker);
+  }
+  const legacy = await legacyDaemons();
+  if (legacy.some((entry) => !entry.verified))
+    throw new BrokerError("legacy_daemon_unverified", "Legacy process ownership is unverified; no process was stopped.");
+  for (const entry of legacy) {
+    const live = await probeDaemon(entry.socketPath);
+    if (!live || typeof live !== "object" || live.pid !== entry.pid || live.socketPath !== entry.socketPath)
+      throw new BrokerError("legacy_daemon_unverified", "Legacy owner changed during cutover.");
+    const processes = await ownedProcessTree(entry.pid);
+    await writeJsonFile(marker, { processes });
+    if (!await probeDaemon(entry.socketPath, "stop"))
+      throw new BrokerError("legacy_stop_failed", "Verified legacy daemon did not accept stop; retirement remains blocked.");
+    await awaitRetirement(processes);
+    await fs2.unlink(marker);
+  }
+}
+
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/daemon/startup-readiness.js
+var DAEMON_STARTUP_TIMEOUT_MS = 45e3;
+var DAEMON_STARTUP_SLOW_NOTICE_MS = 5e3;
+var DAEMON_STARTUP_POLL_INTERVAL_MS = 100;
+async function waitForDaemonReady(probe, timing = {}) {
+  const now = timing.now ?? Date.now;
+  const wait = timing.delay ?? delay;
+  const reportSlowStart = timing.reportSlowStart ?? defaultSlowStartReporter;
+  const startedAt = now();
+  const deadline = startedAt + DAEMON_STARTUP_TIMEOUT_MS;
+  let reportedSlowStart = false;
+  while (true) {
+    const remainingBeforeProbe = deadline - now();
+    if (remainingBeforeProbe <= 0) {
+      throw daemonStartupTimeoutError();
+    }
+    const result = await probe(Math.min(DAEMON_STARTUP_POLL_INTERVAL_MS, remainingBeforeProbe)).catch((error) => {
+      if (error && typeof error === "object" && "code" in error && error.code === "ETIMEDOUT")
+        return null;
+      throw error;
+    });
+    if (result !== null) {
+      return result;
+    }
+    const currentTime = now();
+    if (currentTime >= deadline) {
+      throw daemonStartupTimeoutError();
+    }
+    if (!reportedSlowStart && currentTime - startedAt >= DAEMON_STARTUP_SLOW_NOTICE_MS) {
+      reportedSlowStart = true;
+      reportSlowStart();
+    }
+    await wait(Math.min(DAEMON_STARTUP_POLL_INTERVAL_MS, deadline - currentTime));
+  }
+}
+function defaultSlowStartReporter() {
+  console.error("[mcporter] Daemon startup is taking longer than usual; Chrome relay discovery can take up to 30 seconds.");
+}
+function daemonStartupTimeoutError() {
+  return new Error("MCPorter daemon did not become ready within 45 seconds. Run 'mcporter daemon start --foreground --log' to diagnose startup.");
+}
+function delay(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+// node_modules/.pnpm/mcporter@0.13.10/node_modules/mcporter/dist/daemon/client.js
+var DEFAULT_DAEMON_TIMEOUT_MS = 3e4;
+function resolveDaemonPaths(configPath) {
+  const key = "user";
+  void configPath;
+  return {
+    key,
+    socketPath: getDaemonSocketPath(key),
+    metadataPath: getDaemonMetadataPath(key)
+  };
+}
+var DaemonClient = class {
+  options;
+  socketPath;
+  metadataPath;
+  startingPromise = null;
+  constructor(options) {
+    this.options = options;
+    const paths = resolveDaemonPaths(options.configPath);
+    this.socketPath = paths.socketPath;
+    this.metadataPath = paths.metadataPath;
+  }
+  async callTool(params) {
+    return this.invoke("callTool", params, params.timeoutMs);
+  }
+  async listTools(params) {
+    return this.invoke("listTools", params, params.timeoutMs);
+  }
+  async listResources(params) {
+    return this.invoke("listResources", params);
+  }
+  async readResource(params) {
+    return this.invoke("readResource", params);
+  }
+  async closeServer(params) {
+    await this.invoke("closeServer", params);
+  }
+  async status(timeoutMs) {
+    return await this.readVerifiedStatus(timeoutMs);
+  }
+  async stop() {
+    try {
+      await this.sendRequest("stop", {});
+    } catch (error) {
+      if (isTransportError(error)) {
+        return;
+      }
+      throw error;
+    }
+  }
+  epoch;
+  retiring = /* @__PURE__ */ new Set();
+  definitions;
+  clientInfo;
+  setDefinitions(definitions, clientInfo) {
+    this.definitions = definitions.map(({ command: command2, ...definition2 }) => ({
+      ...structuredClone(definition2),
+      command: command2.kind === "http" ? { ...structuredClone({ ...command2, url: void 0 }), url: new URL(command2.url) } : structuredClone(command2)
+    }));
+    this.clientInfo = clientInfo ? { ...clientInfo } : void 0;
+    if (this.epoch)
+      void this.retire(this.epoch).catch(() => {
+      });
+  }
+  retire(epoch) {
+    if (this.epoch === epoch)
+      this.epoch = void 0;
+    if (!epoch.release) {
+      epoch.release = (async () => {
+        if (epoch.active)
+          await new Promise((resolve) => {
+            epoch.drained = resolve;
+          });
+        const handle = await epoch.registration?.catch(() => void 0);
+        if (handle)
+          await this.sendRequest("releaseView", {}, void 0, handle);
+      })();
+      this.retiring.add(epoch.release);
+      void epoch.release.finally(() => this.retiring.delete(epoch.release)).catch(() => {
+      });
+    }
+    return epoch.release;
+  }
+  async release() {
+    if (this.epoch)
+      void this.retire(this.epoch).catch(() => {
+      });
+    await Promise.all(this.retiring);
+  }
+  async getServerMetadata(params) {
+    return this.invoke("getServerMetadata", params, params.timeoutMs);
+  }
+  async invoke(method, params, timeoutMs) {
+    const epoch = this.epoch ??= { definitions: this.definitions, clientInfo: this.clientInfo, active: 0 };
+    epoch.active++;
+    try {
+      epoch.registration ??= (async () => {
+        await this.ensureDaemon(timeoutMs);
+        const definitions = epoch.definitions ?? await loadServerDefinitions({
+          configPath: this.options.configExplicit ? this.options.configPath : void 0,
+          rootDir: this.options.rootDir
+        });
+        const effective = await Promise.all(definitions.filter(isKeepAliveServer).map((definition2) => effectiveDefinition(definition2, process.env, "view")));
+        return this.sendRequest("registerView", {
+          definitions: effective,
+          clientInfo: epoch.clientInfo
+        });
+      })();
+      let handle;
+      try {
+        handle = await epoch.registration;
+      } catch (error) {
+        void this.retire(epoch).catch(() => {
+        });
+        throw error;
+      }
+      return await this.sendRequest(method, params, timeoutMs, handle);
+    } catch (error) {
+      const code = error.code;
+      if (code === "daemon_generation_changed" || code === "view_expired" || isTransportError(error))
+        void this.retire(epoch).catch(() => {
+        });
+      throw error;
+    } finally {
+      epoch.active--;
+      if (!epoch.active)
+        epoch.drained?.();
+    }
+  }
+  async ensureDaemon(timeoutMs) {
+    await secureDaemonDirectory();
+    await assertLegacyDrained();
+    if (await this.readVerifiedStatus(timeoutMs))
+      return;
+    const previous = await readDaemonMetadata(this.metadataPath);
+    if (previous && !isProcessRunning(previous.pid))
+      throw new Error("Previous daemon exited unexpectedly; verify retirement of its transports before deliberate recovery. No replacement was launched.");
+    this.startingPromise ??= (async () => {
+      const { launchDaemonDetached } = await import("./launch-ZFY6CM2A.js");
+      await launchDaemonDetached({
+        configPath: this.options.configPath,
+        metadataPath: this.metadataPath,
+        socketPath: this.socketPath
+      });
+      await waitForDaemonReady((timeout) => this.readVerifiedStatus(timeout));
+    })().finally(() => {
+      this.startingPromise = null;
+    });
+    await this.startingPromise;
+  }
+  async readVerifiedStatus(timeoutMs) {
+    const metadata = await readDaemonMetadata(this.metadataPath);
+    if (metadata && metadata.protocolVersion !== DAEMON_PROTOCOL_VERSION && isProcessRunning(metadata.pid))
+      throw new Error("Incompatible daemon: upgrade clients and use deliberate daemon cutover.");
+    let result;
+    try {
+      result = await this.sendRequest("status", {}, timeoutMs);
+    } catch (error) {
+      if (isTransportError(error) && (!metadata || !isProcessRunning(metadata.pid)))
+        return null;
+      throw error;
+    }
+    if (result.socketPath !== this.socketPath || result.protocolVersion !== DAEMON_PROTOCOL_VERSION || !result.generation || !isProcessRunning(result.pid))
+      throw new Error("Incompatible or unverified daemon; no restart attempted.");
+    if (!metadata || metadata.pid !== result.pid)
+      await writeJsonFile(this.metadataPath, result);
+    return result;
+  }
+  async sendRequest(method, params, timeoutOverrideMs, handle) {
+    const progressTiming = resolveProgressTiming(resolveDaemonTimeout(timeoutOverrideMs));
+    const request = {
+      id: randomUUID3(),
+      ...handle,
+      method,
+      params,
+      protocolVersion: DAEMON_PROTOCOL_VERSION,
+      progressIntervalMs: progressTiming.progressIntervalMs
+    };
+    const parsed = await requestDaemon(this.socketPath, request, progressTiming.idleTimeoutMs);
+    for (const notice of parsed.notices ?? []) {
+      console.warn(`[mcporter] ${notice}`);
+    }
+    if (!parsed.ok) {
+      const error = new Error(parsed.error?.message ?? "Daemon error");
+      error.code = parsed.error?.code;
+      throw error;
+    }
+    return parsed.result;
+  }
+};
+function isTransportError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const code = error.code;
+  return code === "ECONNREFUSED" || code === "ENOENT" || code === "ETIMEDOUT" || code === "ECONNRESET";
+}
+function resolveDaemonTimeout(override) {
+  if (typeof override === "number" && Number.isFinite(override) && override > 0) {
+    return override;
+  }
+  const raw = process.env.MCPORTER_DAEMON_TIMEOUT_MS;
+  if (!raw) {
+    return DEFAULT_DAEMON_TIMEOUT_MS;
+  }
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return DEFAULT_DAEMON_TIMEOUT_MS;
+  }
+  return parsed;
+}
+async function readDaemonMetadata(metadataPath) {
+  try {
+    const raw = await fs3.readFile(metadataPath, "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export {
+  DAEMON_PROTOCOL_VERSION,
+  resolveProgressInterval,
+  daemonKey,
+  SocketFrames,
+  authenticateServer,
+  requestDaemon,
+  ProcessObservationError,
+  idleTimerDelay,
+  BrokerError,
+  DaemonBroker,
+  legacyDaemons,
+  assertLegacyDrained,
+  stopVerifiedLegacyDaemons,
+  waitForDaemonReady,
+  resolveDaemonPaths,
+  DaemonClient
+};