replicas-engine 0.1.744 → 0.1.745

package/dist/src/chunk-WYE7EXGQ.js

@@ -0,0 +1,2258 @@
+#!/usr/bin/env node
+import {
+  getAgentDir,
+  getAgentPath,
+  getConfigDirName,
+  isServerDisabled,
+  toStringRecord
+} from "./chunk-NZRMKTVA.js";
+
+// ../node_modules/.bun/pi-mcp-adapter@2.32.1+04b0d7b0bc944965/node_modules/pi-mcp-adapter/config.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync, mkdirSync, renameSync } from "fs";
+import { homedir } from "os";
+import { dirname, join as join2, resolve as resolve3 } from "path";
+
+// ../node_modules/.bun/smol-toml@1.7.0/node_modules/smol-toml/dist/date.js
+var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
+var TomlDate = class _TomlDate extends Date {
+  #hasDate = false;
+  #hasTime = false;
+  #offset = null;
+  constructor(date) {
+    let hasDate = true;
+    let hasTime = true;
+    let offset = "Z";
+    if (typeof date === "string") {
+      let match = date.match(DATE_TIME_RE);
+      if (match) {
+        if (!match[1]) {
+          hasDate = false;
+          date = `0000-01-01T${date}`;
+        }
+        hasTime = !!match[2];
+        hasTime && date[10] === " " && (date = date.replace(" ", "T"));
+        if (match[2] && +match[2] > 23) {
+          date = "";
+        } else {
+          offset = match[3] || null;
+          date = date.toUpperCase();
+          if (!offset && hasTime)
+            date += "Z";
+        }
+      } else {
+        date = "";
+      }
+    }
+    super(date);
+    if (!isNaN(this.getTime())) {
+      this.#hasDate = hasDate;
+      this.#hasTime = hasTime;
+      this.#offset = offset;
+    }
+  }
+  isDateTime() {
+    return this.#hasDate && this.#hasTime;
+  }
+  isLocal() {
+    return !this.#hasDate || !this.#hasTime || !this.#offset;
+  }
+  isDate() {
+    return this.#hasDate && !this.#hasTime;
+  }
+  isTime() {
+    return this.#hasTime && !this.#hasDate;
+  }
+  isValid() {
+    return this.#hasDate || this.#hasTime;
+  }
+  toISOString() {
+    let iso = super.toISOString();
+    if (this.isDate())
+      return iso.slice(0, 10);
+    if (this.isTime())
+      return iso.slice(11, 23);
+    if (this.#offset === null)
+      return iso.slice(0, -1);
+    if (this.#offset === "Z")
+      return iso;
+    let offset = +this.#offset.slice(1, 3) * 60 + +this.#offset.slice(4, 6);
+    offset = this.#offset[0] === "-" ? offset : -offset;
+    let offsetDate = new Date(this.getTime() - offset * 6e4);
+    return offsetDate.toISOString().slice(0, -1) + this.#offset;
+  }
+  static wrapAsOffsetDateTime(jsDate, offset = "Z") {
+    let date = new _TomlDate(jsDate);
+    date.#offset = offset;
+    return date;
+  }
+  static wrapAsLocalDateTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalDate(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasTime = false;
+    date.#offset = null;
+    return date;
+  }
+  static wrapAsLocalTime(jsDate) {
+    let date = new _TomlDate(jsDate);
+    date.#hasDate = false;
+    date.#offset = null;
+    return date;
+  }
+};
+
+// ../node_modules/.bun/smol-toml@1.7.0/node_modules/smol-toml/dist/error.js
+function getLineColFromPtr(string, ptr) {
+  let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
+  return [lines.length, lines.pop().length + 1];
+}
+function makeCodeBlock(string, line, column) {
+  let lines = string.split(/\r\n|\n|\r/g);
+  let codeblock = "";
+  let numberLen = (Math.log10(line + 1) | 0) + 1;
+  for (let i = line - 1; i <= line + 1; i++) {
+    let l = lines[i - 1];
+    if (!l)
+      continue;
+    codeblock += i.toString().padEnd(numberLen, " ");
+    codeblock += ":  ";
+    codeblock += l;
+    codeblock += "\n";
+    if (i === line) {
+      codeblock += " ".repeat(numberLen + column + 2);
+      codeblock += "^\n";
+    }
+  }
+  return codeblock;
+}
+var TomlError = class extends Error {
+  line;
+  column;
+  codeblock;
+  constructor(message, options) {
+    const [line, column] = getLineColFromPtr(options.toml, options.ptr);
+    const codeblock = makeCodeBlock(options.toml, line, column);
+    super(`Invalid TOML document: ${message}
+
+${codeblock}`, options);
+    this.line = line;
+    this.column = column;
+    this.codeblock = codeblock;
+  }
+};
+
+// ../node_modules/.bun/smol-toml@1.7.0/node_modules/smol-toml/dist/primitive.js
+var INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
+var FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
+var LEADING_ZERO = /^[+-]?0[0-9_]/;
+function parseString(str, ptr) {
+  let c = str[ptr++];
+  let first = c;
+  let isLiteral = c === "'";
+  let isMultiline = c === str[ptr] && c === str[ptr + 1];
+  if (isMultiline) {
+    if (str[ptr += 2] === "\n")
+      ptr++;
+    else if (str[ptr] === "\r" && str[ptr + 1] === "\n")
+      ptr += 2;
+  }
+  let parsed = "";
+  let sliceStart = ptr;
+  let state = 0;
+  for (let i = ptr; i < str.length; i++) {
+    c = str[i];
+    if (isMultiline && (c === "\n" || c === "\r" && str[i + 1] === "\n")) {
+      state = state && 3;
+    } else if (c < " " && c !== "	" || c === "\x7F") {
+      throw new TomlError("control characters are not allowed in strings", {
+        toml: str,
+        ptr: i
+      });
+    } else if ((!state || state === 3) && c === first && (!isMultiline || str[i + 1] === first && str[i + 2] === first)) {
+      if (isMultiline) {
+        if (str[i + 3] === first)
+          i++;
+        if (str[i + 3] === first)
+          i++;
+      }
+      return [
+        // If we're in a newline escape still, then there's nothing to add.
+        // Also try to avoid concat if there's nothing to add to parsed, or nothing has been added to parsed.
+        state ? parsed : parsed + str.slice(sliceStart, i),
+        i + (isMultiline ? 3 : 1)
+      ];
+    } else if (!state) {
+      if (!isLiteral && c === "\\") {
+        parsed += str.slice(sliceStart, sliceStart = i);
+        state = 1;
+      }
+    } else if (state === 1) {
+      if (c === "x" || c === "u" || c === "U") {
+        let value = 0;
+        let len = c === "x" ? 2 : c === "u" ? 4 : 8;
+        for (let j = 0; j < len; j++, i++) {
+          let hex = str.charCodeAt(i + 1);
+          let digit = (
+            /* 0-9 */
+            hex >= 48 && hex <= 57 ? hex - 48 : (
+              /* A-F */
+              hex >= 65 && hex <= 70 ? hex - 65 + 10 : (
+                /* a-f */
+                hex >= 97 && hex <= 102 ? hex - 97 + 10 : -1
+              )
+            )
+          );
+          if (digit < 0)
+            throw new TomlError("invalid non-hex character in unicode escape", { toml: str, ptr: i + 1 });
+          value = value << 4 | digit;
+        }
+        if (value < 0 || value > 1114111 || value >= 55296 && value <= 57343) {
+          throw new TomlError("invalid unicode escape", { toml: str, ptr: i });
+        }
+        parsed += String.fromCodePoint(value);
+        sliceStart = i + 1;
+        state = 0;
+      } else if (c === " " || c === "	") {
+        state = 2;
+      } else {
+        if (c === "b")
+          parsed += "\b";
+        else if (c === "t")
+          parsed += "	";
+        else if (c === "n")
+          parsed += "\n";
+        else if (c === "f")
+          parsed += "\f";
+        else if (c === "r")
+          parsed += "\r";
+        else if (c === "e")
+          parsed += "\x1B";
+        else if (c === '"')
+          parsed += '"';
+        else if (c === "\\")
+          parsed += "\\";
+        else
+          throw new TomlError("unrecognized escape sequence", { toml: str, ptr: i });
+        sliceStart = i + 1;
+        state = 0;
+      }
+    } else if (c !== " " && c !== "	") {
+      if (state === 2) {
+        throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
+          toml: str,
+          ptr: sliceStart
+        });
+      }
+      state = !isLiteral && c === "\\" ? 1 : 0;
+      sliceStart = i;
+    }
+  }
+  throw new TomlError("unfinished string", { toml: str, ptr });
+}
+function parseValue(value, toml, ptr, integersAsBigInt) {
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  if (value === "-inf")
+    return -Infinity;
+  if (value === "inf" || value === "+inf")
+    return Infinity;
+  if (value === "nan" || value === "+nan" || value === "-nan")
+    return NaN;
+  if (value === "-0")
+    return integersAsBigInt ? 0n : 0;
+  let isInt = INT_REGEX.test(value);
+  if (isInt || FLOAT_REGEX.test(value)) {
+    if (LEADING_ZERO.test(value)) {
+      throw new TomlError("leading zeroes are not allowed", {
+        toml,
+        ptr
+      });
+    }
+    value = value.replace(/_/g, "");
+    let numeric = +value;
+    if (isNaN(numeric)) {
+      throw new TomlError("invalid number", {
+        toml,
+        ptr
+      });
+    }
+    if (isInt) {
+      if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
+        throw new TomlError("integer value cannot be represented losslessly", {
+          toml,
+          ptr
+        });
+      }
+      if (isInt || integersAsBigInt === true)
+        numeric = BigInt(value);
+    }
+    return numeric;
+  }
+  const date = new TomlDate(value);
+  if (!date.isValid()) {
+    throw new TomlError("invalid value", {
+      toml,
+      ptr
+    });
+  }
+  return date;
+}
+
+// ../node_modules/.bun/smol-toml@1.7.0/node_modules/smol-toml/dist/util.js
+function indexOfNewline(str, start = 0, end = str.length) {
+  let idx = str.indexOf("\n", start);
+  if (str[idx - 1] === "\r")
+    idx--;
+  return idx <= end ? idx : -1;
+}
+function skipComment(str, ptr) {
+  for (let i = ptr; i < str.length; i++) {
+    let c = str[i];
+    if (c === "\n")
+      return i;
+    if (c === "\r" && str[i + 1] === "\n")
+      return i + 1;
+    if (c < " " && c !== "	" || c === "\x7F") {
+      throw new TomlError("control characters are not allowed in comments", {
+        toml: str,
+        ptr
+      });
+    }
+  }
+  return str.length;
+}
+function skipVoid(str, ptr, banNewLines, banComments) {
+  let c;
+  while (1) {
+    while ((c = str[ptr]) === " " || c === "	" || !banNewLines && (c === "\n" || c === "\r" && str[ptr + 1] === "\n"))
+      ptr++;
+    if (banComments || c !== "#")
+      break;
+    ptr = skipComment(str, ptr);
+  }
+  return ptr;
+}
+function skipUntil(str, ptr, sep3, end, banNewLines = false) {
+  if (!end) {
+    ptr = indexOfNewline(str, ptr);
+    return ptr < 0 ? str.length : ptr;
+  }
+  for (let i = ptr; i < str.length; i++) {
+    let c = str[i];
+    if (c === "#") {
+      i = indexOfNewline(str, i);
+    } else if (c === sep3) {
+      return i + 1;
+    } else if (c === end || banNewLines && (c === "\n" || c === "\r" && str[i + 1] === "\n")) {
+      return i;
+    }
+  }
+  throw new TomlError("cannot find end of structure", {
+    toml: str,
+    ptr
+  });
+}
+
+// ../node_modules/.bun/smol-toml@1.7.0/node_modules/smol-toml/dist/extract.js
+function sliceAndTrimEndOf(str, startPtr, endPtr) {
+  let value = str.slice(startPtr, endPtr);
+  let commentIdx = value.indexOf("#");
+  if (commentIdx > -1) {
+    skipComment(str, commentIdx);
+    value = value.slice(0, commentIdx);
+  }
+  return [value.trimEnd(), commentIdx];
+}
+function extractValue(str, ptr, end, depth, integersAsBigInt) {
+  if (depth === 0) {
+    throw new TomlError("document contains excessively nested structures. aborting.", {
+      toml: str,
+      ptr
+    });
+  }
+  let c = str[ptr];
+  if (c === "[" || c === "{") {
+    let [value, endPtr2] = c === "[" ? parseArray(str, ptr, depth, integersAsBigInt) : parseInlineTable(str, ptr, depth, integersAsBigInt);
+    if (end) {
+      endPtr2 = skipVoid(str, endPtr2);
+      if (str[endPtr2] === ",")
+        endPtr2++;
+      else if (str[endPtr2] !== end) {
+        throw new TomlError("expected comma or end of structure", {
+          toml: str,
+          ptr: endPtr2
+        });
+      }
+    }
+    return [value, endPtr2];
+  }
+  if (c === '"' || c === "'") {
+    let [parsed, endPtr2] = parseString(str, ptr);
+    if (end) {
+      endPtr2 = skipVoid(str, endPtr2);
+      if (str[endPtr2] && str[endPtr2] !== "," && str[endPtr2] !== end && str[endPtr2] !== "\n" && str[endPtr2] !== "\r") {
+        throw new TomlError("unexpected character encountered", {
+          toml: str,
+          ptr: endPtr2
+        });
+      }
+      if (str[endPtr2] === ",")
+        endPtr2++;
+    }
+    return [parsed, endPtr2];
+  }
+  let endPtr = skipUntil(str, ptr, ",", end);
+  let slice = sliceAndTrimEndOf(str, ptr, endPtr - (str[endPtr - 1] === "," ? 1 : 0));
+  if (!slice[0]) {
+    throw new TomlError("incomplete key-value declaration: no value specified", {
+      toml: str,
+      ptr
+    });
+  }
+  if (end && slice[1] > -1) {
+    endPtr = skipVoid(str, ptr + slice[1]);
+    if (str[endPtr] === ",")
+      endPtr++;
+  }
+  return [
+    parseValue(slice[0], str, ptr, integersAsBigInt),
+    endPtr
+  ];
+}
+
+// ../node_modules/.bun/smol-toml@1.7.0/node_modules/smol-toml/dist/struct.js
+var KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
+function parseKey(str, ptr, end = "=") {
+  let dot = ptr - 1;
+  let parsed = [];
+  let endPtr = str.indexOf(end, ptr);
+  if (endPtr < 0) {
+    throw new TomlError("incomplete key-value: cannot find end of key", {
+      toml: str,
+      ptr
+    });
+  }
+  do {
+    let c = str[ptr = ++dot];
+    if (c !== " " && c !== "	") {
+      if (c === '"' || c === "'") {
+        if (c === str[ptr + 1] && c === str[ptr + 2]) {
+          throw new TomlError("multiline strings are not allowed in keys", {
+            toml: str,
+            ptr
+          });
+        }
+        let [part, eos] = parseString(str, ptr);
+        dot = str.indexOf(".", eos);
+        let strEnd = str.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot);
+        let newLine = indexOfNewline(strEnd);
+        if (newLine > -1) {
+          throw new TomlError("newlines are not allowed in keys", {
+            toml: str,
+            ptr: ptr + dot + newLine
+          });
+        }
+        if (strEnd.trimStart()) {
+          throw new TomlError("found extra tokens after the string part", {
+            toml: str,
+            ptr: eos
+          });
+        }
+        if (endPtr < eos) {
+          endPtr = str.indexOf(end, eos);
+          if (endPtr < 0) {
+            throw new TomlError("incomplete key-value: cannot find end of key", {
+              toml: str,
+              ptr
+            });
+          }
+        }
+        parsed.push(part);
+      } else {
+        dot = str.indexOf(".", ptr);
+        let part = str.slice(ptr, dot < 0 || dot > endPtr ? endPtr : dot);
+        if (!KEY_PART_RE.test(part)) {
+          throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", {
+            toml: str,
+            ptr
+          });
+        }
+        parsed.push(part.trimEnd());
+      }
+    }
+  } while (dot + 1 && dot < endPtr);
+  return [parsed, skipVoid(str, endPtr + 1, true, true)];
+}
+function parseInlineTable(str, ptr, depth, integersAsBigInt) {
+  let res = {};
+  let seen = /* @__PURE__ */ new Set();
+  let c;
+  ptr++;
+  while ((c = str[ptr++]) !== "}" && c) {
+    if (c === ",") {
+      throw new TomlError("expected value, found comma", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    } else if (c === "#")
+      ptr = skipComment(str, ptr);
+    else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
+      let k;
+      let t = res;
+      let hasOwn = false;
+      let [key, keyEndPtr] = parseKey(str, ptr - 1);
+      for (let i = 0; i < key.length; i++) {
+        if (i)
+          t = hasOwn ? t[k] : t[k] = {};
+        k = key[i];
+        if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
+          throw new TomlError("trying to redefine an already defined value", {
+            toml: str,
+            ptr
+          });
+        }
+        if (!hasOwn && k === "__proto__") {
+          Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        }
+      }
+      if (hasOwn) {
+        throw new TomlError("trying to redefine an already defined value", {
+          toml: str,
+          ptr
+        });
+      }
+      let [value, valueEndPtr] = extractValue(str, keyEndPtr, "}", depth - 1, integersAsBigInt);
+      seen.add(value);
+      t[k] = value;
+      ptr = valueEndPtr;
+    }
+  }
+  if (!c) {
+    throw new TomlError("unfinished table encountered", {
+      toml: str,
+      ptr
+    });
+  }
+  return [res, ptr];
+}
+function parseArray(str, ptr, depth, integersAsBigInt) {
+  let res = [];
+  let c;
+  ptr++;
+  while ((c = str[ptr++]) !== "]" && c) {
+    if (c === ",") {
+      throw new TomlError("expected value, found comma", {
+        toml: str,
+        ptr: ptr - 1
+      });
+    } else if (c === "#")
+      ptr = skipComment(str, ptr);
+    else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
+      let e = extractValue(str, ptr - 1, "]", depth - 1, integersAsBigInt);
+      res.push(e[0]);
+      ptr = e[1];
+    }
+  }
+  if (!c) {
+    throw new TomlError("unfinished array encountered", {
+      toml: str,
+      ptr
+    });
+  }
+  return [res, ptr];
+}
+
+// ../node_modules/.bun/smol-toml@1.7.0/node_modules/smol-toml/dist/parse.js
+function peekTable(key, table, meta, type) {
+  let t = table;
+  let m = meta;
+  let k;
+  let hasOwn = false;
+  let state;
+  for (let i = 0; i < key.length; i++) {
+    if (i) {
+      t = hasOwn ? t[k] : t[k] = {};
+      m = (state = m[k]).c;
+      if (type === 0 && (state.t === 1 || state.t === 2)) {
+        return null;
+      }
+      if (state.t === 2) {
+        let l = t.length - 1;
+        t = t[l];
+        m = m[l].c;
+      }
+    }
+    k = key[i];
+    if ((hasOwn = Object.hasOwn(t, k)) && m[k]?.t === 0 && m[k]?.d) {
+      return null;
+    }
+    if (!hasOwn) {
+      if (k === "__proto__") {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+        Object.defineProperty(m, k, { enumerable: true, configurable: true, writable: true });
+      }
+      m[k] = {
+        t: i < key.length - 1 && type === 2 ? 3 : type,
+        d: false,
+        i: 0,
+        c: {}
+      };
+    }
+  }
+  state = m[k];
+  if (state.t !== type && !(type === 1 && state.t === 3)) {
+    return null;
+  }
+  if (type === 2) {
+    if (!state.d) {
+      state.d = true;
+      t[k] = [];
+    }
+    t[k].push(t = {});
+    state.c[state.i++] = state = { t: 1, d: false, i: 0, c: {} };
+  }
+  if (state.d) {
+    return null;
+  }
+  state.d = true;
+  if (type === 1) {
+    t = hasOwn ? t[k] : t[k] = {};
+  } else if (type === 0 && hasOwn) {
+    return null;
+  }
+  return [k, t, state.c];
+}
+function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
+  let res = {};
+  let meta = {};
+  let tbl = res;
+  let m = meta;
+  for (let ptr = skipVoid(toml, 0); ptr < toml.length; ) {
+    if (toml[ptr] === "[") {
+      let isTableArray = toml[++ptr] === "[";
+      let k = parseKey(toml, ptr += +isTableArray, "]");
+      if (isTableArray) {
+        if (toml[k[1] - 1] !== "]") {
+          throw new TomlError("expected end of table declaration", {
+            toml,
+            ptr: k[1] - 1
+          });
+        }
+        k[1]++;
+      }
+      let p = peekTable(
+        k[0],
+        res,
+        meta,
+        isTableArray ? 2 : 1
+        /* Type.EXPLICIT */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr
+        });
+      }
+      m = p[2];
+      tbl = p[1];
+      ptr = k[1];
+    } else {
+      let k = parseKey(toml, ptr);
+      let p = peekTable(
+        k[0],
+        tbl,
+        m,
+        0
+        /* Type.DOTTED */
+      );
+      if (!p) {
+        throw new TomlError("trying to redefine an already defined table or value", {
+          toml,
+          ptr
+        });
+      }
+      let v = extractValue(toml, k[1], void 0, maxDepth, integersAsBigInt);
+      p[1][p[0]] = v[0];
+      ptr = v[1];
+    }
+    ptr = skipVoid(toml, ptr, true);
+    if (toml[ptr] && toml[ptr] !== "\n" && toml[ptr] !== "\r") {
+      throw new TomlError("each key-value declaration must be followed by an end-of-line", {
+        toml,
+        ptr
+      });
+    }
+    ptr = skipVoid(toml, ptr);
+  }
+  return res;
+}
+
+// ../node_modules/.bun/strip-json-comments@5.0.3/node_modules/strip-json-comments/index.js
+var singleComment = /* @__PURE__ */ Symbol("singleComment");
+var multiComment = /* @__PURE__ */ Symbol("multiComment");
+var stripWithoutWhitespace = () => "";
+var stripWithWhitespace = (string, start, end) => string.slice(start, end).replace(/[^ \t\r\n]/g, " ");
+var isEscaped = (jsonString, quotePosition) => {
+  let index = quotePosition - 1;
+  let backslashCount = 0;
+  while (jsonString[index] === "\\") {
+    index -= 1;
+    backslashCount += 1;
+  }
+  return Boolean(backslashCount % 2);
+};
+function stripJsonComments(jsonString, { whitespace = true, trailingCommas = false } = {}) {
+  if (typeof jsonString !== "string") {
+    throw new TypeError(`Expected argument \`jsonString\` to be a \`string\`, got \`${typeof jsonString}\``);
+  }
+  const strip = whitespace ? stripWithWhitespace : stripWithoutWhitespace;
+  let isInsideString = false;
+  let isInsideComment = false;
+  let offset = 0;
+  let buffer = "";
+  let result = "";
+  let commaIndex = -1;
+  for (let index = 0; index < jsonString.length; index++) {
+    const currentCharacter = jsonString[index];
+    const nextCharacter = jsonString[index + 1];
+    if (!isInsideComment && currentCharacter === '"') {
+      const escaped = isEscaped(jsonString, index);
+      if (!escaped) {
+        isInsideString = !isInsideString;
+      }
+    }
+    if (isInsideString) {
+      continue;
+    }
+    if (!isInsideComment && currentCharacter + nextCharacter === "//") {
+      buffer += jsonString.slice(offset, index);
+      offset = index;
+      isInsideComment = singleComment;
+      index++;
+    } else if (isInsideComment === singleComment && currentCharacter + nextCharacter === "\r\n") {
+      index++;
+      isInsideComment = false;
+      buffer += strip(jsonString, offset, index);
+      offset = index;
+      continue;
+    } else if (isInsideComment === singleComment && currentCharacter === "\n") {
+      isInsideComment = false;
+      buffer += strip(jsonString, offset, index);
+      offset = index;
+    } else if (!isInsideComment && currentCharacter + nextCharacter === "/*") {
+      buffer += jsonString.slice(offset, index);
+      offset = index;
+      isInsideComment = multiComment;
+      index++;
+      continue;
+    } else if (isInsideComment === multiComment && currentCharacter + nextCharacter === "*/") {
+      index++;
+      isInsideComment = false;
+      buffer += strip(jsonString, offset, index + 1);
+      offset = index + 1;
+      continue;
+    } else if (trailingCommas && !isInsideComment) {
+      if (commaIndex !== -1) {
+        if (currentCharacter === "}" || currentCharacter === "]") {
+          buffer += jsonString.slice(offset, index);
+          result += strip(buffer, 0, 1) + buffer.slice(1);
+          buffer = "";
+          offset = index;
+          commaIndex = -1;
+        } else if (currentCharacter !== " " && currentCharacter !== "	" && currentCharacter !== "\r" && currentCharacter !== "\n") {
+          buffer += jsonString.slice(offset, index);
+          offset = index;
+          commaIndex = -1;
+        }
+      } else if (currentCharacter === ",") {
+        result += buffer + jsonString.slice(offset, index);
+        buffer = "";
+        offset = index;
+        commaIndex = index;
+      }
+    }
+  }
+  const remaining = isInsideComment === singleComment ? strip(jsonString, offset) : jsonString.slice(offset);
+  return result + buffer + remaining;
+}
+
+// ../node_modules/.bun/pi-mcp-adapter@2.32.1+04b0d7b0bc944965/node_modules/pi-mcp-adapter/agent-plugin-loader.ts
+import { existsSync, readFileSync, statSync } from "fs";
+import { isAbsolute, relative, resolve, sep } from "path";
+var PLUGIN_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json";
+var MCP_SCHEMA = "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json";
+var PLUGIN_NAME_PATTERN = /^(?!.*(?:--|\.\.))[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$/;
+var PLUGIN_MANIFEST_FIELDS = /* @__PURE__ */ new Set([
+  "$schema",
+  "name",
+  "version",
+  "description",
+  "author",
+  "homepage",
+  "repository",
+  "license",
+  "keywords",
+  "extensions"
+]);
+var MCP_CONFIG_FIELDS = /* @__PURE__ */ new Set(["$schema", "mcpServers"]);
+var STDIO_FIELDS = /* @__PURE__ */ new Set(["type", "command", "args", "env", "cwd"]);
+var HTTP_FIELDS = /* @__PURE__ */ new Set(["type", "url", "headers"]);
+function loadAgentPluginConfigs(paths, cwd = process.cwd()) {
+  const mcpServers = {};
+  for (const pluginPath of getPluginPaths(paths)) {
+    const loaded = loadAgentPluginMcpConfig(pluginPath, cwd);
+    if (!loaded) continue;
+    for (const [serverName, server] of Object.entries(loaded.mcpServers)) {
+      if (mcpServers[serverName]) {
+        console.warn(`Agent Plugin at ${resolvePluginPath(pluginPath, cwd)} skips duplicate normalized MCP server ${serverName}`);
+        continue;
+      }
+      mcpServers[serverName] = server;
+    }
+  }
+  return { mcpServers };
+}
+function getAgentPluginSummaries(paths, cwd = process.cwd()) {
+  return getPluginPaths(paths).map((path) => {
+    const pluginRoot = resolvePluginPath(path, cwd);
+    const loaded = loadAgentPluginMcpConfig(path, cwd);
+    const manifest = loaded ? readPluginManifest(pluginRoot, false) : null;
+    return {
+      path: pluginRoot,
+      ...manifest?.name ? { name: manifest.name } : {},
+      serverCount: loaded ? Object.keys(loaded.mcpServers).length : 0
+    };
+  });
+}
+function getPluginPaths(paths) {
+  return Array.isArray(paths) ? paths.filter((path) => typeof path === "string") : [];
+}
+function loadAgentPluginMcpConfig(path, cwd) {
+  const pluginRoot = resolvePluginPath(path, cwd);
+  const manifest = readPluginManifest(pluginRoot, true);
+  if (!manifest) return null;
+  const mcpPath = resolve(pluginRoot, "mcp.json");
+  if (!existsSync(mcpPath)) return { mcpServers: {} };
+  if (!statSync(mcpPath).isFile()) {
+    console.warn(`Agent Plugin ${manifest.name} has invalid MCP config: mcp.json is not a regular file`);
+    return { mcpServers: {} };
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(mcpPath, "utf8"));
+  } catch (error) {
+    console.warn(`Agent Plugin ${manifest.name} has invalid MCP config: failed to parse mcp.json`, error);
+    return { mcpServers: {} };
+  }
+  return translateAgentPluginMcpConfig(raw, manifest, pluginRoot);
+}
+function readPluginManifest(pluginRoot, report) {
+  const manifestPath = resolve(pluginRoot, "plugin.json");
+  if (!existsSync(manifestPath)) {
+    if (report) console.warn(`Agent Plugin at ${pluginRoot} is invalid: missing plugin.json`);
+    return null;
+  }
+  if (!statSync(manifestPath).isFile()) {
+    if (report) console.warn(`Agent Plugin at ${pluginRoot} is invalid: plugin.json is not a regular file`);
+    return null;
+  }
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(manifestPath, "utf8"));
+  } catch (error) {
+    if (report) console.warn(`Agent Plugin at ${pluginRoot} is invalid: failed to parse plugin.json`, error);
+    return null;
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    if (report) console.warn(`Agent Plugin at ${pluginRoot} is invalid: plugin.json must be an object`);
+    return null;
+  }
+  const manifest = raw;
+  for (const key of Object.keys(manifest)) {
+    if (!PLUGIN_MANIFEST_FIELDS.has(key) && report) {
+      console.warn(`Agent Plugin at ${pluginRoot} ignores unknown plugin.json field: ${key}`);
+    }
+  }
+  if (manifest.$schema !== PLUGIN_SCHEMA) {
+    if (report) console.warn(`Agent Plugin at ${pluginRoot} is invalid: unsupported plugin.json $schema`);
+    return null;
+  }
+  if (typeof manifest.name !== "string" || manifest.name.length < 1 || manifest.name.length > 64 || !PLUGIN_NAME_PATTERN.test(manifest.name)) {
+    if (report) console.warn(`Agent Plugin at ${pluginRoot} is invalid: plugin.json name is invalid`);
+    return null;
+  }
+  if (manifest.extensions !== void 0 && (!manifest.extensions || typeof manifest.extensions !== "object" || Array.isArray(manifest.extensions))) {
+    if (report) console.warn(`Agent Plugin ${manifest.name} ignores non-object plugin.json extensions`);
+  }
+  return { name: manifest.name };
+}
+function translateAgentPluginMcpConfig(raw, manifest, pluginRoot) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    console.warn(`Agent Plugin ${manifest.name} has invalid MCP config: mcp.json must be an object`);
+    return { mcpServers: {} };
+  }
+  const mcpConfig = raw;
+  for (const key of Object.keys(mcpConfig)) {
+    if (!MCP_CONFIG_FIELDS.has(key)) {
+      console.warn(`Agent Plugin ${manifest.name} has invalid MCP config: unknown top-level field ${key}`);
+      return { mcpServers: {} };
+    }
+  }
+  if (mcpConfig.$schema !== MCP_SCHEMA) {
+    console.warn(`Agent Plugin ${manifest.name} has invalid MCP config: unsupported mcp.json $schema`);
+    return { mcpServers: {} };
+  }
+  if (!mcpConfig.mcpServers || typeof mcpConfig.mcpServers !== "object" || Array.isArray(mcpConfig.mcpServers)) {
+    console.warn(`Agent Plugin ${manifest.name} has invalid MCP config: mcpServers must be an object`);
+    return { mcpServers: {} };
+  }
+  const mcpServers = {};
+  for (const [serverName, entry] of Object.entries(mcpConfig.mcpServers)) {
+    const translated = translateAgentPluginServer(manifest, pluginRoot, serverName, entry);
+    if (!translated) continue;
+    const normalizedName = formatAgentPluginServerName(manifest.name, serverName);
+    if (mcpServers[normalizedName]) {
+      console.warn(`Agent Plugin ${manifest.name} skips invalid MCP server ${serverName}: normalized server name ${normalizedName} already exists`);
+      continue;
+    }
+    mcpServers[normalizedName] = translated;
+  }
+  return { mcpServers };
+}
+function translateAgentPluginServer(manifest, pluginRoot, serverName, entry) {
+  if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+    console.warn(`Agent Plugin ${manifest.name} skips invalid MCP server ${serverName}: entry must be an object`);
+    return null;
+  }
+  const raw = entry;
+  if (raw.type === "stdio") return translateStdioServer(manifest, pluginRoot, serverName, raw);
+  if (raw.type === "streamable-http" || raw.type === "sse") return translateHttpServer(manifest, serverName, raw, raw.type);
+  console.warn(`Agent Plugin ${manifest.name} skips invalid MCP server ${serverName}: unsupported type`);
+  return null;
+}
+function translateStdioServer(manifest, pluginRoot, serverName, raw) {
+  for (const key of Object.keys(raw)) {
+    if (!STDIO_FIELDS.has(key)) return skipServer(manifest, serverName, `unknown field ${key}`);
+  }
+  if (typeof raw.command !== "string" || raw.command.length === 0) return skipServer(manifest, serverName, "command must be a non-empty string");
+  if (!isBareCommand(raw.command) && !raw.command.startsWith("./")) return skipServer(manifest, serverName, "command must be bare or plugin-relative");
+  const args = translateStringArray(raw.args, manifest, serverName, "args");
+  if (args === null) return null;
+  const env = translateEnv(raw.env, manifest, serverName);
+  if (env === null) return null;
+  const command = raw.command.startsWith("./") ? resolveContainedPath(pluginRoot, raw.command, pluginRoot) : raw.command;
+  if (command === null) return skipServer(manifest, serverName, "command must stay inside the plugin directory");
+  const pluginDataDir = getAgentPath("agent-plugin-data", manifest.name);
+  const cwd = resolvePluginCwd(raw.cwd, pluginRoot, pluginDataDir);
+  if (cwd === null) return skipServer(manifest, serverName, "cwd must be plugin-relative, PLUGIN_ROOT-rooted, or PLUGIN_DATA-rooted");
+  return {
+    command,
+    args: args.map((value) => expandPluginPlaceholders(value, pluginRoot, pluginDataDir)),
+    env: {
+      ...Object.fromEntries(Object.entries(env).map(([key, value]) => [key, expandPluginPlaceholders(value, pluginRoot, pluginDataDir)])),
+      PLUGIN_ROOT: pluginRoot,
+      PLUGIN_DATA: pluginDataDir
+    },
+    cwd,
+    pluginDataDir,
+    literalEnv: true
+  };
+}
+function translateHttpServer(manifest, serverName, raw, type) {
+  for (const key of Object.keys(raw)) {
+    if (!HTTP_FIELDS.has(key)) return skipServer(manifest, serverName, `unknown field ${key}`);
+  }
+  if (typeof raw.url !== "string" || raw.url.length === 0) return skipServer(manifest, serverName, "url must be a non-empty string");
+  if (!isValidAgentPluginUrl(raw.url)) return skipServer(manifest, serverName, "url must be an allowed absolute HTTP(S) URL");
+  const headers = translateHeaders(raw.headers, manifest, serverName);
+  if (headers === null) return null;
+  return {
+    url: raw.url,
+    httpTransport: type,
+    ...headers ? { headers } : {}
+  };
+}
+function formatAgentPluginServerName(pluginName, serverName) {
+  const pluginPart = pluginName.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^[_-]+|[_-]+$/g, "") || "plugin";
+  const serverPart = serverName.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^[_-]+|[_-]+$/g, "") || "server";
+  return `${pluginPart}__${serverPart}`;
+}
+function skipServer(manifest, serverName, reason) {
+  console.warn(`Agent Plugin ${manifest.name} skips invalid MCP server ${serverName}: ${reason}`);
+  return null;
+}
+function translateStringArray(value, manifest, serverName, field) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    console.warn(`Agent Plugin ${manifest.name} skips invalid MCP server ${serverName}: ${field} must be an array of strings`);
+    return null;
+  }
+  return value;
+}
+function translateEnv(value, manifest, serverName) {
+  if (value === void 0) return {};
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    console.warn(`Agent Plugin ${manifest.name} skips invalid MCP server ${serverName}: env must be an object of strings`);
+    return null;
+  }
+  const env = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === "PLUGIN_ROOT" || key === "PLUGIN_DATA") {
+      console.warn(`Agent Plugin ${manifest.name} skips invalid MCP server ${serverName}: env must not define ${key}`);
+      return null;
+    }
+    if (typeof entry !== "string") {
+      console.warn(`Agent Plugin ${manifest.name} skips invalid MCP server ${serverName}: env values must be strings`);
+      return null;
+    }
+    env[key] = entry;
+  }
+  return env;
+}
+function translateHeaders(value, manifest, serverName) {
+  if (value === void 0) return void 0;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    console.warn(`Agent Plugin ${manifest.name} skips invalid MCP server ${serverName}: headers must be an object of strings`);
+    return null;
+  }
+  const headers = {};
+  const seen = /* @__PURE__ */ new Set();
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry !== "string") {
+      console.warn(`Agent Plugin ${manifest.name} skips invalid MCP server ${serverName}: header values must be strings`);
+      return null;
+    }
+    const normalized = key.toLowerCase();
+    if (seen.has(normalized)) {
+      console.warn(`Agent Plugin ${manifest.name} skips invalid MCP server ${serverName}: duplicate header ${key}`);
+      return null;
+    }
+    seen.add(normalized);
+    headers[key] = entry;
+  }
+  try {
+    new Headers(headers);
+  } catch {
+    console.warn(`Agent Plugin ${manifest.name} skips invalid MCP server ${serverName}: headers are not valid HTTP fields`);
+    return null;
+  }
+  return Object.keys(headers).length > 0 ? headers : void 0;
+}
+function resolvePluginPath(path, cwd) {
+  if (path === "~") return resolve(process.env.HOME ?? "", ".");
+  if (path.startsWith("~/")) return resolve(process.env.HOME ?? "", path.slice(2));
+  return isAbsolute(path) ? resolve(path) : resolve(cwd, path);
+}
+function isBareCommand(command) {
+  return !command.includes("/") && !command.includes("\\") && !command.includes("${PLUGIN_ROOT}") && !command.includes("${PLUGIN_DATA}");
+}
+function resolvePluginCwd(value, pluginRoot, pluginDataDir) {
+  if (value === void 0) return pluginRoot;
+  if (typeof value !== "string") return null;
+  if (value.startsWith("./")) return resolveContainedPath(pluginRoot, value, pluginRoot);
+  if (value === "${PLUGIN_ROOT}" || value.startsWith("${PLUGIN_ROOT}/")) {
+    return resolveContainedPath(pluginRoot, value.replace("${PLUGIN_ROOT}", "."), pluginRoot);
+  }
+  if (value === "${PLUGIN_DATA}" || value.startsWith("${PLUGIN_DATA}/")) {
+    return resolveContainedPath(pluginDataDir, value.replace("${PLUGIN_DATA}", "."), pluginDataDir);
+  }
+  return null;
+}
+function resolveContainedPath(root, value, containmentRoot) {
+  const resolved = resolve(root, value);
+  const rel = relative(containmentRoot, resolved);
+  if (rel === "" || !rel.startsWith("..") && !rel.startsWith(sep) && !isAbsolute(rel)) return resolved;
+  return null;
+}
+function expandPluginPlaceholders(value, pluginRoot, pluginDataDir) {
+  return value.replaceAll("${PLUGIN_ROOT}", pluginRoot).replaceAll("${PLUGIN_DATA}", pluginDataDir);
+}
+function isValidAgentPluginUrl(value) {
+  if (value.includes("${") || value.includes("$env:") || value.includes("{env:")) return false;
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    return false;
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") return false;
+  if (url.username || url.password || url.hash) return false;
+  if (url.protocol === "https:") return true;
+  return isLoopbackHost(url.hostname);
+}
+function isLoopbackHost(hostname) {
+  const host = hostname.toLowerCase();
+  if (host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "[::1]") return true;
+  if (/^127(?:\.\d{1,3}){3}$/.test(host)) return true;
+  return false;
+}
+
+// ../node_modules/.bun/pi-mcp-adapter@2.32.1+04b0d7b0bc944965/node_modules/pi-mcp-adapter/package-mcp-loader.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, realpathSync, statSync as statSync2 } from "fs";
+import { isAbsolute as isAbsolute2, join, relative as relative2, resolve as resolve2, sep as sep2 } from "path";
+function loadPackageMcpConfigs(cwd = process.cwd()) {
+  const mcpServers = {};
+  const seen = /* @__PURE__ */ new Set();
+  for (const packageRoot of getConfiguredPackageRoots(cwd)) {
+    const manifest = readPackageManifest(packageRoot);
+    if (!manifest || typeof manifest.name !== "string" || !manifest.name) continue;
+    const paths = getManifestMcpPaths(manifest.pi?.mcp, manifest.name);
+    if (!paths) continue;
+    const packagePrefix = formatPackageName(manifest.name);
+    const packageServers = /* @__PURE__ */ new Set();
+    for (const path of paths) {
+      const configPath = resolvePackageConfigPath(packageRoot, path);
+      if (!configPath) {
+        console.warn(`Pi package ${manifest.name} skips MCP config ${path}: file must stay inside the package`);
+        continue;
+      }
+      const config = readMcpConfig(configPath, manifest.name);
+      if (!config) continue;
+      for (const [serverName, server] of Object.entries(config.mcpServers)) {
+        const normalizedName = `${packagePrefix}__${formatServerName(serverName)}`;
+        if (packageServers.has(normalizedName) || seen.has(normalizedName)) {
+          console.warn(`Pi package ${manifest.name} skips duplicate normalized MCP server ${normalizedName}`);
+          continue;
+        }
+        packageServers.add(normalizedName);
+        seen.add(normalizedName);
+        mcpServers[normalizedName] = server;
+      }
+    }
+  }
+  return { mcpServers };
+}
+function getConfiguredPackageRoots(cwd) {
+  const roots = [];
+  for (const [settingsPath, scope] of [
+    [join(cwd, getConfigDirName(), "settings.json"), "project"],
+    [join(getAgentDir(), "settings.json"), "user"]
+  ]) {
+    const settings = readOptionalJson(settingsPath, `${scope} Pi settings`);
+    if (settings === void 0) continue;
+    if (typeof settings !== "object" || settings === null || Array.isArray(settings)) {
+      throw new Error(`${scope} Pi settings ${settingsPath} must be a JSON object`);
+    }
+    const packages = settings.packages;
+    if (packages === void 0) continue;
+    if (!Array.isArray(packages)) throw new Error(`${scope} Pi settings ${settingsPath} packages must be an array`);
+    for (const entry of packages) {
+      const source = typeof entry === "string" ? entry : entry && typeof entry === "object" && !Array.isArray(entry) && typeof entry.source === "string" ? entry.source : void 0;
+      if (!source) throw new Error(`${scope} Pi settings ${settingsPath} package entries must be strings or objects with a string source`);
+      const root = resolvePackageRoot(source, scope, cwd);
+      if (root && !roots.includes(root)) roots.push(root);
+    }
+  }
+  return roots;
+}
+function resolvePackageRoot(source, scope, cwd) {
+  const baseDir = scope === "user" ? getAgentDir() : join(cwd, getConfigDirName());
+  if (source.startsWith("npm:")) {
+    const name = source.slice(4).trim().match(/^(@?[^@]+(?:\/[^@]+)?)/)?.[1];
+    return name ? resolveContainedPath2(join(baseDir, "npm", "node_modules"), name) : null;
+  }
+  const gitSource = source.startsWith("git:") ? source.slice(4).trim() : /^(?:(?:https?|ssh):\/\/|git@[^:]+:)/.test(source) ? source : null;
+  if (gitSource) {
+    const value = gitSource.replace(/^ssh:\/\/git@/, "").replace(/^git@([^:]+):/, "$1/").replace(/^[a-z]+:\/\//i, "");
+    const path = value.replace(/@[^/]+$/, "").replace(/\.git$/, "");
+    return path && !path.startsWith("/") ? resolveContainedPath2(join(baseDir, "git"), path) : null;
+  }
+  return isAbsolute2(source) ? resolve2(source) : resolve2(baseDir, source);
+}
+function readPackageManifest(packageRoot) {
+  const manifest = readOptionalJson(join(packageRoot, "package.json"), `Pi package manifest ${packageRoot}`);
+  return manifest && typeof manifest === "object" && !Array.isArray(manifest) ? manifest : null;
+}
+function getManifestMcpPaths(value, packageName) {
+  const paths = typeof value === "string" ? [value] : Array.isArray(value) && value.every((path) => typeof path === "string") ? value : null;
+  if (value !== void 0 && !paths) console.warn(`Pi package ${packageName} ignores invalid pi.mcp manifest entry`);
+  return paths;
+}
+function readMcpConfig(path, packageName) {
+  const config = readRequiredJson(path, `Pi package ${packageName} MCP config`);
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new Error(`Pi package ${packageName} MCP config ${path} must be a JSON object`);
+  }
+  const servers = config.mcpServers;
+  if (!servers || typeof servers !== "object" || Array.isArray(servers)) {
+    throw new Error(`Pi package ${packageName} MCP config ${path} must contain a JSON object mcpServers field`);
+  }
+  const mcpServers = {};
+  for (const [name, server] of Object.entries(servers)) {
+    if (!server || typeof server !== "object" || Array.isArray(server)) {
+      throw new Error(`Pi package ${packageName} MCP config ${path} server ${name} must be a JSON object`);
+    }
+    mcpServers[name] = server;
+  }
+  return { mcpServers };
+}
+function readRequiredJson(path, description) {
+  try {
+    return JSON.parse(stripJsonComments(readFileSync2(path, "utf8"), { trailingCommas: true }));
+  } catch (error) {
+    throw new Error(`${description} ${path} contains invalid JSON: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+  }
+}
+function readOptionalJson(path, description) {
+  if (!existsSync2(path)) return void 0;
+  return readRequiredJson(path, description);
+}
+function resolveContainedPath2(root, path) {
+  const resolved = resolve2(root, path);
+  const rel = relative2(root, resolved);
+  return rel === "" || !rel.startsWith("..") && !rel.startsWith(sep2) && !isAbsolute2(rel) ? resolved : null;
+}
+function resolvePackageConfigPath(packageRoot, path) {
+  const lexicalPath = resolveContainedPath2(packageRoot, path);
+  if (!lexicalPath || !existsSync2(lexicalPath) || !statSync2(lexicalPath).isFile()) return null;
+  try {
+    const realPackageRoot = realpathSync(packageRoot);
+    const realConfigPath = realpathSync(lexicalPath);
+    return resolveContainedPath2(realPackageRoot, realConfigPath);
+  } catch {
+    return null;
+  }
+}
+function formatPackageName(name) {
+  return name.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^[_-]+|[_-]+$/g, "") || "package";
+}
+function formatServerName(name) {
+  return name.replace(/[^A-Za-z0-9_-]+/g, "_").replace(/^[_-]+|[_-]+$/g, "") || "server";
+}
+
+// ../node_modules/.bun/pi-mcp-adapter@2.32.1+04b0d7b0bc944965/node_modules/pi-mcp-adapter/config.ts
+var GENERIC_GLOBAL_CONFIG_PATH = join2(homedir(), ".config", "mcp", "mcp.json");
+var AGENTS_GLOBAL_CONFIG_PATHS = [
+  join2(homedir(), ".agents", "mcp.json"),
+  join2(homedir(), ".agents", "mcp", "mcp.json")
+];
+var PROJECT_CONFIG_NAME = ".mcp.json";
+var PROJECT_PI_CONFIG_NAME = "mcp.json";
+var REPOPROMPT_BINARY_CANDIDATES = [
+  join2(homedir(), "RepoPrompt", "repoprompt_cli"),
+  "/Applications/Repo Prompt.app/Contents/MacOS/repoprompt-mcp"
+];
+var KNOWN_SERVER_PRESETS = [
+  {
+    id: "deepwiki",
+    name: "DeepWiki",
+    summary: "Ask questions about public GitHub repositories.",
+    entry: { url: "https://mcp.deepwiki.com/mcp", protocolVersion: "auto" }
+  },
+  {
+    id: "context7",
+    name: "Context7",
+    summary: "Look up current library documentation and examples.",
+    entry: { url: "https://mcp.context7.com/mcp", protocolVersion: "auto" }
+  },
+  {
+    id: "parallel-search",
+    name: "Parallel Search",
+    summary: "Search the web and fetch pages without an API key.",
+    entry: {
+      url: "https://search.parallel.ai/mcp",
+      protocolVersion: "auto",
+      directTools: true
+    }
+  },
+  {
+    id: "notion",
+    name: "Notion",
+    summary: "Search and work with your Notion workspace.",
+    entry: { url: "https://mcp.notion.com/mcp", auth: "oauth", protocolVersion: "auto" }
+  },
+  {
+    id: "github",
+    name: "GitHub",
+    summary: "Work with GitHub through your Copilot account.",
+    entry: { url: "https://api.githubcopilot.com/mcp", auth: "oauth", protocolVersion: "auto" }
+  },
+  {
+    id: "chrome-devtools",
+    name: "Chrome DevTools",
+    summary: "Inspect and automate a local Chrome browser.",
+    entry: { command: "npx", args: ["-y", "chrome-devtools-mcp@1.6.0"] }
+  }
+];
+var IMPORT_PATHS = {
+  cursor: [join2(homedir(), ".cursor", "mcp.json")],
+  "claude-code": [
+    join2(homedir(), ".claude", "mcp.json"),
+    join2(homedir(), ".claude.json"),
+    join2(homedir(), ".claude", "claude_desktop_config.json")
+  ],
+  "claude-desktop": [join2(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json")],
+  codex: [
+    join2(homedir(), ".codex", "config.toml"),
+    join2(homedir(), ".codex", "config.json")
+  ],
+  opencode: [
+    join2(homedir(), ".config", "opencode", "opencode.json"),
+    "./opencode.json"
+  ],
+  windsurf: [join2(homedir(), ".windsurf", "mcp.json")],
+  vscode: [".vscode/mcp.json"]
+};
+function getPiGlobalConfigPath(overridePath) {
+  return overridePath ? resolve3(overridePath) : getAgentPath("mcp.json");
+}
+function getGenericGlobalConfigPath() {
+  return GENERIC_GLOBAL_CONFIG_PATH;
+}
+function getProjectConfigPath(cwd = process.cwd()) {
+  return resolve3(cwd, PROJECT_CONFIG_NAME);
+}
+function getProjectPiConfigPath(cwd = process.cwd()) {
+  return resolve3(cwd, getConfigDirName(), PROJECT_PI_CONFIG_NAME);
+}
+function getSharedConfigPath(target, cwd = process.cwd()) {
+  return target === "project" ? getProjectConfigPath(cwd) : getGenericGlobalConfigPath();
+}
+function getConfigSourceSummaries(sourceSpecs) {
+  return sourceSpecs.map((source) => {
+    const loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
+    return {
+      id: source.id,
+      label: source.label,
+      path: source.readPath,
+      exists: existsSync3(source.readPath),
+      scope: source.scope,
+      kind: source.shared ? "shared" : "pi",
+      serverCount: loaded ? Object.keys(loaded.mcpServers).length : 0
+    };
+  });
+}
+function getMcpStandardConfigSummary(overridePath, cwd = process.cwd()) {
+  const sources = getConfigSourceSummaries(getConfigSources(overridePath, cwd));
+  return {
+    sources,
+    hasSharedServers: sources.some((source) => source.kind === "shared" && source.serverCount > 0),
+    fingerprint: JSON.stringify({ sources: sources.map((source) => [source.id, source.exists, source.serverCount]) })
+  };
+}
+function getMcpDiscoverySummary(overridePath, cwd = process.cwd(), options = {}) {
+  const sourceSpecs = getConfigSources(overridePath, cwd);
+  const sources = getConfigSourceSummaries(sourceSpecs);
+  const includeHostConfigs = options.includeHostConfigs !== false;
+  const importKinds = isExclusiveConfigMode() ? readValidatedConfig(getEffectivePiGlobalConfigPath(overridePath), "MCP exclusive config")?.imports ?? [] : Object.keys(IMPORT_PATHS);
+  const imports = includeHostConfigs ? importKinds.map((kind) => {
+    const imported = loadImportedConfig(kind, cwd, `Failed to inspect imported MCP config from ${kind}:`);
+    if (!imported) return null;
+    return {
+      kind,
+      path: imported.path,
+      serverCount: Object.keys(extractServers(imported.value, kind)).length
+    };
+  }).filter((value) => value !== null) : [];
+  const hostConfigDiscovery = isExclusiveConfigMode() ? "off" : getConfiguredHostConfigDiscovery(overridePath, cwd);
+  const hostConfigs = imports.map((entry) => ({ ...entry, active: hostConfigDiscovery === "on" }));
+  const settings = getMergedSettings(overridePath, cwd);
+  const agentPlugins = isExclusiveConfigMode() ? [] : getAgentPluginSummaries(settings?.agentPluginPaths, cwd);
+  const totalServerCount = sources.reduce((sum, source) => sum + source.serverCount, 0) + agentPlugins.reduce((sum, plugin) => sum + plugin.serverCount, 0);
+  const hasSharedServers = sources.some((source) => source.kind === "shared" && source.serverCount > 0) || agentPlugins.some((plugin) => plugin.serverCount > 0);
+  const hasPiOwnedServers = sources.some((source) => source.kind === "pi" && source.serverCount > 0);
+  const hasAnyDetectedPaths = sources.some((source) => source.exists) || imports.length > 0 || agentPlugins.length > 0;
+  const hasAnyConfig = totalServerCount > 0 || imports.some((entry) => entry.serverCount > 0) || hasAnyDetectedPaths;
+  const summaryWithoutRepoPrompt = {
+    sources,
+    imports,
+    hostConfigs,
+    hostConfigDiscovery,
+    agentPlugins,
+    conflicts: getConfigConflicts(sourceSpecs, imports, cwd),
+    hasAnyConfig,
+    hasAnyDetectedPaths,
+    hasSharedServers,
+    hasPiOwnedServers,
+    totalServerCount
+  };
+  const fingerprint = JSON.stringify({
+    sources: sources.map((source) => [source.id, source.exists, source.serverCount]),
+    imports: imports.map((entry) => [entry.kind, entry.path, entry.serverCount]),
+    agentPlugins: agentPlugins.map((entry) => [entry.path, entry.name, entry.serverCount]),
+    hostConfigDiscovery,
+    conflicts: summaryWithoutRepoPrompt.conflicts
+  });
+  return {
+    ...summaryWithoutRepoPrompt,
+    fingerprint,
+    repoPrompt: detectRepoPrompt(summaryWithoutRepoPrompt, cwd)
+  };
+}
+function cloneMcpConfig(config) {
+  return structuredClone(config);
+}
+function loadMcpConfig(overridePath, cwd = process.cwd()) {
+  const sourceSpecs = getConfigSources(overridePath, cwd);
+  const hostConfigDiscovery = getConfiguredHostConfigDiscovery(overridePath, cwd);
+  let config = !isExclusiveConfigMode() && hostConfigDiscovery === "on" ? loadDiscoveredHostConfigs(cwd) : { mcpServers: {} };
+  for (const source of sourceSpecs) {
+    const loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
+    if (!loaded) continue;
+    config = mergeConfigs(config, expandImports(loaded, cwd));
+  }
+  if (isExclusiveConfigMode()) return config;
+  const packageConfig = loadPackageMcpConfigs(cwd);
+  const pluginConfig = loadAgentPluginConfigs(config.settings?.agentPluginPaths, cwd);
+  const packageServers = Object.fromEntries(
+    Object.entries(packageConfig.mcpServers).filter(([name]) => !Object.hasOwn(pluginConfig.mcpServers, name))
+  );
+  return mergeConfigs({ mcpServers: packageServers }, mergeConfigs(pluginConfig, config));
+}
+function getMergedSettings(overridePath, cwd = process.cwd()) {
+  let settings;
+  for (const source of getConfigSources(overridePath, cwd)) {
+    const loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
+    if (loaded?.settings) settings = { ...settings, ...loaded.settings };
+  }
+  return settings;
+}
+function getConfiguredHostConfigDiscovery(overridePath, cwd = process.cwd()) {
+  let configured = "off";
+  const settings = getMergedSettings(overridePath, cwd);
+  const value = settings?.hostConfigDiscovery;
+  if (value === "off" || value === "prompt" || value === "on") configured = value;
+  return configured;
+}
+function loadDiscoveredHostConfigs(cwd) {
+  let config = { mcpServers: {} };
+  for (const importKind of Object.keys(IMPORT_PATHS)) {
+    const imported = loadImportedConfig(importKind, cwd, `Failed to discover imported MCP config from ${importKind}:`);
+    if (!imported) continue;
+    config = mergeConfigs(config, {
+      mcpServers: extractServers(imported.value, importKind)
+    });
+  }
+  return config;
+}
+function getConfigConflicts(sourceSpecs, imports, cwd) {
+  const seen = /* @__PURE__ */ new Map();
+  const record = (name, source) => {
+    const entries = seen.get(name) ?? [];
+    if (!entries.some((entry) => entry.kind === source.kind && entry.path === source.path)) entries.push(source);
+    seen.set(name, entries);
+  };
+  for (const entry of imports) {
+    const imported = loadImportedConfig(entry.kind, cwd, `Failed to inspect imported MCP config from ${entry.kind}:`);
+    if (!imported) continue;
+    for (const name of Object.keys(extractServers(imported.value, entry.kind))) {
+      record(name, { kind: "host", path: imported.path });
+    }
+  }
+  for (const source of sourceSpecs) {
+    const loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
+    if (!loaded) continue;
+    if (loaded.imports?.length) {
+      for (const importKind of loaded.imports) {
+        const imported = loadImportedConfig(importKind, cwd, `Failed to inspect imported MCP config from ${importKind}:`);
+        if (!imported) continue;
+        for (const name of Object.keys(extractServers(imported.value, importKind))) {
+          record(name, { kind: "host", path: imported.path });
+        }
+      }
+    }
+    for (const name of Object.keys(loaded.mcpServers)) {
+      record(name, {
+        kind: source.shared ? "shared" : "pi",
+        path: source.readPath
+      });
+    }
+  }
+  return [...seen.entries()].filter(([, sources]) => sources.length > 1).map(([serverName, sources]) => ({ serverName, sources, winner: sources[sources.length - 1] })).sort((left, right) => left.serverName.localeCompare(right.serverName));
+}
+function getConfigSources(overridePath, cwd = process.cwd()) {
+  const userPath = getEffectivePiGlobalConfigPath(overridePath);
+  const projectPath = getProjectConfigPath(cwd);
+  const projectPiPath = getProjectPiConfigPath(cwd);
+  const sources = [];
+  if (isExclusiveConfigMode()) {
+    return [{
+      id: "pi-global",
+      label: "Pi exclusive config",
+      readPath: userPath,
+      writePath: userPath,
+      kind: "user",
+      shared: false,
+      scope: "global"
+    }];
+  }
+  if (GENERIC_GLOBAL_CONFIG_PATH !== userPath) {
+    sources.push({
+      id: "shared-global",
+      label: "user-global standard MCP",
+      readPath: GENERIC_GLOBAL_CONFIG_PATH,
+      writePath: userPath,
+      kind: "import",
+      importKind: "global MCP config",
+      shared: true,
+      scope: "global"
+    });
+  }
+  for (const [index, agentsPath] of AGENTS_GLOBAL_CONFIG_PATHS.entries()) {
+    if (agentsPath === userPath || agentsPath === GENERIC_GLOBAL_CONFIG_PATH) continue;
+    sources.push({
+      id: index === 0 ? "agents-global" : "agents-nested-global",
+      label: index === 0 ? "user-global .agents MCP" : "user-global .agents nested MCP",
+      readPath: agentsPath,
+      writePath: userPath,
+      kind: "import",
+      importKind: index === 0 ? ".agents MCP config" : ".agents/mcp MCP config",
+      shared: true,
+      scope: "global"
+    });
+  }
+  sources.push({
+    id: "pi-global",
+    label: "Pi global override",
+    readPath: userPath,
+    writePath: userPath,
+    kind: "user",
+    shared: false,
+    scope: "global"
+  });
+  if (projectPath !== userPath) {
+    sources.push({
+      id: "shared-project",
+      label: "project standard MCP",
+      readPath: projectPath,
+      writePath: projectPath,
+      kind: "project",
+      shared: true,
+      scope: "project"
+    });
+  }
+  if (projectPiPath !== userPath && projectPiPath !== projectPath) {
+    sources.push({
+      id: "pi-project",
+      label: "project Pi override",
+      readPath: projectPiPath,
+      writePath: projectPiPath,
+      kind: "project",
+      shared: false,
+      scope: "project"
+    });
+  }
+  return sources;
+}
+function isExclusiveConfigMode() {
+  return process.env.PI_MCP_CONFIG_MODE?.trim().toLowerCase() === "exclusive";
+}
+function getEffectivePiGlobalConfigPath(overridePath) {
+  return getPiGlobalConfigPath(isExclusiveConfigMode() ? void 0 : overridePath);
+}
+function mergeConfigs(base, next) {
+  const imports = mergeImports(base.imports, next.imports);
+  const settings = next.settings ? { ...base.settings, ...next.settings } : base.settings;
+  return {
+    mcpServers: mergeServerMaps(base.mcpServers, next.mcpServers),
+    ...imports !== void 0 ? { imports } : {},
+    ...settings !== void 0 ? { settings } : {}
+  };
+}
+var URL_BOUND_AUTH_FIELDS = ["headers", "bearerToken", "bearerTokenEnv", "bearerTokenStore", "requestHeadersCommand"];
+function mergeServerMaps(base, next) {
+  const merged = { ...base };
+  for (const [name, definition] of Object.entries(next)) {
+    const existing = merged[name];
+    let baseEntry = existing ?? {};
+    if (existing && typeof definition.command === "string") {
+      baseEntry = { ...existing };
+      for (const field of [
+        "url",
+        "headers",
+        "requestHeadersCommand",
+        "auth",
+        "bearerToken",
+        "bearerTokenEnv",
+        "oauth",
+        "httpTransport",
+        "socket"
+      ]) {
+        delete baseEntry[field];
+      }
+    } else if (existing && typeof definition.url === "string") {
+      baseEntry = { ...existing };
+      for (const field of [
+        "command",
+        "args",
+        "env",
+        "cwd",
+        "pluginDataDir",
+        "literalEnv",
+        "socket"
+      ]) {
+        delete baseEntry[field];
+      }
+    } else if (existing && typeof definition.socket === "string") {
+      baseEntry = { ...existing };
+      for (const field of [
+        "command",
+        "args",
+        "env",
+        "cwd",
+        "pluginDataDir",
+        "literalEnv",
+        "url",
+        "headers",
+        "requestHeadersCommand",
+        "auth",
+        "bearerToken",
+        "bearerTokenEnv",
+        "oauth",
+        "httpTransport"
+      ]) {
+        delete baseEntry[field];
+      }
+    }
+    if (existing && typeof definition.url === "string" && definition.url !== existing.url) {
+      if (baseEntry === existing) baseEntry = { ...existing };
+      for (const field of URL_BOUND_AUTH_FIELDS) {
+        delete baseEntry[field];
+      }
+      if (baseEntry.oauth !== false) {
+        delete baseEntry.oauth;
+      }
+    }
+    merged[name] = { ...baseEntry, ...definition };
+  }
+  return merged;
+}
+function mergeImports(left, right) {
+  const merged = [...left ?? [], ...right ?? []];
+  if (merged.length === 0) return void 0;
+  return [...new Set(merged)];
+}
+function expandImports(config, cwd = process.cwd()) {
+  if (!config.imports?.length) return config;
+  const importedServers = {};
+  for (const importKind of config.imports) {
+    const imported = loadImportedConfig(importKind, cwd, `Failed to import MCP config from ${importKind}:`);
+    if (!imported) continue;
+    const servers = extractServers(imported.value, importKind);
+    for (const [name, definition] of Object.entries(servers)) {
+      if (!importedServers[name]) {
+        importedServers[name] = definition;
+      }
+    }
+  }
+  return {
+    imports: config.imports,
+    ...config.settings !== void 0 ? { settings: config.settings } : {},
+    mcpServers: mergeServerMaps(importedServers, config.mcpServers)
+  };
+}
+function resolveImportCandidates(importKind, cwd) {
+  return (IMPORT_PATHS[importKind] ?? []).map((candidate) => {
+    if (importKind === "opencode" && candidate === "./opencode.json") {
+      const start = resolve3(cwd);
+      let gitRoot;
+      let current = start;
+      while (true) {
+        if (existsSync3(join2(current, ".git"))) {
+          gitRoot = current;
+          break;
+        }
+        const parent = dirname(current);
+        if (parent === current) break;
+        current = parent;
+      }
+      if (!gitRoot) return join2(start, "opencode.json");
+      current = start;
+      while (true) {
+        const projectConfig = join2(current, "opencode.json");
+        if (existsSync3(projectConfig) || current === gitRoot) return projectConfig;
+        current = dirname(current);
+      }
+    }
+    return candidate.startsWith(".") ? resolve3(cwd, candidate) : candidate;
+  });
+}
+function parseJsonConfig(raw) {
+  return JSON.parse(stripJsonComments(raw, { trailingCommas: true }));
+}
+function readImportedConfig(path) {
+  const raw = readFileSync3(path, "utf-8");
+  return path.endsWith(".toml") ? parse(raw) : parseJsonConfig(raw);
+}
+function loadImportedConfig(importKind, cwd, warningPrefix) {
+  if (importKind === "opencode") {
+    let merged = {};
+    let highestPrecedencePath;
+    for (const path of resolveImportCandidates(importKind, cwd)) {
+      if (!existsSync3(path)) continue;
+      try {
+        const value = readImportedConfig(path);
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+          merged = mergeOpenCodeConfigs(merged, value);
+          highestPrecedencePath = path;
+        }
+      } catch (error) {
+        console.warn(warningPrefix, error);
+      }
+    }
+    return highestPrecedencePath ? { path: highestPrecedencePath, value: merged } : null;
+  }
+  for (const path of resolveImportCandidates(importKind, cwd)) {
+    if (!existsSync3(path)) continue;
+    try {
+      return { path, value: readImportedConfig(path) };
+    } catch (error) {
+      console.warn(warningPrefix, error);
+    }
+  }
+  return null;
+}
+function readValidatedConfig(path, label) {
+  if (!existsSync3(path)) return null;
+  try {
+    return validateConfig(parseJsonConfig(readFileSync3(path, "utf-8")));
+  } catch (error) {
+    console.warn(`Failed to load ${label}:`, error);
+    return null;
+  }
+}
+function validateConfig(raw) {
+  if (!isRecord(raw)) {
+    return { mcpServers: {} };
+  }
+  return {
+    mcpServers: toServerEntries(raw.mcpServers ?? raw["mcp-servers"]),
+    ...Array.isArray(raw.imports) ? { imports: raw.imports } : {},
+    ...raw.settings !== void 0 ? { settings: raw.settings } : {}
+  };
+}
+function toServerEntries(servers) {
+  if (!isRecord(servers)) return {};
+  const entries = {};
+  for (const [name, entry] of Object.entries(servers)) {
+    if (isServerEntry(entry)) entries[name] = entry;
+  }
+  return entries;
+}
+function isServerEntry(value) {
+  return isRecord(value);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeOpenCodeConfigs(base, next) {
+  const baseMcp = base.mcp;
+  const nextMcp = next.mcp;
+  const mergedMcp = {
+    ...baseMcp && typeof baseMcp === "object" && !Array.isArray(baseMcp) ? baseMcp : {}
+  };
+  if (nextMcp && typeof nextMcp === "object" && !Array.isArray(nextMcp)) {
+    for (const [name, nextEntry] of Object.entries(nextMcp)) {
+      const baseEntry = mergedMcp[name];
+      if (baseEntry && typeof baseEntry === "object" && !Array.isArray(baseEntry) && nextEntry && typeof nextEntry === "object" && !Array.isArray(nextEntry)) {
+        const safeBase = { ...baseEntry };
+        const override = nextEntry;
+        if (typeof override.type === "string" && override.type !== safeBase.type) {
+          for (const field of ["command", "environment", "cwd", "url", "headers", "oauth"]) delete safeBase[field];
+        }
+        if (typeof override.url === "string" && override.url !== safeBase.url) {
+          delete safeBase.headers;
+          delete safeBase.oauth;
+        }
+        if (Array.isArray(override.command)) {
+          const baseCommand = safeBase.command;
+          const commandChanged = !Array.isArray(baseCommand) || override.command.length !== baseCommand.length || override.command.some((value, index) => value !== baseCommand[index]);
+          if (commandChanged) {
+            delete safeBase.environment;
+            delete safeBase.cwd;
+          }
+        }
+        const mergedEntry = { ...safeBase, ...override };
+        for (const field of ["environment", "headers", "oauth"]) {
+          const baseField = safeBase[field];
+          const nextField = override[field];
+          if (baseField && typeof baseField === "object" && !Array.isArray(baseField) && nextField && typeof nextField === "object" && !Array.isArray(nextField)) {
+            mergedEntry[field] = { ...baseField, ...nextField };
+          }
+        }
+        mergedMcp[name] = mergedEntry;
+      } else {
+        mergedMcp[name] = nextEntry;
+      }
+    }
+  }
+  return { ...base, ...next, mcp: mergedMcp };
+}
+function extractServers(config, kind) {
+  if (!config || typeof config !== "object") return {};
+  const obj = config;
+  let servers;
+  switch (kind) {
+    case "claude-desktop":
+    case "claude-code":
+      servers = obj.mcpServers;
+      break;
+    case "codex":
+      servers = obj.mcp_servers ?? obj.mcpServers;
+      break;
+    case "cursor":
+    case "windsurf":
+    case "vscode":
+      servers = obj.mcpServers ?? obj["mcp-servers"];
+      break;
+    case "opencode":
+      servers = obj.mcp;
+      break;
+    default:
+      return {};
+  }
+  if (!servers || typeof servers !== "object" || Array.isArray(servers)) {
+    return {};
+  }
+  const mappedServers = {};
+  for (const [name, entry] of Object.entries(servers)) {
+    if (kind === "opencode") {
+      if (!entry || typeof entry !== "object" || Array.isArray(entry)) continue;
+      const raw = entry;
+      if (raw.enabled === false) continue;
+      if (raw.type === "local" && Array.isArray(raw.command) && raw.command.length > 0 && raw.command.every((value) => typeof value === "string")) {
+        const env = toStringRecord(raw.environment);
+        const command = raw.command[0];
+        if (command === void 0) continue;
+        const mapped2 = {
+          command,
+          args: raw.command.slice(1),
+          ...env ? { env } : {},
+          ...typeof raw.cwd === "string" ? { cwd: raw.cwd } : {}
+        };
+        mappedServers[name] = mapped2;
+        continue;
+      }
+      if (raw.type === "remote" && typeof raw.url === "string") {
+        const headers = toStringRecord(raw.headers);
+        const mapped2 = {
+          url: raw.url,
+          ...headers ? { headers } : {}
+        };
+        if (raw.oauth === false) {
+          mapped2.oauth = false;
+        } else if (raw.oauth && typeof raw.oauth === "object" && !Array.isArray(raw.oauth)) {
+          const oauth = raw.oauth;
+          mapped2.auth = "oauth";
+          mapped2.oauth = {
+            ...typeof oauth.clientId === "string" ? { clientId: oauth.clientId } : {},
+            ...typeof oauth.clientSecret === "string" ? { clientSecret: oauth.clientSecret } : {},
+            ...typeof oauth.scope === "string" ? { scope: oauth.scope } : {},
+            ...typeof oauth.authServerMetadataUrl === "string" ? { authServerMetadataUrl: oauth.authServerMetadataUrl } : {},
+            ...typeof oauth.skipIssuerMetadataValidation === "boolean" ? { skipIssuerMetadataValidation: oauth.skipIssuerMetadataValidation } : {}
+          };
+        }
+        mappedServers[name] = mapped2;
+      }
+      continue;
+    }
+    if (!isRecord(entry)) continue;
+    if (kind !== "codex") {
+      mappedServers[name] = entry;
+      continue;
+    }
+    const mapped = { ...entry };
+    const bearerTokenEnv = mapped.bearer_token_env_var;
+    const httpHeaders = mapped.http_headers;
+    const envHttpHeaders = mapped.env_http_headers;
+    if (typeof bearerTokenEnv === "string") {
+      mapped.bearerTokenEnv = bearerTokenEnv;
+      if (mapped.auth === void 0) mapped.auth = "bearer";
+    }
+    if (httpHeaders && typeof httpHeaders === "object" && !Array.isArray(httpHeaders)) {
+      mapped.headers = { ...mapped.headers, ...httpHeaders };
+    }
+    if (envHttpHeaders && typeof envHttpHeaders === "object" && !Array.isArray(envHttpHeaders)) {
+      const headers = { ...mapped.headers };
+      for (const [header, envVar] of Object.entries(envHttpHeaders)) {
+        if (typeof envVar === "string" && headers[header] === void 0) headers[header] = `$env:${envVar}`;
+      }
+      mapped.headers = headers;
+    }
+    delete mapped.bearer_token_env_var;
+    delete mapped.http_headers;
+    delete mapped.env_http_headers;
+    mappedServers[name] = mapped;
+  }
+  return mappedServers;
+}
+function serializeRawConfig(raw) {
+  return `${JSON.stringify(raw, null, 2)}
+`;
+}
+function buildUnifiedDiff(beforeText, afterText) {
+  if (beforeText === afterText) return "(no changes)";
+  const before = beforeText.split("\n");
+  const after = afterText.split("\n");
+  const rows = before.length;
+  const cols = after.length;
+  const lcs = Array.from({ length: rows + 1 }, () => Array(cols + 1).fill(0));
+  for (let i2 = rows - 1; i2 >= 0; i2--) {
+    for (let j2 = cols - 1; j2 >= 0; j2--) {
+      const row = lcs[i2];
+      const nextRow = lcs[i2 + 1];
+      if (!row || !nextRow) continue;
+      row[j2] = before[i2] === after[j2] ? (nextRow[j2 + 1] ?? 0) + 1 : Math.max(nextRow[j2] ?? 0, row[j2 + 1] ?? 0);
+    }
+  }
+  const lines = ["--- before", "+++ after"];
+  let i = 0;
+  let j = 0;
+  while (i < rows || j < cols) {
+    if (i < rows && j < cols && before[i] === after[j]) {
+      lines.push(`  ${before[i]}`);
+      i++;
+      j++;
+      continue;
+    }
+    if (j < cols && (i === rows || (lcs[i]?.[j + 1] ?? 0) >= (lcs[i + 1]?.[j] ?? 0))) {
+      lines.push(`+ ${after[j]}`);
+      j++;
+      continue;
+    }
+    if (i < rows) {
+      lines.push(`- ${before[i]}`);
+      i++;
+    }
+  }
+  return lines.join("\n");
+}
+function buildConfigWritePreview(filePath, nextRaw) {
+  const existed = existsSync3(filePath);
+  const beforeRaw = readRawConfigObject(filePath);
+  const beforeText = existed ? serializeRawConfig(beforeRaw) : "";
+  const afterText = serializeRawConfig(nextRaw);
+  return {
+    path: filePath,
+    existed,
+    changed: beforeText !== afterText,
+    beforeText,
+    afterText,
+    diffText: buildUnifiedDiff(beforeText, afterText)
+  };
+}
+function readRawConfigObject(filePath) {
+  if (!existsSync3(filePath)) return {};
+  try {
+    const raw = parseJsonConfig(readFileSync3(filePath, "utf-8"));
+    return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+  } catch {
+    return {};
+  }
+}
+function writeRawConfigObject(filePath, raw) {
+  mkdirSync(dirname(filePath), { recursive: true });
+  const tmpPath = `${filePath}.${process.pid}.tmp`;
+  writeFileSync(tmpPath, `${JSON.stringify(raw, null, 2)}
+`, "utf-8");
+  renameSync(tmpPath, filePath);
+}
+function getServersObject(raw) {
+  const existing = raw.mcpServers ?? raw["mcp-servers"] ?? {};
+  if (!existing || typeof existing !== "object" || Array.isArray(existing)) {
+    return {};
+  }
+  return existing;
+}
+function setServersObject(raw, servers) {
+  delete raw["mcp-servers"];
+  raw.mcpServers = servers;
+}
+function writeProjectServerDisabledOverride(overridePath, cwd, serverName, disabled) {
+  const filePath = getProjectPiConfigPath(cwd);
+  let raw = {};
+  if (existsSync3(filePath)) {
+    try {
+      const parsed = parseJsonConfig(readFileSync3(filePath, "utf-8"));
+      if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("root value must be an object");
+      }
+      raw = parsed;
+    } catch (error) {
+      throw new Error(`Failed to read project MCP override at ${filePath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+  }
+  const serverKey = raw.mcpServers !== void 0 ? "mcpServers" : raw["mcp-servers"] !== void 0 ? "mcp-servers" : "mcpServers";
+  const rawServers = raw[serverKey];
+  if (rawServers !== void 0 && (!rawServers || typeof rawServers !== "object" || Array.isArray(rawServers))) {
+    throw new Error(`Failed to update project MCP override at ${filePath}: ${serverKey} must be an object`);
+  }
+  const servers = rawServers ?? {};
+  const previous = servers[serverName];
+  if (previous !== void 0 && (!previous || typeof previous !== "object" || Array.isArray(previous))) {
+    throw new Error(`Failed to update project MCP override at ${filePath}: server "${serverName}" must be an object`);
+  }
+  const existing = previous;
+  let next;
+  if (disabled) {
+    next = { ...existing, disabled: true };
+  } else {
+    next = Object.fromEntries(Object.entries(existing ?? {}).filter(([key]) => key !== "disabled"));
+    let lowerConfig = { mcpServers: {} };
+    for (const source of getConfigSources(overridePath, cwd)) {
+      if (source.readPath === filePath) continue;
+      const loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
+      if (loaded) lowerConfig = mergeConfigs(lowerConfig, expandImports(loaded, cwd));
+    }
+    if (raw.imports !== void 0) {
+      if (!Array.isArray(raw.imports) || raw.imports.some((kind) => typeof kind !== "string" || !Object.hasOwn(IMPORT_PATHS, kind))) {
+        throw new Error(`Failed to update project MCP override at ${filePath}: imports contains an unsupported config kind`);
+      }
+      lowerConfig = mergeConfigs(lowerConfig, expandImports({ mcpServers: {}, imports: raw.imports }, cwd));
+    }
+    if (isServerDisabled(lowerConfig.mcpServers[serverName])) next.disabled = false;
+  }
+  if (!existing && Object.keys(next).length === 0 || JSON.stringify(existing) === JSON.stringify(next)) {
+    return { path: filePath, changed: false };
+  }
+  if (Object.keys(next).length === 0) delete servers[serverName];
+  else servers[serverName] = next;
+  raw[serverKey] = servers;
+  writeRawConfigObject(filePath, raw);
+  return { path: filePath, changed: true };
+}
+function isRepoPromptServer(name, entry) {
+  const normalizedName = name.toLowerCase();
+  if (normalizedName.includes("repoprompt") || normalizedName === "rp") {
+    return true;
+  }
+  const command = entry.command?.toLowerCase() ?? "";
+  if (command.includes("repoprompt") || command.includes("rp-mcp") || command.endsWith("repoprompt_cli")) {
+    return true;
+  }
+  return (entry.args ?? []).some((arg) => typeof arg === "string" && arg.toLowerCase().includes("repoprompt"));
+}
+function findProjectRoot(cwd = process.cwd()) {
+  let current = resolve3(cwd);
+  while (true) {
+    if (existsSync3(join2(current, ".git")) || existsSync3(join2(current, "package.json")) || existsSync3(join2(current, PROJECT_CONFIG_NAME)) || existsSync3(join2(current, ".pi"))) {
+      return current;
+    }
+    const parent = dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function buildRepoPromptEntry(executablePath) {
+  return {
+    command: executablePath,
+    args: [],
+    lifecycle: "lazy"
+  };
+}
+function detectRepoPrompt(summary, cwd = process.cwd()) {
+  for (const source of summary.sources) {
+    if (source.kind !== "shared" || source.serverCount === 0) continue;
+    const config = readValidatedConfig(source.path, `MCP config from ${source.path}`);
+    if (!config) continue;
+    for (const [name, entry] of Object.entries(config.mcpServers)) {
+      if (isRepoPromptServer(name, entry)) {
+        return { configured: true, configuredPath: source.path };
+      }
+    }
+  }
+  const executablePath = REPOPROMPT_BINARY_CANDIDATES.find((candidate) => existsSync3(candidate));
+  if (!executablePath) {
+    return { configured: false };
+  }
+  const projectRoot = findProjectRoot(cwd);
+  const targetPath = projectRoot ? join2(projectRoot, PROJECT_CONFIG_NAME) : GENERIC_GLOBAL_CONFIG_PATH;
+  return {
+    configured: false,
+    executablePath,
+    targetPath,
+    serverName: "repoprompt",
+    entry: buildRepoPromptEntry(executablePath)
+  };
+}
+function previewCompatibilityImports(importKinds, overridePath) {
+  const targetPath = getPiGlobalConfigPath(overridePath);
+  const raw = readRawConfigObject(targetPath);
+  const currentImports = Array.isArray(raw.imports) ? raw.imports.filter((value) => typeof value === "string") : [];
+  const merged = [.../* @__PURE__ */ new Set([...currentImports, ...importKinds])];
+  const nextRaw = { ...raw, imports: merged };
+  setServersObject(nextRaw, getServersObject(nextRaw));
+  return buildConfigWritePreview(targetPath, nextRaw);
+}
+function ensureCompatibilityImports(importKinds, overridePath) {
+  const targetPath = getPiGlobalConfigPath(overridePath);
+  const raw = readRawConfigObject(targetPath);
+  const currentImports = Array.isArray(raw.imports) ? raw.imports.filter((value) => typeof value === "string") : [];
+  const merged = [.../* @__PURE__ */ new Set([...currentImports, ...importKinds])];
+  const added = merged.filter((kind) => !currentImports.includes(kind));
+  if (added.length === 0) {
+    return { path: targetPath, added: [] };
+  }
+  raw.imports = merged;
+  const servers = getServersObject(raw);
+  setServersObject(raw, servers);
+  writeRawConfigObject(targetPath, raw);
+  return { path: targetPath, added };
+}
+function buildStarterProjectConfig() {
+  return {
+    mcpServers: {}
+  };
+}
+function previewStarterSharedConfig(target, cwd = process.cwd()) {
+  const targetPath = getSharedConfigPath(target, cwd);
+  const nextRaw = { mcpServers: buildStarterProjectConfig().mcpServers };
+  return buildConfigWritePreview(targetPath, nextRaw);
+}
+function writeStarterSharedConfig(target, cwd = process.cwd()) {
+  const targetPath = getSharedConfigPath(target, cwd);
+  const raw = { mcpServers: buildStarterProjectConfig().mcpServers };
+  writeRawConfigObject(targetPath, raw);
+  return targetPath;
+}
+function previewSharedServerEntry(filePath, serverName, entry) {
+  const raw = readRawConfigObject(filePath);
+  const nextRaw = { ...raw };
+  const servers = getServersObject(nextRaw);
+  servers[serverName] = entry;
+  setServersObject(nextRaw, servers);
+  return buildConfigWritePreview(filePath, nextRaw);
+}
+function writeSharedServerEntry(filePath, serverName, entry) {
+  const raw = readRawConfigObject(filePath);
+  const servers = getServersObject(raw);
+  servers[serverName] = entry;
+  setServersObject(raw, servers);
+  writeRawConfigObject(filePath, raw);
+  return filePath;
+}
+function getServerProvenance(overridePath, cwd = process.cwd()) {
+  const provenance = /* @__PURE__ */ new Map();
+  const userPath = getPiGlobalConfigPath(overridePath);
+  if (getConfiguredHostConfigDiscovery(overridePath, cwd) === "on") {
+    for (const importKind of Object.keys(IMPORT_PATHS)) {
+      const imported = loadImportedConfig(importKind, cwd, `Failed to inspect imported MCP config from ${importKind}:`);
+      if (!imported) continue;
+      for (const name of Object.keys(extractServers(imported.value, importKind))) {
+        provenance.set(name, { path: userPath, kind: "import", importKind });
+      }
+    }
+  }
+  for (const source of getConfigSources(overridePath, cwd)) {
+    const loaded = readValidatedConfig(source.readPath, `MCP config from ${source.readPath}`);
+    if (!loaded) continue;
+    if (loaded.imports?.length) {
+      for (const importKind of loaded.imports) {
+        const imported = loadImportedConfig(importKind, cwd, `Failed to inspect imported MCP config from ${importKind}:`);
+        if (!imported) continue;
+        const servers = extractServers(imported.value, importKind);
+        for (const name of Object.keys(servers)) {
+          if (!provenance.has(name)) {
+            provenance.set(name, { path: userPath, kind: "import", importKind });
+          }
+        }
+      }
+    }
+    for (const name of Object.keys(loaded.mcpServers)) {
+      provenance.set(name, {
+        path: source.writePath,
+        kind: source.kind,
+        ...source.importKind !== void 0 ? { importKind: source.importKind } : {}
+      });
+    }
+  }
+  return provenance;
+}
+function writeDirectToolsConfig(changes, provenance, fullConfig) {
+  const byPath = /* @__PURE__ */ new Map();
+  for (const [serverName, value] of changes) {
+    const prov = provenance.get(serverName);
+    if (!prov) continue;
+    const targetPath = prov.path;
+    if (!byPath.has(targetPath)) byPath.set(targetPath, []);
+    byPath.get(targetPath).push({ name: serverName, value, prov });
+  }
+  for (const [filePath, entries] of byPath) {
+    const raw = readRawConfigObject(filePath);
+    const servers = getServersObject(raw);
+    for (const { name, value, prov } of entries) {
+      if (prov.kind === "import") {
+        const fullDef = fullConfig.mcpServers[name];
+        if (fullDef) {
+          servers[name] = { ...fullDef, directTools: value };
+        }
+      } else if (servers[name]) {
+        servers[name] = { ...servers[name], directTools: value };
+      }
+    }
+    setServersObject(raw, servers);
+    writeRawConfigObject(filePath, raw);
+  }
+}
+function resolveConfiguredOAuthDir(raw, cwd = process.cwd()) {
+  if (raw === void 0 || raw === null) return void 0;
+  if (typeof raw !== "string") {
+    throw new Error("settings.oauthDir must be a string");
+  }
+  const trimmed = raw.trim();
+  if (!trimmed) return void 0;
+  return resolve3(cwd, trimmed);
+}
+
+export {
+  KNOWN_SERVER_PRESETS,
+  getSharedConfigPath,
+  getMcpStandardConfigSummary,
+  getMcpDiscoverySummary,
+  cloneMcpConfig,
+  loadMcpConfig,
+  writeProjectServerDisabledOverride,
+  previewCompatibilityImports,
+  ensureCompatibilityImports,
+  previewStarterSharedConfig,
+  writeStarterSharedConfig,
+  previewSharedServerEntry,
+  writeSharedServerEntry,
+  getServerProvenance,
+  writeDirectToolsConfig,
+  resolveConfiguredOAuthDir
+};
+/*! Bundled license information:
+
+smol-toml/dist/date.js:
+smol-toml/dist/error.js:
+smol-toml/dist/primitive.js:
+smol-toml/dist/util.js:
+smol-toml/dist/extract.js:
+smol-toml/dist/struct.js:
+smol-toml/dist/parse.js:
+smol-toml/dist/stringify.js:
+smol-toml/dist/index.js:
+  (*!
+   * Copyright (c) Squirrel Chat et al., All rights reserved.
+   * SPDX-License-Identifier: BSD-3-Clause
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are met:
+   *
+   * 1. Redistributions of source code must retain the above copyright notice, this
+   *    list of conditions and the following disclaimer.
+   * 2. Redistributions in binary form must reproduce the above copyright notice,
+   *    this list of conditions and the following disclaimer in the
+   *    documentation and/or other materials provided with the distribution.
+   * 3. Neither the name of the copyright holder nor the names of its contributors
+   *    may be used to endorse or promote products derived from this software without
+   *    specific prior written permission.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+   * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+   * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   *)
+*/