@qwen-code/qwen-code 0.19.7 → 0.19.8-nightly.20260710.205430235

package/chunks/{chunk-Q6OEPOOC.js → chunk-TB6GWNV4.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   BaseJsonOutputAdapter
-} from "./chunk-YDSYD7UI.js";
+} from "./chunk-E3SA2LY4.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-24XYI5EI.js → chunk-TERKDCOZ.js}

@@ -5,10 +5,10 @@ import {
 } from "./chunk-KHDZHZMH.js";
 import {
   getCliVersion
-} from "./chunk-GD236YPV.js";
+} from "./chunk-4ONWIT5C.js";
 import {
   IdeClient
-} from "./chunk-YEGT55NW.js";
+} from "./chunk-ZDAZSR2O.js";
 import {
   createDebugLogger
 } from "./chunk-22MNNNXE.js";
@@ -27,7 +27,7 @@ import { execFile } from "node:child_process";
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO = "47978cd9e";
+var GIT_COMMIT_INFO = "4fe960c59";
 
 // packages/cli/src/utils/systemInfo.ts
 var debugLogger = createDebugLogger("STATUS");

package/chunks/chunk-TVO5C767.js

@@ -0,0 +1,159 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  SessionNotFoundError
+} from "./chunk-GGQQA4JW.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/workspace-registry.ts
+init_esbuild_shims();
+function createWorkspaceSessionOwnerIndex() {
+  const bySessionId = /* @__PURE__ */ new Map();
+  const register = /* @__PURE__ */ __name((sessionId, workspaceCwd) => {
+    let owners = bySessionId.get(sessionId);
+    if (!owners) {
+      owners = /* @__PURE__ */ new Set();
+      bySessionId.set(sessionId, owners);
+    }
+    owners.add(workspaceCwd);
+  }, "register");
+  const remove = /* @__PURE__ */ __name((sessionId, workspaceCwd) => {
+    if (workspaceCwd === void 0) {
+      bySessionId.delete(sessionId);
+      return;
+    }
+    const owners = bySessionId.get(sessionId);
+    if (!owners) return;
+    owners.delete(workspaceCwd);
+    if (owners.size === 0) {
+      bySessionId.delete(sessionId);
+    }
+  }, "remove");
+  return {
+    register,
+    remove,
+    getWorkspaceCwds: /* @__PURE__ */ __name((sessionId) => [...bySessionId.get(sessionId) ?? []], "getWorkspaceCwds"),
+    handleBridgeSessionLifecycle: /* @__PURE__ */ __name((event) => {
+      if (event.type === "registered") {
+        register(event.sessionId, event.workspaceCwd);
+      } else {
+        remove(event.sessionId, event.workspaceCwd);
+      }
+    }, "handleBridgeSessionLifecycle")
+  };
+}
+__name(createWorkspaceSessionOwnerIndex, "createWorkspaceSessionOwnerIndex");
+function createWorkspaceRegistry(inputRuntimes, options = {}) {
+  if (inputRuntimes.length === 0) {
+    throw new Error(
+      "WorkspaceRegistry requires at least one workspace runtime."
+    );
+  }
+  const primaryRuntimes = inputRuntimes.filter((runtime) => runtime.primary);
+  if (primaryRuntimes.length !== 1) {
+    throw new Error(
+      "WorkspaceRegistry requires exactly one primary workspace runtime."
+    );
+  }
+  const byCwd = /* @__PURE__ */ new Map();
+  const byId = /* @__PURE__ */ new Map();
+  for (const runtime of inputRuntimes) {
+    if (byCwd.has(runtime.workspaceCwd)) {
+      throw new Error(
+        `Duplicate workspace runtime cwd ${JSON.stringify(
+          runtime.workspaceCwd
+        )}.`
+      );
+    }
+    byCwd.set(runtime.workspaceCwd, runtime);
+    if (byId.has(runtime.workspaceId)) {
+      throw new Error(
+        `Duplicate workspace runtime id ${JSON.stringify(
+          runtime.workspaceId
+        )}.`
+      );
+    }
+    byId.set(runtime.workspaceId, runtime);
+  }
+  const runtimes = Object.freeze([...inputRuntimes]);
+  const primary = primaryRuntimes[0];
+  const sessionOwnerIndex = options.sessionOwnerIndex;
+  const scanLiveOwners = /* @__PURE__ */ __name((sessionId) => {
+    const matches = [];
+    for (const runtime of runtimes) {
+      try {
+        runtime.bridge.getSessionSummary(sessionId);
+        matches.push(runtime);
+      } catch (err) {
+        if (err instanceof SessionNotFoundError) continue;
+        throw err;
+      }
+    }
+    for (const match of matches) {
+      sessionOwnerIndex?.register(sessionId, match.workspaceCwd);
+    }
+    if (matches.length === 0) return { kind: "not_found" };
+    if (matches.length === 1) {
+      return { kind: "found", runtime: matches[0] };
+    }
+    return { kind: "ambiguous", runtimes: matches };
+  }, "scanLiveOwners");
+  return {
+    primary,
+    list: /* @__PURE__ */ __name(() => runtimes, "list"),
+    getByWorkspaceCwd: /* @__PURE__ */ __name((workspaceCwd) => byCwd.get(workspaceCwd), "getByWorkspaceCwd"),
+    getByWorkspaceId: /* @__PURE__ */ __name((workspaceId) => byId.get(workspaceId), "getByWorkspaceId"),
+    resolveWorkspaceCwd: /* @__PURE__ */ __name((workspaceCwd) => workspaceCwd === void 0 ? primary : byCwd.get(workspaceCwd), "resolveWorkspaceCwd"),
+    resolveLiveSessionOwner: /* @__PURE__ */ __name((sessionId) => {
+      const indexedCwds = sessionOwnerIndex?.getWorkspaceCwds(sessionId) ?? [];
+      if (indexedCwds.length > 0) {
+        const matches = [];
+        for (const workspaceCwd of indexedCwds) {
+          const runtime = byCwd.get(workspaceCwd);
+          if (!runtime) {
+            sessionOwnerIndex?.remove(sessionId, workspaceCwd);
+            continue;
+          }
+          try {
+            runtime.bridge.getSessionSummary(sessionId);
+            matches.push(runtime);
+          } catch (err) {
+            if (err instanceof SessionNotFoundError) {
+              sessionOwnerIndex?.remove(sessionId, workspaceCwd);
+              continue;
+            }
+            throw err;
+          }
+        }
+        if (matches.length === 1) {
+          return { kind: "found", runtime: matches[0] };
+        }
+        if (matches.length > 1) {
+          return { kind: "ambiguous", runtimes: matches };
+        }
+      }
+      return scanLiveOwners(sessionId);
+    }, "resolveLiveSessionOwner")
+  };
+}
+__name(createWorkspaceRegistry, "createWorkspaceRegistry");
+function createSingleWorkspaceRegistry(runtime, options = {}) {
+  return createWorkspaceRegistry([runtime], options);
+}
+__name(createSingleWorkspaceRegistry, "createSingleWorkspaceRegistry");
+
+export {
+  createWorkspaceSessionOwnerIndex,
+  createWorkspaceRegistry,
+  createSingleWorkspaceRegistry
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-TBAZMRW3.js → chunk-TVW53EK7.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getGlobalQwenDir
-} from "./chunk-2NPS2UDH.js";
+} from "./chunk-YUNPEB3Q.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/chunk-TX5QZYK6.js

@@ -0,0 +1,296 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  isGitRepository
+} from "./chunk-ZDAZSR2O.js";
+import {
+  createDebugLogger
+} from "./chunk-22MNNNXE.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/utils/installationInfo.ts
+init_esbuild_shims();
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as childProcess from "node:child_process";
+var PackageManager = /* @__PURE__ */ ((PackageManager2) => {
+  PackageManager2["NPM"] = "npm";
+  PackageManager2["YARN"] = "yarn";
+  PackageManager2["PNPM"] = "pnpm";
+  PackageManager2["PNPX"] = "pnpx";
+  PackageManager2["BUN"] = "bun";
+  PackageManager2["BUNX"] = "bunx";
+  PackageManager2["HOMEBREW"] = "homebrew";
+  PackageManager2["STANDALONE"] = "standalone";
+  PackageManager2["NPX"] = "npx";
+  PackageManager2["UNKNOWN"] = "unknown";
+  return PackageManager2;
+})(PackageManager || {});
+var debugLogger = createDebugLogger("INSTALLATION_INFO");
+var STANDALONE_UNIX_INSTALLER = "https://qwen-code-assets.oss-cn-hangzhou.aliyuncs.com/installation/install-qwen-standalone.sh";
+var STANDALONE_WINDOWS_INSTALLER = "https://qwen-code-assets.oss-cn-hangzhou.aliyuncs.com/installation/install-qwen-standalone.ps1";
+function getStandaloneInstallerUrl() {
+  return process.platform === "win32" ? STANDALONE_WINDOWS_INSTALLER : STANDALONE_UNIX_INSTALLER;
+}
+__name(getStandaloneInstallerUrl, "getStandaloneInstallerUrl");
+function resolveUpdateCommand(updateCommand, latestVersion) {
+  const isNightly = latestVersion.includes("nightly");
+  return updateCommand.replace(
+    "@latest",
+    isNightly ? "@nightly" : `@${latestVersion}`
+  );
+}
+__name(resolveUpdateCommand, "resolveUpdateCommand");
+function formatUpdateInstructions(installationInfo, latestVersion) {
+  const lines = [];
+  if (installationInfo.updateMessage && !installationInfo.updateCommand) {
+    lines.push(
+      ...formatUpdateMessage(installationInfo.updateMessage, latestVersion)
+    );
+  }
+  if (installationInfo.updateCommand) {
+    const updateCmd = resolveUpdateCommand(
+      installationInfo.updateCommand,
+      latestVersion
+    );
+    lines.push("Run the following to update:", `  ${updateCmd}`);
+  } else if (!installationInfo.updateMessage) {
+    lines.push("Manual update required. Please reinstall Qwen Code.");
+  }
+  return lines;
+}
+__name(formatUpdateInstructions, "formatUpdateInstructions");
+function formatUpdateMessage(updateMessage, latestVersion) {
+  const message = resolveUpdateCommand(updateMessage, latestVersion);
+  const sudoPrefix = "Update requires sudo. Please run: ";
+  if (message.startsWith(sudoPrefix)) {
+    return [
+      "Update requires sudo. Please run:",
+      `  ${message.slice(sudoPrefix.length)}`
+    ];
+  }
+  return [message];
+}
+__name(formatUpdateMessage, "formatUpdateMessage");
+function getInstallationInfo(projectRoot, isAutoUpdateEnabled) {
+  const cliPath = process.argv[1];
+  if (!cliPath) {
+    return { packageManager: "unknown" /* UNKNOWN */, isGlobal: false };
+  }
+  try {
+    const realPath = fs.realpathSync(cliPath).replace(/\\/g, "/");
+    const normalizedProjectRoot = projectRoot?.replace(/\\/g, "/");
+    const isGit = isGitRepository(process.cwd());
+    if (isGit && normalizedProjectRoot && isSamePathOrInside(realPath, normalizedProjectRoot) && !realPath.includes("/node_modules/")) {
+      return {
+        packageManager: "unknown" /* UNKNOWN */,
+        // Not managed by a package manager in this sense
+        isGlobal: false,
+        updateMessage: 'Running from a local git clone. Please update with "git pull".'
+      };
+    }
+    if (realPath.includes("/.npm/_npx") || realPath.includes("/npm/_npx")) {
+      return {
+        packageManager: "npx" /* NPX */,
+        isGlobal: false,
+        updateMessage: "Running via npx, update not applicable."
+      };
+    }
+    if (realPath.includes("/.pnpm/_pnpx")) {
+      return {
+        packageManager: "pnpx" /* PNPX */,
+        isGlobal: false,
+        updateMessage: "Running via pnpx, update not applicable."
+      };
+    }
+    const standaloneInfo = getStandaloneInstallInfo(
+      realPath,
+      isAutoUpdateEnabled
+    );
+    if (standaloneInfo) {
+      return standaloneInfo;
+    }
+    if (process.platform === "darwin") {
+      try {
+        childProcess.execSync('brew list -1 | grep -q "^qwen-code$"', {
+          stdio: "ignore"
+        });
+        return {
+          packageManager: "homebrew" /* HOMEBREW */,
+          isGlobal: true,
+          updateMessage: 'Installed via Homebrew. Please update with "brew upgrade".'
+        };
+      } catch (_error) {
+      }
+    }
+    if (realPath.includes("/.pnpm/global")) {
+      const updateCommand2 = "pnpm add -g @qwen-code/qwen-code@latest";
+      return {
+        packageManager: "pnpm" /* PNPM */,
+        isGlobal: true,
+        updateCommand: updateCommand2,
+        updateMessage: isAutoUpdateEnabled ? "Installed with pnpm. Attempting to automatically update now..." : `Please run ${updateCommand2} to update`
+      };
+    }
+    if (realPath.includes("/.yarn/global")) {
+      const updateCommand2 = "yarn global add @qwen-code/qwen-code@latest";
+      return {
+        packageManager: "yarn" /* YARN */,
+        isGlobal: true,
+        updateCommand: updateCommand2,
+        updateMessage: isAutoUpdateEnabled ? "Installed with yarn. Attempting to automatically update now..." : `Please run ${updateCommand2} to update`
+      };
+    }
+    if (realPath.includes("/.bun/install/cache")) {
+      return {
+        packageManager: "bunx" /* BUNX */,
+        isGlobal: false,
+        updateMessage: "Running via bunx, update not applicable."
+      };
+    }
+    if (realPath.includes("/.bun/bin")) {
+      const updateCommand2 = "bun add -g @qwen-code/qwen-code@latest";
+      return {
+        packageManager: "bun" /* BUN */,
+        isGlobal: true,
+        updateCommand: updateCommand2,
+        updateMessage: isAutoUpdateEnabled ? "Installed with bun. Attempting to automatically update now..." : `Please run ${updateCommand2} to update`
+      };
+    }
+    if (normalizedProjectRoot && isSamePathOrInside(realPath, `${normalizedProjectRoot}/node_modules`)) {
+      let pm = "npm" /* NPM */;
+      if (fs.existsSync(path.join(projectRoot, "yarn.lock"))) {
+        pm = "yarn" /* YARN */;
+      } else if (fs.existsSync(path.join(projectRoot, "pnpm-lock.yaml"))) {
+        pm = "pnpm" /* PNPM */;
+      } else if (fs.existsSync(path.join(projectRoot, "bun.lockb"))) {
+        pm = "bun" /* BUN */;
+      }
+      return {
+        packageManager: pm,
+        isGlobal: false,
+        updateMessage: "Locally installed. Please update via your project's package.json."
+      };
+    }
+    const npmPackageDir = path.dirname(path.dirname(realPath));
+    let npmPrefixWritable = false;
+    try {
+      fs.accessSync(npmPackageDir, fs.constants.W_OK);
+      npmPrefixWritable = true;
+    } catch {
+    }
+    if (!npmPrefixWritable) {
+      return {
+        packageManager: "npm" /* NPM */,
+        isGlobal: true,
+        updateMessage: "Update requires sudo. Please run: sudo npm install -g @qwen-code/qwen-code@latest"
+      };
+    }
+    const updateCommand = "npm install -g @qwen-code/qwen-code@latest";
+    return {
+      packageManager: "npm" /* NPM */,
+      isGlobal: true,
+      updateCommand,
+      updateMessage: isAutoUpdateEnabled ? "Installed with npm. Attempting to automatically update now..." : `Please run ${updateCommand} to update`
+    };
+  } catch (error) {
+    debugLogger.error("Failed to detect installation info:", error);
+    return { packageManager: "unknown" /* UNKNOWN */, isGlobal: false };
+  }
+}
+__name(getInstallationInfo, "getInstallationInfo");
+function stripTrailingSlashes(value) {
+  return value.replace(/\/+$/, "") || "/";
+}
+__name(stripTrailingSlashes, "stripTrailingSlashes");
+function isSamePathOrInside(candidate, parent) {
+  const normalizedCandidate = stripTrailingSlashes(candidate);
+  const normalizedParent = stripTrailingSlashes(parent);
+  if (normalizedParent === "/") {
+    return normalizedCandidate === "/" || normalizedCandidate.startsWith("/");
+  }
+  return normalizedCandidate === normalizedParent || normalizedCandidate.startsWith(`${normalizedParent}/`);
+}
+__name(isSamePathOrInside, "isSamePathOrInside");
+function getStandaloneInstallInfo(realPath, isAutoUpdateEnabled) {
+  const installDir = standaloneInstallDirForCliPath(realPath);
+  if (!installDir || !isStandaloneInstallDir(installDir)) {
+    return null;
+  }
+  const installerUrl = getStandaloneInstallerUrl();
+  const updateCommand = process.platform === "win32" ? `powershell -ExecutionPolicy Bypass -c "irm ${installerUrl} | iex"` : `curl -fsSL ${installerUrl} | bash`;
+  return {
+    packageManager: "standalone" /* STANDALONE */,
+    isGlobal: true,
+    isStandalone: true,
+    standaloneDir: installDir,
+    updateMessage: isAutoUpdateEnabled ? "Standalone install detected. Attempting to automatically update now..." : `Standalone install detected. Please rerun the standalone installer to update: ${updateCommand}`
+  };
+}
+__name(getStandaloneInstallInfo, "getStandaloneInstallInfo");
+function standaloneInstallDirForCliPath(realPath) {
+  const normalized = realPath.replace(/\\/g, "/");
+  const suffix = "/lib/cli.js";
+  if (!normalized.endsWith(suffix)) {
+    return null;
+  }
+  return realPath.slice(0, -suffix.length);
+}
+__name(standaloneInstallDirForCliPath, "standaloneInstallDirForCliPath");
+function isStandaloneInstallDir(installDir) {
+  try {
+    const manifestPath = path.join(installDir, "manifest.json");
+    if (!fs.existsSync(manifestPath)) {
+      return false;
+    }
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+    if (manifest.name !== "@qwen-code/qwen-code" || typeof manifest.target !== "string" || !isStandaloneTargetForCurrentPlatform(manifest.target)) {
+      return false;
+    }
+    const qwenBin = process.platform === "win32" ? path.join(installDir, "bin", "qwen.cmd") : path.join(installDir, "bin", "qwen");
+    const nodeBin = process.platform === "win32" ? path.join(installDir, "node", "node.exe") : path.join(installDir, "node", "bin", "node");
+    return fs.existsSync(qwenBin) && fs.existsSync(nodeBin) && isStandaloneRuntimeFile(qwenBin) && isStandaloneRuntimeFile(nodeBin);
+  } catch (err) {
+    debugLogger.error("Standalone detection failed:", installDir, err);
+    return false;
+  }
+}
+__name(isStandaloneInstallDir, "isStandaloneInstallDir");
+function isStandaloneTargetForCurrentPlatform(target) {
+  switch (process.platform) {
+    case "darwin":
+      return /^darwin-(arm64|x64)$/.test(target);
+    case "linux":
+      return /^linux-(arm64|x64)$/.test(target);
+    case "win32":
+      return /^win-(arm64|x64)$/.test(target);
+    default:
+      return false;
+  }
+}
+__name(isStandaloneTargetForCurrentPlatform, "isStandaloneTargetForCurrentPlatform");
+function isStandaloneRuntimeFile(filePath) {
+  const stats = fs.lstatSync(filePath);
+  if (!stats.isFile() || stats.isSymbolicLink()) {
+    return false;
+  }
+  return process.platform === "win32" || (stats.mode & 73) !== 0;
+}
+__name(isStandaloneRuntimeFile, "isStandaloneRuntimeFile");
+
+export {
+  PackageManager,
+  resolveUpdateCommand,
+  formatUpdateInstructions,
+  getInstallationInfo
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-JD33UY7E.js → chunk-TZRVTPJ6.js}

@@ -6,20 +6,23 @@ import {
   parseAcpBaseModelId,
   resolveCliGenerationConfig,
   sanitizeProviderBaseUrl
-} from "./chunk-4ZJIPVPB.js";
+} from "./chunk-4XK7TNBP.js";
 import {
-  loadSettings
-} from "./chunk-STAZRKOT.js";
+  snapshotProcessEnv
+} from "./chunk-PCWSPWXZ.js";
 import {
   STATUS_SCHEMA_VERSION
-} from "./chunk-JF7DFPQ5.js";
+} from "./chunk-I3MBKL6Z.js";
+import {
+  loadSettings
+} from "./chunk-I34IHZFJ.js";
 import {
   ModelsConfig,
   resolveProviderProtocol
-} from "./chunk-YEGT55NW.js";
+} from "./chunk-ZDAZSR2O.js";
 import {
   APPROVAL_MODES
-} from "./chunk-VEB3NYSO.js";
+} from "./chunk-ZJQBTFJ6.js";
 import {
   tokenLimit
 } from "./chunk-HW4N45EE.js";
@@ -42,10 +45,13 @@ function createWorkspaceProvidersStatusProvider(options = {}) {
 __name(createWorkspaceProvidersStatusProvider, "createWorkspaceProvidersStatusProvider");
 function buildWorkspaceProvidersStatus(workspaceCwd, acpChannelLive, options) {
   try {
-    const loaded = loadSettings(workspaceCwd);
+    const loaded = loadSettings(
+      workspaceCwd,
+      options.env ? { skipLoadEnvironment: true } : true
+    );
     const settings = loaded.merged;
-    const env = options.env ?? process.env;
-    const selectedAuthType = settings.security?.auth?.selectedType ?? getAuthTypeFromEnv();
+    const env = options.env ?? snapshotProcessEnv();
+    const selectedAuthType = settings.security?.auth?.selectedType ?? getAuthTypeFromEnv(env);
     const argv = {
       model: options.argv?.model,
       openaiApiKey: options.argv?.openaiApiKey,

package/chunks/{chunk-65CFHNSE.js → chunk-UAFB2DNB.js}

@@ -4,11 +4,11 @@ import {
   disableMouseEvents,
   enableMouseEvents,
   useKeypressContext
-} from "./chunk-B4U2M63D.js";
+} from "./chunk-LRY7HD3Q.js";
 import {
   use_stdin_default,
   use_stdout_default
-} from "./chunk-DGHJTO2K.js";
+} from "./chunk-2AF26HVM.js";
 import {
   require_react
 } from "./chunk-KYMBIKIW.js";
@@ -62,6 +62,62 @@ function useTerminalSize() {
 }
 __name(useTerminalSize, "useTerminalSize");
 
+// packages/cli/src/ui/colors.ts
+init_esbuild_shims();
+var Colors = {
+  get type() {
+    return themeManager.getActiveTheme().colors.type;
+  },
+  get Foreground() {
+    return themeManager.getActiveTheme().colors.Foreground;
+  },
+  get Background() {
+    return themeManager.getActiveTheme().colors.Background;
+  },
+  get LightBlue() {
+    return themeManager.getActiveTheme().colors.LightBlue;
+  },
+  get AccentBlue() {
+    return themeManager.getActiveTheme().colors.AccentBlue;
+  },
+  get AccentPurple() {
+    return themeManager.getActiveTheme().colors.AccentPurple;
+  },
+  get AccentCyan() {
+    return themeManager.getActiveTheme().colors.AccentCyan;
+  },
+  get AccentGreen() {
+    return themeManager.getActiveTheme().colors.AccentGreen;
+  },
+  get AccentYellow() {
+    return themeManager.getActiveTheme().colors.AccentYellow;
+  },
+  get AccentRed() {
+    return themeManager.getActiveTheme().colors.AccentRed;
+  },
+  get AccentYellowDim() {
+    return themeManager.getActiveTheme().colors.AccentYellowDim;
+  },
+  get AccentRedDim() {
+    return themeManager.getActiveTheme().colors.AccentRedDim;
+  },
+  get DiffAdded() {
+    return themeManager.getActiveTheme().colors.DiffAdded;
+  },
+  get DiffRemoved() {
+    return themeManager.getActiveTheme().colors.DiffRemoved;
+  },
+  get Comment() {
+    return themeManager.getActiveTheme().colors.Comment;
+  },
+  get Gray() {
+    return themeManager.getActiveTheme().colors.Gray;
+  },
+  get GradientColors() {
+    return themeManager.getActiveTheme().colors.GradientColors;
+  }
+};
+
 // packages/cli/src/ui/hooks/useMouseEvents.ts
 init_esbuild_shims();
 var import_react3 = __toESM(require_react(), 1);
@@ -121,7 +177,7 @@ function useMouseEvents(handler, { isActive, tracking = "button", bypassVpGate =
   const vpGateOpen = isVpMode || bypassVpGate;
   const handlerRef = (0, import_react3.useRef)(handler);
   handlerRef.current = handler;
-  const enabled = isActive && isRawModeSupported && vpGateOpen;
+  const enabled = isActive && isRawModeSupported && vpGateOpen && Boolean(stdout.isTTY);
   (0, import_react3.useEffect)(() => {
     if (!enabled) return;
     acquireMouseMode(stdout, tracking);
@@ -140,62 +196,6 @@ function useMouseEvents(handler, { isActive, tracking = "button", bypassVpGate =
 }
 __name(useMouseEvents, "useMouseEvents");
 
-// packages/cli/src/ui/colors.ts
-init_esbuild_shims();
-var Colors = {
-  get type() {
-    return themeManager.getActiveTheme().colors.type;
-  },
-  get Foreground() {
-    return themeManager.getActiveTheme().colors.Foreground;
-  },
-  get Background() {
-    return themeManager.getActiveTheme().colors.Background;
-  },
-  get LightBlue() {
-    return themeManager.getActiveTheme().colors.LightBlue;
-  },
-  get AccentBlue() {
-    return themeManager.getActiveTheme().colors.AccentBlue;
-  },
-  get AccentPurple() {
-    return themeManager.getActiveTheme().colors.AccentPurple;
-  },
-  get AccentCyan() {
-    return themeManager.getActiveTheme().colors.AccentCyan;
-  },
-  get AccentGreen() {
-    return themeManager.getActiveTheme().colors.AccentGreen;
-  },
-  get AccentYellow() {
-    return themeManager.getActiveTheme().colors.AccentYellow;
-  },
-  get AccentRed() {
-    return themeManager.getActiveTheme().colors.AccentRed;
-  },
-  get AccentYellowDim() {
-    return themeManager.getActiveTheme().colors.AccentYellowDim;
-  },
-  get AccentRedDim() {
-    return themeManager.getActiveTheme().colors.AccentRedDim;
-  },
-  get DiffAdded() {
-    return themeManager.getActiveTheme().colors.DiffAdded;
-  },
-  get DiffRemoved() {
-    return themeManager.getActiveTheme().colors.DiffRemoved;
-  },
-  get Comment() {
-    return themeManager.getActiveTheme().colors.Comment;
-  },
-  get Gray() {
-    return themeManager.getActiveTheme().colors.Gray;
-  },
-  get GradientColors() {
-    return themeManager.getActiveTheme().colors.GradientColors;
-  }
-};
-
 // packages/cli/src/ui/utils/measure-element-position.ts
 init_esbuild_shims();