@redscope-ai/redscope 1.0.0

package/dist/chunk-g7fwk59d.js

@@ -0,0 +1,19 @@
+// @bun
+import {
+  init_subprocessEnv,
+  registerUpstreamProxyEnvFn,
+  subprocessEnv
+} from "./chunk-q3b4n194.js";
+import"./chunk-s3hafnk3.js";
+import"./chunk-kb3758f7.js";
+import"./chunk-9h9k5vz3.js";
+import"./chunk-xmpgmeb8.js";
+import"./chunk-2kz09j2s.js";
+import"./chunk-c0k7b0jw.js";
+import"./chunk-hhsxm2yr.js";
+init_subprocessEnv();
+
+export {
+  subprocessEnv,
+  registerUpstreamProxyEnvFn
+};

package/dist/chunk-g9jnkrtm.js

@@ -0,0 +1,663 @@
+// @bun
+import {
+  Select,
+  clearServerCache,
+  detectIDEs,
+  detectRunningIDEs,
+  getCurrentWorktreeSession,
+  init_AppState,
+  init_CustomSelect,
+  init_client,
+  init_ide,
+  init_worktree,
+  isJetBrainsIde,
+  isSupportedJetBrainsTerminal,
+  isSupportedTerminal,
+  toIDEDisplayName,
+  useAppState,
+  useSetAppState
+} from "./chunk-gmdy2w3z.js";
+import"./chunk-q0e485mg.js";
+import"./chunk-2kcgxnvp.js";
+import"./chunk-14p6wvsq.js";
+import"./chunk-6s0q1s5r.js";
+import"./chunk-3w9sye8h.js";
+import"./chunk-nzxfj0gq.js";
+import"./chunk-vr0n9pv9.js";
+import"./chunk-9a9g5hbj.js";
+import"./chunk-ptxteaeh.js";
+import"./chunk-w4p5t920.js";
+import"./chunk-rgyzsbs3.js";
+import"./chunk-q3b4n194.js";
+import"./chunk-kywtr3jg.js";
+import"./chunk-eewg66y1.js";
+import"./chunk-71sdcaq6.js";
+import"./chunk-9hn8e6h1.js";
+import"./chunk-7qey87th.js";
+import"./chunk-zw62m6n3.js";
+import"./chunk-1w20m7gw.js";
+import"./chunk-zzf074w3.js";
+import"./chunk-rpmntgyh.js";
+import"./chunk-24kv69g3.js";
+import"./chunk-hzxzvzw8.js";
+import"./chunk-30wnahyg.js";
+import"./chunk-ztmb7geg.js";
+import"./chunk-tbdkekz3.js";
+import"./chunk-65zbgg1n.js";
+import"./chunk-4spgkgr3.js";
+import"./chunk-60fkafk2.js";
+import"./chunk-50m3a23z.js";
+import"./chunk-6hygvrhn.js";
+import"./chunk-7tfdhkpy.js";
+import"./chunk-8gv2pjby.js";
+import"./chunk-g06pm4n9.js";
+import"./chunk-2p369q9z.js";
+import"./chunk-z0jgeax8.js";
+import"./chunk-w68wc625.js";
+import"./chunk-6hr7742d.js";
+import"./chunk-xyg1sk2w.js";
+import"./chunk-935nrvdb.js";
+import"./chunk-8zz4z1q3.js";
+import"./chunk-fncpkzs5.js";
+import"./chunk-hqxp6b72.js";
+import"./chunk-m2c3bjv1.js";
+import"./chunk-jhtccjc9.js";
+import"./chunk-7nvday0n.js";
+import"./chunk-vxbjzggp.js";
+import"./chunk-yc1stfve.js";
+import"./chunk-8yvsnrkr.js";
+import"./chunk-5mmhfbxb.js";
+import {
+  getGlobalConfig,
+  init_config1 as init_config,
+  saveGlobalConfig
+} from "./chunk-eemjb825.js";
+import"./chunk-ga1jkyqy.js";
+import"./chunk-y1q7rt9n.js";
+import"./chunk-8kct9arg.js";
+import"./chunk-k7hexw3v.js";
+import"./chunk-trqrj23e.js";
+import"./chunk-za3k6h2h.js";
+import"./chunk-8kf8h7xf.js";
+import"./chunk-bgan4cpf.js";
+import"./chunk-jmv7k0jn.js";
+import"./chunk-hjxqmtg5.js";
+import"./chunk-bzyzrq0k.js";
+import"./chunk-vwenx8ke.js";
+import"./chunk-q2h79ncs.js";
+import"./chunk-v4ypszbb.js";
+import"./chunk-qfsn720k.js";
+import"./chunk-7qx3xhv3.js";
+import"./chunk-j9475b46.js";
+import"./chunk-fdwabr8p.js";
+import"./chunk-e4dsy4g1.js";
+import"./chunk-326zehp8.js";
+import"./chunk-kc67kt75.js";
+import"./chunk-40t1d75v.js";
+import"./chunk-dbts5q5p.js";
+import"./chunk-e3abfxpy.js";
+import"./chunk-q44zc68f.js";
+import"./chunk-fejeqe61.js";
+import"./chunk-q1vrhh0q.js";
+import"./chunk-hn4w9pkj.js";
+import {
+  Dialog,
+  ThemedBox_default,
+  ThemedText,
+  init_source,
+  init_src,
+  source_default
+} from "./chunk-2g0ytd9d.js";
+import {
+  require_jsx_dev_runtime,
+  require_react
+} from "./chunk-de0qnnf7.js";
+import {
+  init_analytics,
+  logEvent
+} from "./chunk-j1mep9ck.js";
+import"./chunk-6x35ffpx.js";
+import"./chunk-1zbwhcbt.js";
+import"./chunk-92bjkrf2.js";
+import"./chunk-10k5jfc5.js";
+import"./chunk-n9g24mwe.js";
+import"./chunk-e3j7m7k2.js";
+import {
+  execFileNoThrow,
+  init_execFileNoThrow
+} from "./chunk-hzmzwte2.js";
+import {
+  getCwd,
+  init_cwd
+} from "./chunk-pdvg91cg.js";
+import"./chunk-c696122m.js";
+import"./chunk-xbj5keyy.js";
+import"./chunk-c1yc761e.js";
+import"./chunk-c5g9shkw.js";
+import"./chunk-aeysytks.js";
+import"./chunk-s3hafnk3.js";
+import"./chunk-kb3758f7.js";
+import"./chunk-9h9k5vz3.js";
+import"./chunk-xmpgmeb8.js";
+import"./chunk-2kz09j2s.js";
+import"./chunk-c0k7b0jw.js";
+import"./chunk-pecy49yr.js";
+import"./chunk-azbab59e.js";
+import"./chunk-3nk9q8dr.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-hhsxm2yr.js";
+
+// src/components/IdeAutoConnectDialog.tsx
+function IdeAutoConnectDialog({
+  onComplete
+}) {
+  const handleSelect = import_react.useCallback(async (value) => {
+    const autoConnect = value === "yes";
+    saveGlobalConfig((current) => ({
+      ...current,
+      autoConnectIde: autoConnect,
+      hasIdeAutoConnectDialogBeenShown: true
+    }));
+    onComplete();
+  }, [onComplete]);
+  const options = [
+    { label: "Yes", value: "yes" },
+    { label: "No", value: "no" }
+  ];
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Dialog, {
+    title: "Do you wish to enable auto-connect to IDE?",
+    color: "ide",
+    onCancel: onComplete,
+    children: [
+      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Select, {
+        options,
+        onChange: handleSelect,
+        defaultValue: "yes"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+        dimColor: true,
+        children: "You can also configure this in /config or with the --ide flag"
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function shouldShowAutoConnectDialog() {
+  const config = getGlobalConfig();
+  return !isSupportedTerminal() && config.autoConnectIde !== true && config.hasIdeAutoConnectDialogBeenShown !== true;
+}
+function IdeDisableAutoConnectDialog({
+  onComplete
+}) {
+  const handleSelect = import_react.useCallback((value) => {
+    const disableAutoConnect = value === "yes";
+    if (disableAutoConnect) {
+      saveGlobalConfig((current) => ({
+        ...current,
+        autoConnectIde: false
+      }));
+    }
+    onComplete(disableAutoConnect);
+  }, [onComplete]);
+  const handleCancel = import_react.useCallback(() => {
+    onComplete(false);
+  }, [onComplete]);
+  const options = [
+    { label: "No", value: "no" },
+    { label: "Yes", value: "yes" }
+  ];
+  return /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Dialog, {
+    title: "Do you wish to disable auto-connect to IDE?",
+    subtitle: "You can also configure this in /config",
+    onCancel: handleCancel,
+    color: "ide",
+    children: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Select, {
+      options,
+      onChange: handleSelect,
+      defaultValue: "no"
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+function shouldShowDisableAutoConnectDialog() {
+  const config = getGlobalConfig();
+  return !isSupportedTerminal() && config.autoConnectIde === true;
+}
+var import_react, jsx_dev_runtime;
+var init_IdeAutoConnectDialog = __esm(() => {
+  init_src();
+  init_config();
+  init_ide();
+  init_CustomSelect();
+  import_react = __toESM(require_react(), 1);
+  jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+});
+
+// src/commands/ide/ide.tsx
+import * as path from "path";
+function IDEScreen({
+  availableIDEs,
+  unavailableIDEs,
+  selectedIDE,
+  onClose,
+  onSelect
+}) {
+  const [selectedValue, setSelectedValue] = import_react2.useState(selectedIDE?.port?.toString() ?? "None");
+  const [showAutoConnectDialog, setShowAutoConnectDialog] = import_react2.useState(false);
+  const [showDisableAutoConnectDialog, setShowDisableAutoConnectDialog] = import_react2.useState(false);
+  const handleSelectIDE = import_react2.useCallback((value) => {
+    if (value !== "None" && shouldShowAutoConnectDialog()) {
+      setShowAutoConnectDialog(true);
+    } else if (value === "None" && shouldShowDisableAutoConnectDialog()) {
+      setShowDisableAutoConnectDialog(true);
+    } else {
+      onSelect(availableIDEs.find((ide) => ide.port === parseInt(value, 10)));
+    }
+  }, [availableIDEs, onSelect]);
+  const ideCounts = availableIDEs.reduce((acc, ide) => {
+    acc[ide.name] = (acc[ide.name] || 0) + 1;
+    return acc;
+  }, {});
+  const options = availableIDEs.map((ide) => {
+    const hasMultipleInstances = (ideCounts[ide.name] || 0) > 1;
+    const showWorkspace = hasMultipleInstances && ide.workspaceFolders.length > 0;
+    return {
+      label: ide.name,
+      value: ide.port.toString(),
+      description: showWorkspace ? formatWorkspaceFolders(ide.workspaceFolders) : undefined
+    };
+  }).concat([{ label: "None", value: "None", description: undefined }]);
+  if (showAutoConnectDialog) {
+    return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(IdeAutoConnectDialog, {
+      onComplete: () => handleSelectIDE(selectedValue)
+    }, undefined, false, undefined, this);
+  }
+  if (showDisableAutoConnectDialog) {
+    return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(IdeDisableAutoConnectDialog, {
+      onComplete: () => {
+        onSelect(undefined);
+      }
+    }, undefined, false, undefined, this);
+  }
+  return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Dialog, {
+    title: "Select IDE",
+    subtitle: "Connect to an IDE for integrated development features.",
+    onCancel: onClose,
+    color: "ide",
+    children: /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedBox_default, {
+      flexDirection: "column",
+      children: [
+        availableIDEs.length === 0 && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedText, {
+          dimColor: true,
+          children: isSupportedJetBrainsTerminal() ? `No available IDEs detected. Please install the plugin and restart your IDE:
+` + "https://docs.claude.com/s/claude-code-jetbrains" : "No available IDEs detected. Make sure your IDE has the RedScope AI extension or plugin installed and is running."
+        }, undefined, false, undefined, this),
+        availableIDEs.length !== 0 && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Select, {
+          defaultValue: selectedValue,
+          defaultFocusValue: selectedValue,
+          options,
+          onChange: (value) => {
+            setSelectedValue(value);
+            handleSelectIDE(value);
+          }
+        }, undefined, false, undefined, this),
+        availableIDEs.length !== 0 && availableIDEs.some((ide) => ide.name === "VS Code" || ide.name === "Visual Studio Code") && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedBox_default, {
+          marginTop: 1,
+          children: /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedText, {
+            color: "warning",
+            children: "Note: Only one RedScope AI instance can be connected to VS Code at a time."
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this),
+        availableIDEs.length !== 0 && !isSupportedTerminal() && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedBox_default, {
+          marginTop: 1,
+          children: /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedText, {
+            dimColor: true,
+            children: "Tip: You can enable auto-connect to IDE in /config or with the --ide flag"
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this),
+        unavailableIDEs.length > 0 && /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedBox_default, {
+          marginTop: 1,
+          flexDirection: "column",
+          children: [
+            /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedText, {
+              dimColor: true,
+              children: [
+                "Found ",
+                unavailableIDEs.length,
+                " other running IDE(s). However, their workspace/project directories do not match the current cwd."
+              ]
+            }, undefined, true, undefined, this),
+            /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedBox_default, {
+              marginTop: 1,
+              flexDirection: "column",
+              children: unavailableIDEs.map((ide, index) => /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedBox_default, {
+                paddingLeft: 3,
+                children: /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedText, {
+                  dimColor: true,
+                  children: [
+                    "\u2022 ",
+                    ide.name,
+                    ": ",
+                    formatWorkspaceFolders(ide.workspaceFolders)
+                  ]
+                }, undefined, true, undefined, this)
+              }, index, false, undefined, this))
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this)
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
+async function findCurrentIDE(availableIDEs, dynamicMcpConfig) {
+  const currentConfig = dynamicMcpConfig?.ide;
+  if (!currentConfig || currentConfig.type !== "sse-ide" && currentConfig.type !== "ws-ide") {
+    return null;
+  }
+  for (const ide of availableIDEs) {
+    if (ide.url === currentConfig.url) {
+      return ide;
+    }
+  }
+  return null;
+}
+function IDEOpenSelection({
+  availableIDEs,
+  onSelectIDE,
+  onDone
+}) {
+  const [selectedValue, setSelectedValue] = import_react2.useState(availableIDEs[0]?.port?.toString() ?? "");
+  const handleSelectIDE = import_react2.useCallback((value) => {
+    const selectedIDE = availableIDEs.find((ide) => ide.port === parseInt(value, 10));
+    onSelectIDE(selectedIDE);
+  }, [availableIDEs, onSelectIDE]);
+  const options = availableIDEs.map((ide) => ({
+    label: ide.name,
+    value: ide.port.toString()
+  }));
+  function handleCancel() {
+    onDone("IDE selection cancelled", { display: "system" });
+  }
+  return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Dialog, {
+    title: "Select an IDE to open the project",
+    onCancel: handleCancel,
+    color: "ide",
+    children: /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Select, {
+      defaultValue: selectedValue,
+      defaultFocusValue: selectedValue,
+      options,
+      onChange: (value) => {
+        setSelectedValue(value);
+        handleSelectIDE(value);
+      }
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+function RunningIDESelector({
+  runningIDEs,
+  onSelectIDE,
+  onDone
+}) {
+  const [selectedValue, setSelectedValue] = import_react2.useState(runningIDEs[0] ?? "");
+  const handleSelectIDE = import_react2.useCallback((value) => {
+    onSelectIDE(value);
+  }, [onSelectIDE]);
+  const options = runningIDEs.map((ide) => ({
+    label: toIDEDisplayName(ide),
+    value: ide
+  }));
+  function handleCancel() {
+    onDone("IDE selection cancelled", { display: "system" });
+  }
+  return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Dialog, {
+    title: "Select IDE to install extension",
+    onCancel: handleCancel,
+    color: "ide",
+    children: /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(Select, {
+      defaultFocusValue: selectedValue,
+      options,
+      onChange: (value) => {
+        setSelectedValue(value);
+        handleSelectIDE(value);
+      }
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+function InstallOnMount({
+  ide,
+  onInstall
+}) {
+  import_react2.useEffect(() => {
+    onInstall(ide);
+  }, [ide, onInstall]);
+  return null;
+}
+async function call(onDone, context, args) {
+  logEvent("tengu_ext_ide_command", {});
+  const {
+    options: { dynamicMcpConfig },
+    onChangeDynamicMcpConfig
+  } = context;
+  if (args?.trim() === "open") {
+    const worktreeSession = getCurrentWorktreeSession();
+    const targetPath = worktreeSession ? worktreeSession.worktreePath : getCwd();
+    const detectedIDEs2 = await detectIDEs(true);
+    const availableIDEs2 = detectedIDEs2.filter((ide) => ide.isValid);
+    if (availableIDEs2.length === 0) {
+      onDone("No IDEs with RedScope AI extension detected.");
+      return null;
+    }
+    return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(IDEOpenSelection, {
+      availableIDEs: availableIDEs2,
+      onSelectIDE: async (selectedIDE) => {
+        if (!selectedIDE) {
+          onDone("No IDE selected.");
+          return;
+        }
+        if (selectedIDE.name.toLowerCase().includes("vscode") || selectedIDE.name.toLowerCase().includes("cursor") || selectedIDE.name.toLowerCase().includes("windsurf")) {
+          const { code } = await execFileNoThrow("code", [targetPath]);
+          if (code === 0) {
+            onDone(`Opened ${worktreeSession ? "worktree" : "project"} in ${source_default.bold(selectedIDE.name)}`);
+          } else {
+            onDone(`Failed to open in ${selectedIDE.name}. Try opening manually: ${targetPath}`);
+          }
+        } else if (isSupportedJetBrainsTerminal()) {
+          onDone(`Please open the ${worktreeSession ? "worktree" : "project"} manually in ${source_default.bold(selectedIDE.name)}: ${targetPath}`);
+        } else {
+          onDone(`Please open the ${worktreeSession ? "worktree" : "project"} manually in ${source_default.bold(selectedIDE.name)}: ${targetPath}`);
+        }
+      },
+      onDone: () => {
+        onDone("Exited without opening IDE", { display: "system" });
+      }
+    }, undefined, false, undefined, this);
+  }
+  const detectedIDEs = await detectIDEs(true);
+  if (detectedIDEs.length === 0 && context.onInstallIDEExtension && !isSupportedTerminal()) {
+    const runningIDEs = await detectRunningIDEs();
+    const onInstall = (ide) => {
+      if (context.onInstallIDEExtension) {
+        context.onInstallIDEExtension(ide);
+        if (isJetBrainsIde(ide)) {
+          onDone(`Installed plugin to ${source_default.bold(toIDEDisplayName(ide))}
+` + `Please ${source_default.bold("restart your IDE")} completely for it to take effect`);
+        } else {
+          onDone(`Installed extension to ${source_default.bold(toIDEDisplayName(ide))}`);
+        }
+      }
+    };
+    if (runningIDEs.length > 1) {
+      return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(RunningIDESelector, {
+        runningIDEs,
+        onSelectIDE: onInstall,
+        onDone: () => {
+          onDone("No IDE selected.", { display: "system" });
+        }
+      }, undefined, false, undefined, this);
+    } else if (runningIDEs.length === 1) {
+      return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(InstallOnMount, {
+        ide: runningIDEs[0],
+        onInstall
+      }, undefined, false, undefined, this);
+    }
+  }
+  const availableIDEs = detectedIDEs.filter((ide) => ide.isValid);
+  const unavailableIDEs = detectedIDEs.filter((ide) => !ide.isValid);
+  const currentIDE = await findCurrentIDE(availableIDEs, dynamicMcpConfig);
+  return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(IDECommandFlow, {
+    availableIDEs,
+    unavailableIDEs,
+    currentIDE,
+    dynamicMcpConfig,
+    onChangeDynamicMcpConfig,
+    onDone
+  }, undefined, false, undefined, this);
+}
+function IDECommandFlow({
+  availableIDEs,
+  unavailableIDEs,
+  currentIDE,
+  dynamicMcpConfig,
+  onChangeDynamicMcpConfig,
+  onDone
+}) {
+  const [connectingIDE, setConnectingIDE] = import_react2.useState(null);
+  const ideClient = useAppState((s) => s.mcp.clients.find((c) => c.name === "ide"));
+  const setAppState = useSetAppState();
+  const isFirstCheckRef = import_react2.useRef(true);
+  import_react2.useEffect(() => {
+    if (!connectingIDE)
+      return;
+    if (isFirstCheckRef.current) {
+      isFirstCheckRef.current = false;
+      return;
+    }
+    if (!ideClient || ideClient.type === "pending")
+      return;
+    if (ideClient.type === "connected") {
+      onDone(`Connected to ${connectingIDE.name}.`);
+    } else if (ideClient.type === "failed") {
+      onDone(`Failed to connect to ${connectingIDE.name}.`);
+    }
+  }, [ideClient, connectingIDE, onDone]);
+  import_react2.useEffect(() => {
+    if (!connectingIDE)
+      return;
+    const timer = setTimeout(onDone, IDE_CONNECTION_TIMEOUT_MS, `Connection to ${connectingIDE.name} timed out.`);
+    return () => clearTimeout(timer);
+  }, [connectingIDE, onDone]);
+  const handleSelectIDE = import_react2.useCallback((selectedIDE) => {
+    if (!onChangeDynamicMcpConfig) {
+      onDone("Error connecting to IDE.");
+      return;
+    }
+    const newConfig = { ...dynamicMcpConfig || {} };
+    if (currentIDE) {
+      delete newConfig.ide;
+    }
+    if (!selectedIDE) {
+      if (ideClient && ideClient.type === "connected" && currentIDE) {
+        ideClient.client.onclose = () => {};
+        clearServerCache("ide", ideClient.config);
+        setAppState((prev) => ({
+          ...prev,
+          mcp: {
+            ...prev.mcp,
+            clients: prev.mcp.clients.filter((c) => c.name !== "ide"),
+            tools: prev.mcp.tools.filter((t) => !t.name?.startsWith("mcp__ide__")),
+            commands: prev.mcp.commands.filter((c) => !c.name?.startsWith("mcp__ide__"))
+          }
+        }));
+      }
+      onChangeDynamicMcpConfig(newConfig);
+      onDone(currentIDE ? `Disconnected from ${currentIDE.name}.` : "No IDE selected.");
+      return;
+    }
+    const url = selectedIDE.url;
+    newConfig.ide = {
+      type: url.startsWith("ws:") ? "ws-ide" : "sse-ide",
+      url,
+      ideName: selectedIDE.name,
+      authToken: selectedIDE.authToken,
+      ideRunningInWindows: selectedIDE.ideRunningInWindows,
+      scope: "dynamic"
+    };
+    isFirstCheckRef.current = true;
+    setConnectingIDE(selectedIDE);
+    onChangeDynamicMcpConfig(newConfig);
+  }, [
+    dynamicMcpConfig,
+    currentIDE,
+    ideClient,
+    setAppState,
+    onChangeDynamicMcpConfig,
+    onDone
+  ]);
+  if (connectingIDE) {
+    return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(ThemedText, {
+      dimColor: true,
+      children: [
+        "Connecting to ",
+        connectingIDE.name,
+        "\u2026"
+      ]
+    }, undefined, true, undefined, this);
+  }
+  return /* @__PURE__ */ jsx_dev_runtime2.jsxDEV(IDEScreen, {
+    availableIDEs,
+    unavailableIDEs,
+    selectedIDE: currentIDE,
+    onClose: () => onDone("IDE selection cancelled", { display: "system" }),
+    onSelect: handleSelectIDE
+  }, undefined, false, undefined, this);
+}
+function formatWorkspaceFolders(folders, maxLength = 100) {
+  if (folders.length === 0)
+    return "";
+  const cwd = getCwd();
+  const foldersToShow = folders.slice(0, 2);
+  const hasMore = folders.length > 2;
+  const ellipsisOverhead = hasMore ? 3 : 0;
+  const separatorOverhead = (foldersToShow.length - 1) * 2;
+  const availableLength = maxLength - separatorOverhead - ellipsisOverhead;
+  const maxLengthPerPath = Math.floor(availableLength / foldersToShow.length);
+  const cwdNFC = cwd.normalize("NFC");
+  const formattedFolders = foldersToShow.map((folder) => {
+    const folderNFC = folder.normalize("NFC");
+    if (folderNFC.startsWith(cwdNFC + path.sep)) {
+      folder = folderNFC.slice(cwdNFC.length + 1);
+    }
+    if (folder.length <= maxLengthPerPath) {
+      return folder;
+    }
+    return "\u2026" + folder.slice(-(maxLengthPerPath - 1));
+  });
+  let result = formattedFolders.join(", ");
+  if (hasMore) {
+    result += ", \u2026";
+  }
+  return result;
+}
+var import_react2, jsx_dev_runtime2, IDE_CONNECTION_TIMEOUT_MS = 35000;
+var init_ide2 = __esm(() => {
+  init_source();
+  init_analytics();
+  init_CustomSelect();
+  init_src();
+  init_IdeAutoConnectDialog();
+  init_src();
+  init_client();
+  init_AppState();
+  init_cwd();
+  init_execFileNoThrow();
+  init_ide();
+  init_worktree();
+  import_react2 = __toESM(require_react(), 1);
+  jsx_dev_runtime2 = __toESM(require_jsx_dev_runtime(), 1);
+});
+init_ide2();
+
+export {
+  formatWorkspaceFolders,
+  call
+};