@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.19-dev.10.1

package/dist/node-runtime/chunk-ZSEZY3II.js

@@ -0,0 +1,247 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  loadPhoton
+} from "./chunk-RQ2Q5IYR.js";
+
+// packages/coding-agent/dist/utils/image-resize.js
+import { Worker } from "node:worker_threads";
+
+// packages/coding-agent/dist/utils/exif-orientation.js
+function readOrientationFromTiff(bytes, tiffStart) {
+  if (tiffStart + 8 > bytes.length)
+    return 1;
+  let le = (bytes[tiffStart] << 8 | bytes[tiffStart + 1]) === 18761, read16 = (pos) => le ? bytes[pos] | bytes[pos + 1] << 8 : bytes[pos] << 8 | bytes[pos + 1], ifdOffset = ((pos) => le ? bytes[pos] | bytes[pos + 1] << 8 | bytes[pos + 2] << 16 | bytes[pos + 3] << 24 : (bytes[pos] << 24 | bytes[pos + 1] << 16 | bytes[pos + 2] << 8 | bytes[pos + 3]) >>> 0)(tiffStart + 4), ifdStart = tiffStart + ifdOffset;
+  if (ifdStart + 2 > bytes.length)
+    return 1;
+  let entryCount = read16(ifdStart);
+  for (let i = 0; i < entryCount; i++) {
+    let entryPos = ifdStart + 2 + i * 12;
+    if (entryPos + 12 > bytes.length)
+      return 1;
+    if (read16(entryPos) === 274) {
+      let value = read16(entryPos + 8);
+      return value >= 1 && value <= 8 ? value : 1;
+    }
+  }
+  return 1;
+}
+function findJpegTiffOffset(bytes) {
+  let offset = 2;
+  for (; offset < bytes.length - 1; ) {
+    if (bytes[offset] !== 255)
+      return -1;
+    let marker = bytes[offset + 1];
+    if (marker === 255) {
+      offset++;
+      continue;
+    }
+    if (marker === 225) {
+      if (offset + 4 >= bytes.length)
+        return -1;
+      let segmentStart = offset + 4;
+      return segmentStart + 6 > bytes.length || !hasExifHeader(bytes, segmentStart) ? -1 : segmentStart + 6;
+    }
+    if (offset + 4 > bytes.length)
+      return -1;
+    let length = bytes[offset + 2] << 8 | bytes[offset + 3];
+    offset += 2 + length;
+  }
+  return -1;
+}
+function findWebpTiffOffset(bytes) {
+  let offset = 12;
+  for (; offset + 8 <= bytes.length; ) {
+    let chunkId = String.fromCharCode(bytes[offset], bytes[offset + 1], bytes[offset + 2], bytes[offset + 3]), chunkSize = bytes[offset + 4] | bytes[offset + 5] << 8 | bytes[offset + 6] << 16 | bytes[offset + 7] << 24, dataStart = offset + 8;
+    if (chunkId === "EXIF")
+      return dataStart + chunkSize > bytes.length ? -1 : chunkSize >= 6 && hasExifHeader(bytes, dataStart) ? dataStart + 6 : dataStart;
+    offset = dataStart + chunkSize + chunkSize % 2;
+  }
+  return -1;
+}
+function hasExifHeader(bytes, offset) {
+  return bytes[offset] === 69 && bytes[offset + 1] === 120 && bytes[offset + 2] === 105 && bytes[offset + 3] === 102 && bytes[offset + 4] === 0 && bytes[offset + 5] === 0;
+}
+function getExifOrientation(bytes) {
+  let tiffOffset = -1;
+  return bytes.length >= 2 && bytes[0] === 255 && bytes[1] === 216 ? tiffOffset = findJpegTiffOffset(bytes) : bytes.length >= 12 && bytes[0] === 82 && bytes[1] === 73 && bytes[2] === 70 && bytes[3] === 70 && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80 && (tiffOffset = findWebpTiffOffset(bytes)), tiffOffset === -1 ? 1 : readOrientationFromTiff(bytes, tiffOffset);
+}
+function rotate90(photon, image, dstIndex) {
+  let w = image.get_width(), h = image.get_height(), src = image.get_raw_pixels(), dst = new Uint8Array(src.length);
+  for (let y = 0; y < h; y++)
+    for (let x = 0; x < w; x++) {
+      let srcIdx = (y * w + x) * 4, dstIdx = dstIndex(x, y, w, h) * 4;
+      dst[dstIdx] = src[srcIdx], dst[dstIdx + 1] = src[srcIdx + 1], dst[dstIdx + 2] = src[srcIdx + 2], dst[dstIdx + 3] = src[srcIdx + 3];
+    }
+  return new photon.PhotonImage(dst, h, w);
+}
+function applyExifOrientation(photon, image, originalBytes) {
+  let orientation = getExifOrientation(originalBytes);
+  if (orientation === 1)
+    return image;
+  switch (orientation) {
+    case 2:
+      return photon.fliph(image), image;
+    case 3:
+      return photon.fliph(image), photon.flipv(image), image;
+    case 4:
+      return photon.flipv(image), image;
+    case 5: {
+      let rotated = rotate90(photon, image, (x, y, _w, h) => x * h + (h - 1 - y));
+      return photon.fliph(rotated), rotated;
+    }
+    case 6:
+      return rotate90(photon, image, (x, y, _w, h) => x * h + (h - 1 - y));
+    case 7: {
+      let rotated = rotate90(photon, image, (x, y, w, h) => (w - 1 - x) * h + y);
+      return photon.fliph(rotated), rotated;
+    }
+    case 8:
+      return rotate90(photon, image, (x, y, w, h) => (w - 1 - x) * h + y);
+    default:
+      return image;
+  }
+}
+
+// packages/coding-agent/dist/utils/image-resize-core.js
+var DEFAULT_MAX_BYTES = 4.5 * 1024 * 1024, DEFAULT_OPTIONS = {
+  maxWidth: 2e3,
+  maxHeight: 2e3,
+  maxBytes: DEFAULT_MAX_BYTES,
+  jpegQuality: 80
+};
+function encodeCandidate(buffer, mimeType) {
+  let data = Buffer.from(buffer).toString("base64");
+  return {
+    data,
+    encodedSize: Buffer.byteLength(data, "utf-8"),
+    mimeType
+  };
+}
+async function resizeImageInProcess(inputBytes, mimeType, options) {
+  let opts = { ...DEFAULT_OPTIONS, ...options }, inputBase64Size = Math.ceil(inputBytes.byteLength / 3) * 4, photon = await loadPhoton();
+  if (!photon)
+    return null;
+  let image;
+  try {
+    let tryEncodings = function(width, height, jpegQualities) {
+      let resized = photon.resize(image, width, height, photon.SamplingFilter.Lanczos3);
+      try {
+        let candidates = [encodeCandidate(resized.get_bytes(), "image/png")];
+        for (let quality of jpegQualities)
+          candidates.push(encodeCandidate(resized.get_bytes_jpeg(quality), "image/jpeg"));
+        return candidates;
+      } finally {
+        resized.free();
+      }
+    }, rawImage = photon.PhotonImage.new_from_byteslice(inputBytes);
+    image = applyExifOrientation(photon, rawImage, inputBytes), image !== rawImage && rawImage.free();
+    let originalWidth = image.get_width(), originalHeight = image.get_height(), format = mimeType.split("/")[1] ?? "png";
+    if (originalWidth <= opts.maxWidth && originalHeight <= opts.maxHeight && inputBase64Size < opts.maxBytes)
+      return {
+        data: Buffer.from(inputBytes).toString("base64"),
+        mimeType: mimeType || `image/${format}`,
+        originalWidth,
+        originalHeight,
+        width: originalWidth,
+        height: originalHeight,
+        wasResized: !1
+      };
+    let targetWidth = originalWidth, targetHeight = originalHeight;
+    targetWidth > opts.maxWidth && (targetHeight = Math.round(targetHeight * opts.maxWidth / targetWidth), targetWidth = opts.maxWidth), targetHeight > opts.maxHeight && (targetWidth = Math.round(targetWidth * opts.maxHeight / targetHeight), targetHeight = opts.maxHeight);
+    let qualitySteps = Array.from(/* @__PURE__ */ new Set([opts.jpegQuality, 85, 70, 55, 40])), currentWidth = targetWidth, currentHeight = targetHeight;
+    for (; ; ) {
+      let candidates = tryEncodings(currentWidth, currentHeight, qualitySteps);
+      for (let candidate of candidates)
+        if (candidate.encodedSize < opts.maxBytes)
+          return {
+            data: candidate.data,
+            mimeType: candidate.mimeType,
+            originalWidth,
+            originalHeight,
+            width: currentWidth,
+            height: currentHeight,
+            wasResized: !0
+          };
+      if (currentWidth === 1 && currentHeight === 1)
+        break;
+      let nextWidth = currentWidth === 1 ? 1 : Math.max(1, Math.floor(currentWidth * 0.75)), nextHeight = currentHeight === 1 ? 1 : Math.max(1, Math.floor(currentHeight * 0.75));
+      if (nextWidth === currentWidth && nextHeight === currentHeight)
+        break;
+      currentWidth = nextWidth, currentHeight = nextHeight;
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    image && image.free();
+  }
+}
+
+// packages/coding-agent/dist/utils/image-resize.js
+function toTransferableBytes(input) {
+  return new Uint8Array(input);
+}
+function isResizeImageWorkerResponse(value) {
+  return value !== null && typeof value == "object";
+}
+function createResizeWorker(workerSpecifier) {
+  return new Worker(workerSpecifier);
+}
+async function resizeImageInWorker(workerSpecifier, inputBytes, mimeType, options) {
+  let worker = createResizeWorker(workerSpecifier);
+  try {
+    let inputBytesForWorker = toTransferableBytes(inputBytes);
+    return await new Promise((resolve, reject) => {
+      let settled = !1, settle = (result) => {
+        settled || (settled = !0, resolve(result));
+      }, fail = (error) => {
+        settled || (settled = !0, reject(error));
+      };
+      worker.once("message", (message) => {
+        if (!isResizeImageWorkerResponse(message)) {
+          fail(new Error("Invalid image resize worker response"));
+          return;
+        }
+        if (message.error) {
+          fail(new Error(message.error));
+          return;
+        }
+        settle(message.result ?? null);
+      }), worker.once("error", fail), worker.once("exit", (code) => {
+        settled || fail(new Error(`Image resize worker exited with code ${code}`));
+      }), worker.postMessage({
+        inputBytes: inputBytesForWorker,
+        mimeType,
+        options
+      }, [inputBytesForWorker.buffer]);
+    });
+  } finally {
+    worker.terminate().catch(() => {
+    });
+  }
+}
+async function resizeImage(inputBytes, mimeType, options) {
+  let isTypeScriptRuntime = new URL("../utils/image-resize.js", import.meta.url).href.endsWith(".ts"), workerUrl = new URL(isTypeScriptRuntime ? "./image-resize-worker.ts" : "./image-resize-worker.js", new URL("../utils/image-resize.js", import.meta.url).href);
+  if (typeof process.versions.bun == "string")
+    try {
+      return await resizeImageInWorker("./src/utils/image-resize-worker.ts", inputBytes, mimeType, options);
+    } catch {
+    }
+  try {
+    return await resizeImageInWorker(workerUrl, inputBytes, mimeType, options);
+  } catch {
+    return resizeImageInProcess(inputBytes, mimeType, options);
+  }
+}
+function formatDimensionNote(result) {
+  if (!result.wasResized)
+    return;
+  let scale = result.originalWidth / result.width;
+  return `[Image: original ${result.originalWidth}x${result.originalHeight}, displayed at ${result.width}x${result.height}. Multiply coordinates by ${scale.toFixed(2)} to map to original image.]`;
+}
+
+export {
+  applyExifOrientation,
+  resizeImage,
+  formatDimensionNote
+};

package/dist/node-runtime/cli-runtime.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  parseArgs
+} from "./chunk-DDGMHUOW.js";
+import {
+  markStartupMilestone
+} from "./chunk-CCZJ3PYY.js";
+import {
+  isNodeBundle
+} from "./chunk-PCIGF2XK.js";
+import "./chunk-Q4Q6D4IY.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/cli-runtime.js
+import { enableCompileCache } from "node:module";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// packages/coding-agent/dist/startup/launch-routing.js
+var DEFERRED_COMMANDS = /* @__PURE__ */ new Set([
+  "config",
+  "features",
+  "gateway",
+  "install",
+  "list",
+  "remove",
+  "setup",
+  "uninstall",
+  "update"
+]);
+function resolvePreloadLaunchMode(args2, environment) {
+  if (DEFERRED_COMMANDS.has(args2[0] ?? ""))
+    return "deferred";
+  let parsed = parseArgs([...args2]);
+  return parsed.help || parsed.version || parsed.print || parsed.export || parsed.listModels !== void 0 || parsed.mode === "rpc" || parsed.mode === "json" ? "deferred" : environment.startupBenchmark || environment.stdinIsTTY && environment.stdoutIsTTY ? "interactive" : "deferred";
+}
+
+// packages/coding-agent/dist/cli-runtime.js
+markStartupMilestone("process_entry");
+var startupAppName = process.env.PI_CODING_AGENT_DEV === "1" ? "lunr-dev" : "lunr";
+process.title = startupAppName;
+process.stdout.isTTY && process.stdout.write(`\x1B]0;${startupAppName}\x07`);
+if (!isNodeBundle)
+  try {
+    let agentDir = process.env.PI_CODING_AGENT_DIR?.trim() || join(homedir(), ".lunr", "agent");
+    enableCompileCache(join(agentDir, "compile-cache"));
+  } catch {
+  }
+process.env.PI_CODING_AGENT = "true";
+process.emitWarning = (() => {
+});
+var args = process.argv.slice(2), startupBenchmark = process.env.PI_STARTUP_BENCHMARK === "1", preloadMode = resolvePreloadLaunchMode(args, {
+  stdinIsTTY: process.stdin.isTTY === !0,
+  stdoutIsTTY: process.stdout.isTTY === !0,
+  startupBenchmark
+});
+markStartupMilestone("mode_routed");
+var startupView;
+if (preloadMode === "interactive") {
+  let { InteractiveView } = await import("./interactive-view-N6F4KUIT.js");
+  startupView = new InteractiveView(), startupView.start(), await startupView.waitForFirstFrame(), startupView.isExitRequested && process.exit(0);
+}
+var startRuntime = async () => {
+  let importStarted = performance.now();
+  try {
+    let [{ APP_NAME }, { main }, { noteImportMain }] = await Promise.all([
+      import("./config-FMEOZSWE.js"),
+      import("./main.js"),
+      import("./timings-UAD5BEAS.js")
+    ]);
+    noteImportMain(performance.now() - importStarted), process.title = APP_NAME, await main(args, { startupView });
+  } catch (error) {
+    if (startupBenchmark && console.error(error), startupView && !startupView.isExitRequested)
+      process.exitCode = 1, await startupView.fail(error);
+    else
+      throw error;
+  }
+};
+process.once("exit", () => startupView?.stop());
+startupView ? (await Promise.race([startRuntime(), startupView.waitForExit()]), startupView.isExitRequested && process.exit(process.exitCode ?? 0)) : await startRuntime();

package/dist/node-runtime/clipboard-OZ63BBC6.js

@@ -0,0 +1,12 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  copyToClipboard,
+  readClipboardText
+} from "./chunk-Q5ZU2VRT.js";
+import "./chunk-NUIFPZWX.js";
+import "./chunk-RQ2Q5IYR.js";
+import "./chunk-BRJX2PRC.js";
+export {
+  copyToClipboard,
+  readClipboardText
+};

package/dist/node-runtime/clipboard-image-7QR6GXVA.js

@@ -0,0 +1,13 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  extensionForImageMimeType,
+  isWaylandSession,
+  readClipboardImage
+} from "./chunk-NUIFPZWX.js";
+import "./chunk-RQ2Q5IYR.js";
+import "./chunk-BRJX2PRC.js";
+export {
+  extensionForImageMimeType,
+  isWaylandSession,
+  readClipboardImage
+};

package/dist/node-runtime/command-6UXQ6XZN.js

@@ -0,0 +1,13 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/gateway/command.js
+async function handleGatewayCommand(args) {
+  if (args[0] !== "gateway")
+    return !1;
+  let { runGateway } = await import("./gateway-3OLC4GQN.js"), code = await runGateway(args.slice(1));
+  return process.exitCode = code, !0;
+}
+export {
+  handleGatewayCommand
+};

package/dist/node-runtime/commands-LGR5VT5X.js

@@ -0,0 +1,293 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  buildToolMetadata,
+  getFailureAgeSeconds,
+  lazyConnect,
+  updateMetadataCache,
+  updateStatusBar
+} from "./chunk-BKAZ6BKX.js";
+import {
+  ensureCompatibilityImports,
+  getMcpDiscoverySummary,
+  getServerProvenance,
+  loadMetadataCache,
+  openPath,
+  previewCompatibilityImports,
+  previewSharedServerEntry,
+  previewStarterProjectConfig,
+  writeDirectToolsConfig,
+  writeSharedServerEntry,
+  writeStarterProjectConfig
+} from "./chunk-EHMBW7FA.js";
+import "./chunk-ARC4KOTI.js";
+import "./chunk-LWJXTA6Z.js";
+import {
+  authenticate,
+  getAuthForUrl,
+  removeAuth,
+  supportsOAuth
+} from "./chunk-U6C7VTR5.js";
+import {
+  getAgentPath
+} from "./chunk-4HXHDDCF.js";
+import "./chunk-2IDTZAG5.js";
+import "./chunk-BI3DHYCN.js";
+import "./chunk-Q4Q6D4IY.js";
+import "./chunk-BRJX2PRC.js";
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/onboarding-state.js
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from "node:fs";
+import { dirname } from "node:path";
+var DEFAULT_STATE = {
+  version: 1,
+  sharedConfigHintShown: !1,
+  setupCompleted: !1
+};
+function getOnboardingStatePath() {
+  return getAgentPath("mcp-onboarding.json");
+}
+function loadOnboardingState() {
+  let path = getOnboardingStatePath();
+  if (!existsSync(path))
+    return { ...DEFAULT_STATE };
+  try {
+    let raw = JSON.parse(readFileSync(path, "utf-8"));
+    return !raw || typeof raw != "object" ? { ...DEFAULT_STATE } : {
+      version: 1,
+      sharedConfigHintShown: raw.sharedConfigHintShown === !0,
+      setupCompleted: raw.setupCompleted === !0,
+      lastDiscoveryFingerprint: typeof raw.lastDiscoveryFingerprint == "string" ? raw.lastDiscoveryFingerprint : void 0
+    };
+  } catch {
+    return { ...DEFAULT_STATE };
+  }
+}
+function saveOnboardingState(state) {
+  let path = getOnboardingStatePath();
+  mkdirSync(dirname(path), { recursive: !0 });
+  let tmpPath = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmpPath, `${JSON.stringify(state, null, 2)}
+`, "utf-8"), renameSync(tmpPath, path);
+}
+function updateOnboardingState(updater) {
+  let next = updater(loadOnboardingState());
+  return saveOnboardingState(next), next;
+}
+function markSharedConfigHintShown(fingerprint) {
+  return updateOnboardingState((state) => ({
+    ...state,
+    sharedConfigHintShown: !0,
+    lastDiscoveryFingerprint: fingerprint ?? state.lastDiscoveryFingerprint
+  }));
+}
+function markSetupCompleted(fingerprint) {
+  return updateOnboardingState((state) => ({
+    ...state,
+    setupCompleted: !0,
+    lastDiscoveryFingerprint: fingerprint ?? state.lastDiscoveryFingerprint
+  }));
+}
+
+// packages/coding-agent/dist/builtin-extensions/pi-mcp-adapter/commands.js
+async function showStatus(state, ctx) {
+  if (!ctx.hasUI)
+    return;
+  let lines = ["MCP Server Status:", ""];
+  for (let name of Object.keys(state.config.mcpServers)) {
+    let connection = state.manager.getConnection(name), metadata = state.toolMetadata.get(name), toolCount = metadata?.length ?? 0, failedAgo = getFailureAgeSeconds(state, name), status = "not connected", statusIcon = "\u25CB", failed = !1;
+    connection?.status === "connected" ? (status = "connected", statusIcon = "\u2713") : connection?.status === "needs-auth" ? (status = "needs auth", statusIcon = "\u26A0") : failedAgo !== null ? (status = `failed ${failedAgo}s ago`, statusIcon = "\u2717", failed = !0) : metadata !== void 0 && (status = "cached");
+    let toolSuffix = failed ? "" : ` (${toolCount} tools${status === "cached" ? ", cached" : ""})`;
+    lines.push(`${statusIcon} ${name}: ${status}${toolSuffix}`);
+  }
+  Object.keys(state.config.mcpServers).length === 0 && (lines.push("No MCP servers configured"), lines.push("Run /mcp setup to adopt imports or scaffold a starter .mcp.json")), ctx.ui.notify(lines.join(`
+`), "info");
+}
+async function showTools(state, ctx) {
+  if (!ctx.hasUI)
+    return;
+  let allTools = [...state.toolMetadata.values()].flat().map((m) => m.name);
+  if (allTools.length === 0) {
+    ctx.ui.notify("No MCP tools available", "info");
+    return;
+  }
+  let lines = [
+    "MCP Tools:",
+    "",
+    ...allTools.map((t) => `  ${t}`),
+    "",
+    `Total: ${allTools.length} tools`
+  ];
+  ctx.ui.notify(lines.join(`
+`), "info");
+}
+async function reconnectServers(state, ctx, targetServer) {
+  if (targetServer && !state.config.mcpServers[targetServer]) {
+    ctx.hasUI && ctx.ui.notify(`Server "${targetServer}" not found in config`, "error");
+    return;
+  }
+  let entries = targetServer ? [[targetServer, state.config.mcpServers[targetServer]]] : Object.entries(state.config.mcpServers);
+  for (let [name, definition] of entries)
+    try {
+      await state.manager.close(name);
+      let connection = await state.manager.connect(name, definition);
+      if (connection.status === "needs-auth") {
+        ctx.hasUI && ctx.ui.notify(`MCP: ${name} requires OAuth. Run /mcp-auth ${name} first.`, "warning");
+        continue;
+      }
+      let prefix = state.config.settings?.toolPrefix ?? "server", { metadata, failedTools } = buildToolMetadata(connection.tools, connection.resources, definition, name, prefix);
+      state.toolMetadata.set(name, metadata), updateMetadataCache(state, name), state.failureTracker.delete(name), ctx.hasUI && (ctx.ui.notify(`MCP: Reconnected to ${name} (${connection.tools.length} tools, ${connection.resources.length} resources)`, "info"), failedTools.length > 0 && ctx.ui.notify(`MCP: ${name} - ${failedTools.length} tools skipped`, "warning"));
+    } catch (error) {
+      let message = error instanceof Error ? error.message : String(error);
+      state.failureTracker.set(name, Date.now()), ctx.hasUI && ctx.ui.notify(`MCP: Failed to reconnect to ${name}: ${message}`, "error");
+    }
+  updateStatusBar(state);
+}
+async function authenticateServer(serverName, config, ctx) {
+  if (!ctx.hasUI)
+    return { ok: !1, message: "OAuth authentication requires an interactive session." };
+  let definition = config.mcpServers[serverName];
+  if (!definition) {
+    let message = `Server "${serverName}" not found in config`;
+    return ctx.ui.notify(message, "error"), { ok: !1, message };
+  }
+  if (!supportsOAuth(definition)) {
+    let message = `Server "${serverName}" does not use OAuth authentication. Set "auth": "oauth" or omit auth for auto-detection.`;
+    return ctx.ui.notify(`Server "${serverName}" does not use OAuth authentication.
+Set "auth": "oauth" or omit auth for auto-detection.`, "error"), { ok: !1, message };
+  }
+  if (!definition.url) {
+    let message = `Server "${serverName}" has no URL configured (OAuth requires HTTP transport)`;
+    return ctx.ui.notify(message, "error"), { ok: !1, message };
+  }
+  try {
+    if (ctx.ui.setStatus("mcp-auth", `Authenticating ${serverName}...`), await authenticate(serverName, definition.url, definition, {
+      onAuthorizationUrl: (authorizationUrl) => {
+        ctx.ui.notify(`Open this URL to authenticate ${serverName}:
+
+${authorizationUrl}
+
+After approving, return to Pi; the local callback will complete automatically.`, "info");
+      }
+    }) === "authenticated") {
+      let message2 = `OAuth authentication successful for "${serverName}"! Run /mcp reconnect ${serverName} to connect with the new token.`;
+      return ctx.ui.notify(`OAuth authentication successful for "${serverName}"!
+Run /mcp reconnect ${serverName} to connect with the new token.`, "info"), { ok: !0, message: message2 };
+    }
+    let message = `OAuth authentication failed for "${serverName}".`;
+    return ctx.ui.notify(message, "error"), { ok: !1, message };
+  } catch (error) {
+    let message = error instanceof Error ? error.message : String(error);
+    return ctx.ui.notify(`Failed to authenticate "${serverName}": ${message}`, "error"), { ok: !1, message };
+  } finally {
+    ctx.ui.setStatus("mcp-auth", void 0);
+  }
+}
+async function logoutServer(serverName, state, ctx) {
+  if (!state.config.mcpServers[serverName]) {
+    let message2 = `Server "${serverName}" not found in config`;
+    return ctx.hasUI && ctx.ui.notify(message2, "error"), { ok: !1, message: message2 };
+  }
+  await removeAuth(serverName), await state.manager.close(serverName), updateStatusBar(state);
+  let message = `OAuth credentials cleared for "${serverName}". Run /mcp-auth ${serverName} to authenticate again.`;
+  return ctx.hasUI && ctx.ui.notify(message, "info"), { ok: !0, message };
+}
+function buildSharedConfigNoticeLines(configOverridePath, cwd) {
+  let discovery = getMcpDiscoverySummary(configOverridePath, cwd), onboardingState = loadOnboardingState();
+  return !discovery.hasSharedServers || onboardingState.sharedConfigHintShown ? { lines: [], fingerprint: null } : {
+    lines: [
+      `Using standard MCP config from ${discovery.sources.filter((source) => source.kind === "shared" && source.serverCount > 0).map((source) => source.path).join(", ")}.`,
+      "Pi only writes compatibility imports and adapter-specific overrides into Pi-owned files when needed."
+    ],
+    fingerprint: discovery.fingerprint
+  };
+}
+async function openMcpSetup(_state, pi, ctx, configOverridePath, mode = "setup") {
+  if (!ctx.hasUI)
+    return { configChanged: !1 };
+  let discovery = getMcpDiscoverySummary(configOverridePath, ctx.cwd), onboardingState = loadOnboardingState(), { createMcpSetupPanel } = await import("./mcp-setup-panel-FEK7663I.js"), configChanged = !1, callbacks = {
+    previewImports: (imports) => previewCompatibilityImports(imports, configOverridePath),
+    previewStarterProject: () => previewStarterProjectConfig(ctx.cwd),
+    previewRepoPrompt: () => {
+      let repoPrompt = getMcpDiscoverySummary(configOverridePath, ctx.cwd).repoPrompt;
+      return !repoPrompt.entry || !repoPrompt.targetPath || !repoPrompt.serverName ? null : previewSharedServerEntry(repoPrompt.targetPath, repoPrompt.serverName, repoPrompt.entry);
+    },
+    adoptImports: async (imports) => {
+      let result = ensureCompatibilityImports(imports, configOverridePath);
+      return result.added.length > 0 && (configChanged = !0), result;
+    },
+    scaffoldProjectConfig: async () => {
+      let path = writeStarterProjectConfig(ctx.cwd);
+      return configChanged = !0, { path };
+    },
+    addRepoPrompt: async () => {
+      let repoPrompt = getMcpDiscoverySummary(configOverridePath, ctx.cwd).repoPrompt;
+      if (!repoPrompt.entry || !repoPrompt.targetPath || !repoPrompt.serverName)
+        throw new Error("RepoPrompt is not available to add from this setup screen.");
+      let path = writeSharedServerEntry(repoPrompt.targetPath, repoPrompt.serverName, repoPrompt.entry);
+      return configChanged = !0, { path, serverName: repoPrompt.serverName };
+    },
+    openPath: async (targetPath) => {
+      await openPath(pi, targetPath);
+    },
+    markSetupCompleted: () => {
+      markSetupCompleted(discovery.fingerprint);
+    }
+  };
+  return new Promise((resolve) => {
+    ctx.ui.custom((tui, _theme, keybindings, done) => createMcpSetupPanel(discovery, callbacks, { mode, onboardingState, keybindings }, tui, () => {
+      done(void 0), resolve({ configChanged });
+    }), { overlay: !0, overlayOptions: { anchor: "center", width: 92 } });
+  });
+}
+function buildMcpPanelCallbacks(state, config, ctx) {
+  return {
+    reconnect: (serverName) => lazyConnect(state, serverName),
+    canAuthenticate: (serverName) => {
+      let definition = config.mcpServers[serverName];
+      return definition ? supportsOAuth(definition) : !1;
+    },
+    authenticate: (serverName) => authenticateServer(serverName, config, ctx),
+    getConnectionStatus: (serverName) => {
+      let definition = config.mcpServers[serverName], connection = state.manager.getConnection(serverName);
+      return connection?.status === "needs-auth" || definition?.auth === "oauth" && definition.url && definition.oauth !== !1 && definition.oauth?.grantType !== "client_credentials" && !getAuthForUrl(serverName, definition.url)?.tokens ? "needs-auth" : connection?.status === "connected" ? "connected" : getFailureAgeSeconds(state, serverName) !== null ? "failed" : "idle";
+    },
+    refreshCacheAfterReconnect: (serverName) => loadMetadataCache()?.servers?.[serverName] ?? null
+  };
+}
+async function openMcpPanel(state, pi, ctx, configOverridePath) {
+  if (Object.keys(state.config.mcpServers).length === 0)
+    return openMcpSetup(state, pi, ctx, configOverridePath, "empty");
+  let config = state.config, cache = loadMetadataCache(), configPath = pi.getFlag("mcp-config") ?? configOverridePath, provenanceMap = getServerProvenance(configPath, ctx.cwd), { lines: noticeLines, fingerprint } = buildSharedConfigNoticeLines(configPath, ctx.cwd), callbacks = buildMcpPanelCallbacks(state, config, ctx), { createMcpPanel } = await import("./mcp-panel-IIGMXQGP.js"), configChanged = !1;
+  return await new Promise((resolve) => {
+    ctx.ui.custom((tui, _theme, keybindings, done) => createMcpPanel(config, cache, provenanceMap, callbacks, tui, (result) => {
+      !result.cancelled && result.changes.size > 0 && (writeDirectToolsConfig(result.changes, provenanceMap, config), configChanged = !0, ctx.ui.notify("Direct tools updated. Pi will reload after this panel closes.", "info")), done(void 0), resolve();
+    }, { noticeLines, keybindings }), { overlay: !0, overlayOptions: { anchor: "center", width: 82 } });
+  }), noticeLines.length > 0 && fingerprint && markSharedConfigHintShown(fingerprint), { configChanged };
+}
+async function openMcpAuthPanel(state, pi, ctx, configOverridePath) {
+  if (!ctx.hasUI)
+    return { configChanged: !1 };
+  let config = state.config;
+  if (Object.entries(config.mcpServers).filter(([, definition]) => supportsOAuth(definition)).length === 0)
+    return ctx.ui.notify("No OAuth-capable MCP servers are configured.", "warning"), { configChanged: !1 };
+  let cache = loadMetadataCache(), configPath = pi.getFlag("mcp-config") ?? configOverridePath, provenanceMap = getServerProvenance(configPath, ctx.cwd), callbacks = buildMcpPanelCallbacks(state, config, ctx), { createMcpPanel } = await import("./mcp-panel-IIGMXQGP.js");
+  return await new Promise((resolve) => {
+    ctx.ui.custom((tui, _theme, keybindings, done) => createMcpPanel(config, cache, provenanceMap, callbacks, tui, () => {
+      done(void 0), resolve();
+    }, {
+      authOnly: !0,
+      keybindings,
+      noticeLines: ["Select an OAuth MCP server and press Enter or ctrl+a to authenticate."]
+    }), { overlay: !0, overlayOptions: { anchor: "center", width: 82 } });
+  }), { configChanged: !1 };
+}
+export {
+  authenticateServer,
+  logoutServer,
+  openMcpAuthPanel,
+  openMcpPanel,
+  openMcpSetup,
+  reconnectServers,
+  showStatus,
+  showTools
+};