@qwen-code/qwen-code 0.19.7 → 0.19.8-nightly.20260711.0ef3a76bd

package/chunks/chunk-2UU6DW5P.js

@@ -0,0 +1,296 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  isGitRepository
+} from "./chunk-UUVCHN62.js";
+import {
+  createDebugLogger
+} from "./chunk-J4TSQ5EQ.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.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-2PSWA5ID.js → chunk-2X56YUSZ.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __commonJS,
   __require

package/chunks/chunk-2ZQOQZIS.js

@@ -0,0 +1,71 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getErrorMessage
+} from "./chunk-65F3I3PM.js";
+import {
+  extensionToOutputString,
+  getExtensionManager
+} from "./chunk-WPHYXKFL.js";
+import {
+  loadSettings
+} from "./chunk-L6GPKRH7.js";
+import {
+  initializeI18n,
+  resolveLanguageSetting,
+  t
+} from "./chunk-LD5OWZ5E.js";
+import {
+  writeStderrLine,
+  writeStdoutLine
+} from "./chunk-YUZI3WAC.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/commands/extensions/list.ts
+init_esbuild_shims();
+async function handleList() {
+  try {
+    const settings = loadSettings();
+    await initializeI18n(
+      resolveLanguageSetting(settings.merged.general?.language)
+    );
+    const extensionManager = await getExtensionManager();
+    const extensions = extensionManager.getLoadedExtensions();
+    if (!extensions || extensions.length === 0) {
+      writeStdoutLine(t("No extensions installed."));
+      return;
+    }
+    writeStdoutLine(
+      extensions.map(
+        (extension, _) => extensionToOutputString(extension, extensionManager, process.cwd())
+      ).join("\n\n")
+    );
+  } catch (error) {
+    writeStderrLine(getErrorMessage(error));
+    process.exit(1);
+  }
+}
+__name(handleList, "handleList");
+var listCommand = {
+  command: "list",
+  describe: t("Lists installed extensions."),
+  builder: /* @__PURE__ */ __name((yargs) => yargs, "builder"),
+  handler: /* @__PURE__ */ __name(async () => {
+    await handleList();
+  }, "handler")
+};
+
+export {
+  handleList,
+  listCommand
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-Q6OEPOOC.js → chunk-3AMVHPEQ.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   BaseJsonOutputAdapter
-} from "./chunk-YDSYD7UI.js";
+} from "./chunk-FD3DA3B4.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";

package/chunks/{chunk-4RQIB5UZ.js → chunk-3BTRNWWD.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name
 } from "./chunk-J2S4EL5Y.js";
@@ -221,35 +221,6 @@ var V1_INDICATOR_KEYS = [
   "disableCacheControl"
 ];
 
-// packages/cli/src/config/shared-env-keys.ts
-init_esbuild_shims();
-var DEFAULT_EXCLUDED_ENV_VARS = ["DEBUG", "DEBUG_MODE"];
-var ENV_CORRUPTED_PATH = "QWEN_CODE_SETTINGS_CORRUPTED_PATH";
-var ENV_WAS_RECOVERED = "QWEN_CODE_SETTINGS_WAS_RECOVERED";
-var PROJECT_ENV_HARDCODED_EXCLUSIONS = [
-  "QWEN_HOME",
-  "QWEN_RUNTIME_DIR",
-  "QWEN_CODE_MCP_APPROVALS_PATH",
-  "QWEN_CODE_TRUSTED_FOLDERS_PATH",
-  ENV_CORRUPTED_PATH,
-  ENV_WAS_RECOVERED,
-  // QWEN_TLS_INSECURE (and NODE_TLS_REJECT_UNAUTHORIZED, which it mirrors)
-  // disable TLS certificate verification for all outbound API connections. A
-  // project `.env` must never enable either — that would let an untrusted repo
-  // silently turn off MITM protection. Opt-in stays with the user via the
-  // `--insecure` flag, the shell environment, or a home `.env`. The initial
-  // `.env` load only consults this list, so both keys must be here (not just
-  // RELOAD_EXCLUDED_KEYS, which only applies on reload).
-  "QWEN_TLS_INSECURE",
-  "NODE_TLS_REJECT_UNAUTHORIZED"
-];
-var HOME_ENV_BOOTSTRAP_KEYS = [
-  "QWEN_HOME",
-  "QWEN_RUNTIME_DIR",
-  "QWEN_CODE_MCP_APPROVALS_PATH",
-  "QWEN_CODE_TRUSTED_FOLDERS_PATH"
-];
-
 // packages/cli/src/config/storage-paths-lite.ts
 init_esbuild_shims();
 import * as os from "node:os";
@@ -310,11 +281,6 @@ export {
   V1_TO_V2_PRESERVE_DISABLE_MAP,
   CONSOLIDATED_DISABLE_KEYS,
   V1_INDICATOR_KEYS,
-  DEFAULT_EXCLUDED_ENV_VARS,
-  ENV_CORRUPTED_PATH,
-  ENV_WAS_RECOVERED,
-  PROJECT_ENV_HARDCODED_EXCLUSIONS,
-  HOME_ENV_BOOTSTRAP_KEYS,
   SETTINGS_DIRECTORY_NAME,
   resolveConfigPathLite,
   getGlobalQwenDirLite,

package/chunks/{chunk-SD4N3QJ2.js → chunk-3QZ6GY6A.js}

@@ -2,30 +2,31 @@
 "use strict";
 import {
   appEvents
-} from "./chunk-I4A4K72C.js";
+} from "./chunk-VL7GBUQA.js";
 import {
   require_undici
-} from "./chunk-54YZOP7P.js";
+} from "./chunk-L573Z2QZ.js";
 import {
+  IdeClient,
   getAllProviderBaseUrls
-} from "./chunk-YEGT55NW.js";
+} from "./chunk-UUVCHN62.js";
 import {
   initializeTelemetry
-} from "./chunk-GMOWQOQQ.js";
+} from "./chunk-MUCWGT7O.js";
 import {
   detectRuntime,
   getOrCreateSharedDispatcher,
   redactProxyCredentials
-} from "./chunk-H6EMK6QK.js";
+} from "./chunk-4ZVWQHEQ.js";
 import {
   createDebugLogger
-} from "./chunk-22MNNNXE.js";
+} from "./chunk-J4TSQ5EQ.js";
 import {
   recordStartupEvent
-} from "./chunk-ITOGNELQ.js";
+} from "./chunk-QSWDGAIC.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name,
   __toESM
@@ -144,24 +145,38 @@ __name(preconnectApi, "preconnectApi");
 
 // packages/cli/src/startup/startup-prefetch.ts
 var debugLogger2 = createDebugLogger("STARTUP_PREFETCH");
-var DEFERRED_IDE_CONNECT_TIMEOUT_MS = 1e4;
+var DEFERRED_IDE_CONNECT_TIMEOUT_MS = 15e3;
 var earlyStarted = /* @__PURE__ */ new WeakSet();
 var postRenderStarted = /* @__PURE__ */ new WeakSet();
-function withTimeout(promise, name, timeoutMs) {
+function withTimeout(promise, name, timeoutMs, onTimeout = () => {
+}) {
   let timeoutId;
   let timedOut = false;
+  const runTimeoutCleanup = /* @__PURE__ */ __name(() => {
+    void Promise.resolve().then(onTimeout).catch((err) => {
+      debugLogger2.debug(`${name} timeout cleanup failed:`, err);
+    });
+  }, "runTimeoutCleanup");
   const timeout = new Promise((_, reject) => {
     timeoutId = setTimeout(() => {
       timedOut = true;
+      runTimeoutCleanup();
       reject(new Error(`${name} timed out after ${timeoutMs}ms`));
     }, timeoutMs);
     timeoutId.unref?.();
   });
-  promise.catch((err) => {
-    if (timedOut) {
-      debugLogger2.debug(`${name} underlying error after timeout:`, err);
+  void promise.then(
+    () => {
+      if (timedOut) {
+        runTimeoutCleanup();
+      }
+    },
+    (err) => {
+      if (timedOut) {
+        debugLogger2.debug(`${name} underlying error after timeout:`, err);
+      }
     }
-  });
+  );
   return Promise.race([promise, timeout]).finally(() => {
     if (timeoutId) {
       clearTimeout(timeoutId);
@@ -179,6 +194,11 @@ function runDeferredTask(name, task) {
   });
 }
 __name(runDeferredTask, "runDeferredTask");
+async function disconnectIdeAfterDeferredTimeout() {
+  const ideClient = await IdeClient.getInstance();
+  await ideClient.disconnect();
+}
+__name(disconnectIdeAfterDeferredTimeout, "disconnectIdeAfterDeferredTimeout");
 function startEarlyStartupPrefetches(config) {
   if (earlyStarted.has(config)) return;
   earlyStarted.add(config);
@@ -200,12 +220,35 @@ function startPostRenderPrefetches(config, settings, options = {}) {
   postRenderStarted.add(config);
   if (settings.merged.general?.enableAutoUpdate !== false) {
     runDeferredTask("update_check", async () => {
-      const [{ checkForUpdates }, { handleAutoUpdate }] = await Promise.all([
-        import("./updateCheck-E2ZX7RL7.js"),
-        import("./handleAutoUpdate-HN7ZOSXY.js")
+      const [
+        { checkForUpdatesDetailed },
+        { handleAutoUpdate },
+        { updateEventEmitter },
+        { t }
+      ] = await Promise.all([
+        import("./updateCheck-NKPJGJCR.js"),
+        import("./handleAutoUpdate-FFF3CZGP.js"),
+        import("./updateEventEmitter-5MKC7BLQ.js"),
+        import("./i18n-QQAJT7A2.js")
       ]);
-      const info = await checkForUpdates();
-      handleAutoUpdate(info, settings, config.getProjectRoot());
+      const updateFailedMessage = t(
+        "Failed to check for updates. Please check your network or registry configuration."
+      );
+      try {
+        const result = await checkForUpdatesDetailed();
+        if (result.status === "update") {
+          handleAutoUpdate(result.info, settings, config.getProjectRoot());
+        } else if (result.status === "error") {
+          updateEventEmitter.emit("update-failed", {
+            message: updateFailedMessage
+          });
+        }
+      } catch (error) {
+        updateEventEmitter.emit("update-failed", {
+          message: updateFailedMessage
+        });
+        throw error;
+      }
     });
   }
   if (options.connectIde && config.getIdeMode()) {
@@ -214,11 +257,12 @@ function startPostRenderPrefetches(config, settings, options = {}) {
         state: "connecting"
       });
       try {
-        const { connectIdeForStartup } = await import("./initializer-SRN3IM42.js");
+        const { connectIdeForStartup } = await import("./initializer-LGQGC7ZT.js");
         await withTimeout(
           connectIdeForStartup(config),
           "ide_connect",
-          DEFERRED_IDE_CONNECT_TIMEOUT_MS
+          DEFERRED_IDE_CONNECT_TIMEOUT_MS,
+          disconnectIdeAfterDeferredTimeout
         );
         appEvents.emit("startup-ide-connection-status-changed" /* StartupIdeConnectionStatusChanged */, {
           state: "connected"
@@ -239,7 +283,7 @@ function startPostRenderPrefetches(config, settings, options = {}) {
   }
   if (config.isInteractive()) {
     runDeferredTask("background_housekeeping", async () => {
-      const { startBackgroundHousekeeping } = await import("./scheduler-ZRW3AIDU.js");
+      const { startBackgroundHousekeeping } = await import("./scheduler-XXEA6EFC.js");
       startBackgroundHousekeeping(config, settings);
     });
   }

package/chunks/{chunk-DNV4FSN5.js → chunk-3SJSQXNS.js}

@@ -1,27 +1,29 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  DEFAULT_EXCLUDED_ENV_VARS,
-  HOME_ENV_BOOTSTRAP_KEYS,
-  PROJECT_ENV_HARDCODED_EXCLUSIONS,
   SETTINGS_DIRECTORY_NAME,
   V1_INDICATOR_KEYS,
   getGlobalQwenDirLite,
   getSystemDefaultsPath,
   getSystemSettingsPath,
   resolveEnvVarsInObject
-} from "./chunk-4RQIB5UZ.js";
+} from "./chunk-3BTRNWWD.js";
+import {
+  DEFAULT_EXCLUDED_ENV_VARS,
+  HOME_ENV_BOOTSTRAP_KEYS,
+  PROJECT_ENV_HARDCODED_EXCLUSIONS
+} from "./chunk-QRUIS3DN.js";
 import {
   getPathComparisonVariants,
   isWithinRoot,
   require_strip_json_comments
-} from "./chunk-QYUE6W3T.js";
+} from "./chunk-RDJSGHZE.js";
 import {
   require_main
-} from "./chunk-SKAZWEV5.js";
+} from "./chunk-ZJE7NSL3.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name,
   __toESM
@@ -365,6 +367,18 @@ function pickFastPathSettings(value) {
   if (isPlainObject(env)) {
     out.env = pickStringRecord(env);
   }
+  const general = value["general"];
+  if (isPlainObject(general)) {
+    const chatRecording = general["chatRecording"];
+    if (chatRecording !== void 0 && typeof chatRecording !== "boolean") {
+      throw new Error(
+        "Serve fast path settings general.chatRecording must be a boolean."
+      );
+    }
+    if (chatRecording !== void 0) {
+      out.general = { chatRecording };
+    }
+  }
   const advanced = value["advanced"];
   if (isPlainObject(advanced)) {
     const pickedAdvanced = {};
@@ -509,6 +523,9 @@ function mergeFastPathSettings(...sources) {
     if (source.env) {
       merged.env = { ...merged.env ?? {}, ...source.env };
     }
+    if (source.general) {
+      merged.general = { ...merged.general ?? {}, ...source.general };
+    }
     if (source.advanced?.excludedEnvVars) {
       merged.advanced = {
         ...merged.advanced ?? {},