@qwen-code/qwen-code 0.19.7 → 0.19.8

package/chunks/{chunk-STAZRKOT.js → chunk-M7S4GK5Z.js}

@@ -6,18 +6,18 @@ import {
   getLanguageNameFromLocale,
   getLanguageSettingsOptions,
   t
-} from "./chunk-QAKFYMJI.js";
+} from "./chunk-O33TBKDC.js";
 import {
   DEFAULT_DARK_THEME_NAME,
   DEFAULT_LIGHT_THEME_NAME
 } from "./chunk-TLRYABYP.js";
+import {
+  getHomeEnvFallbackVars,
+  loadEnvironment,
+  preResolveHomeEnvOverrides
+} from "./chunk-BOBRZZKD.js";
 import {
   CONSOLIDATED_DISABLE_KEYS,
-  DEFAULT_EXCLUDED_ENV_VARS,
-  ENV_CORRUPTED_PATH,
-  ENV_WAS_RECOVERED,
-  HOME_ENV_BOOTSTRAP_KEYS,
-  PROJECT_ENV_HARDCODED_EXCLUSIONS,
   V1_INDICATOR_KEYS,
   V1_TO_V2_MIGRATION_MAP,
   V1_TO_V2_PRESERVE_DISABLE_MAP,
@@ -25,11 +25,15 @@ import {
   getSystemDefaultsPath,
   getSystemSettingsPath,
   resolveEnvVarsInObject
-} from "./chunk-4RQIB5UZ.js";
+} from "./chunk-O2YT7VB4.js";
+import {
+  ENV_CORRUPTED_PATH,
+  ENV_WAS_RECOVERED
+} from "./chunk-Z3I3QJK3.js";
 import {
   isWorkspaceTrusted,
   updateSettingsFilePreservingFormat
-} from "./chunk-MIG5SQNL.js";
+} from "./chunk-DICGXFAI.js";
 import {
   require_strip_json_comments
 } from "./chunk-QYUE6W3T.js";
@@ -42,20 +46,16 @@ import {
   DEFAULT_TRUNCATE_TOOL_OUTPUT_LINES,
   DEFAULT_TRUNCATE_TOOL_OUTPUT_THRESHOLD,
   stripRuntimeSnapshotPrefix
-} from "./chunk-YEGT55NW.js";
-import {
-  require_main
-} from "./chunk-SKAZWEV5.js";
+} from "./chunk-3GNOQZDC.js";
 import {
   DEFAULT_QWEN_CUSTOM_IGNORE_FILE_NAMES
 } from "./chunk-TLWA7TPR.js";
 import {
   DEFAULT_SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH,
   SENSITIVE_SPAN_ATTRIBUTE_MAX_LENGTH_LIMIT
-} from "./chunk-GMOWQOQQ.js";
+} from "./chunk-BUZ6HGL4.js";
 import {
   FatalConfigError,
-  QWEN_DIR,
   Storage,
   createDebugLogger,
   getErrorMessage
@@ -70,10 +70,10 @@ import {
 
 // packages/cli/src/config/settings.ts
 init_esbuild_shims();
-import * as fs4 from "node:fs";
-import * as path3 from "node:path";
-import { homedir as homedir2 } from "node:os";
-import process2 from "node:process";
+import * as fs3 from "node:fs";
+import * as path2 from "node:path";
+import { homedir } from "node:os";
+import process from "node:process";
 var import_strip_json_comments = __toESM(require_strip_json_comments(), 1);
 
 // packages/cli/src/config/modelProvidersScope.ts
@@ -3047,8 +3047,8 @@ function getDefaultValue(key) {
   return getFlattenedSchema()[key]?.default;
 }
 __name(getDefaultValue, "getDefaultValue");
-function getNestedValue(obj, path4) {
-  const [first, ...rest] = path4;
+function getNestedValue(obj, path3) {
+  const [first, ...rest] = path3;
   if (!first || !(first in obj)) {
     return void 0;
   }
@@ -3062,8 +3062,8 @@ function getNestedValue(obj, path4) {
   return void 0;
 }
 __name(getNestedValue, "getNestedValue");
-function getNestedProperty(obj, path4) {
-  return getNestedValue(obj, path4.split("."));
+function getNestedProperty(obj, path3) {
+  return getNestedValue(obj, path3.split("."));
 }
 __name(getNestedProperty, "getNestedProperty");
 function getEffectiveValue(key, settings, mergedSettings) {
@@ -3071,12 +3071,12 @@ function getEffectiveValue(key, settings, mergedSettings) {
   if (!definition) {
     return void 0;
   }
-  const path4 = key.split(".");
-  let value = getNestedValue(settings, path4);
+  const path3 = key.split(".");
+  let value = getNestedValue(settings, path3);
   if (value !== void 0) {
     return value;
   }
-  value = getNestedValue(mergedSettings, path4);
+  value = getNestedValue(mergedSettings, path3);
   if (value !== void 0) {
     return value;
   }
@@ -3162,8 +3162,8 @@ function getDialogSettingKeys() {
 }
 __name(getDialogSettingKeys, "getDialogSettingKeys");
 function settingExistsInScope(key, scopeSettings) {
-  const path4 = key.split(".");
-  const value = getNestedValue(scopeSettings, path4);
+  const path3 = key.split(".");
+  const value = getNestedValue(scopeSettings, path3);
   return value !== void 0;
 }
 __name(settingExistsInScope, "settingExistsInScope");
@@ -3176,8 +3176,8 @@ function pathHasUnsafeSegment(keys) {
   return false;
 }
 __name(pathHasUnsafeSegment, "pathHasUnsafeSegment");
-function setNestedPropertyForce(obj, path4, value) {
-  const keys = path4.split(".");
+function setNestedPropertyForce(obj, path3, value) {
+  const keys = path3.split(".");
   if (pathHasUnsafeSegment(keys)) return;
   const lastKey = keys.pop();
   if (!lastKey) return;
@@ -3191,8 +3191,8 @@ function setNestedPropertyForce(obj, path4, value) {
   current[lastKey] = value;
 }
 __name(setNestedPropertyForce, "setNestedPropertyForce");
-function setNestedPropertySafe(obj, path4, value) {
-  const keys = path4.split(".");
+function setNestedPropertySafe(obj, path3, value) {
+  const keys = path3.split(".");
   if (pathHasUnsafeSegment(keys)) return;
   const lastKey = keys.pop();
   if (!lastKey) return;
@@ -3211,8 +3211,8 @@ function setNestedPropertySafe(obj, path4, value) {
   current[lastKey] = value;
 }
 __name(setNestedPropertySafe, "setNestedPropertySafe");
-function deleteNestedPropertySafe(obj, path4) {
-  const keys = path4.split(".");
+function deleteNestedPropertySafe(obj, path3) {
+  const keys = path3.split(".");
   const lastKey = keys.pop();
   if (!lastKey) return;
   let current = obj;
@@ -3244,10 +3244,10 @@ function getRestartRequiredFromModified(modifiedSettings) {
 __name(getRestartRequiredFromModified, "getRestartRequiredFromModified");
 function saveModifiedSettings(modifiedSettings, pendingSettings, loadedSettings, scope) {
   modifiedSettings.forEach((settingKey) => {
-    const path4 = settingKey.split(".");
+    const path3 = settingKey.split(".");
     const value = getNestedValue(
       pendingSettings,
-      path4
+      path3
     );
     const existsInOriginalFile = settingExistsInScope(
       settingKey,
@@ -3349,12 +3349,12 @@ function isPlainObject(item) {
   return !!item && typeof item === "object" && !Array.isArray(item);
 }
 __name(isPlainObject, "isPlainObject");
-function mergeRecursively(target, source, getMergeStrategyForPath2, path4 = []) {
+function mergeRecursively(target, source, getMergeStrategyForPath2, path3 = []) {
   for (const key of Object.keys(source)) {
     if (key === "__proto__" || key === "constructor" || key === "prototype") {
       continue;
     }
-    const newPath = [...path4, key];
+    const newPath = [...path3, key];
     const srcValue = source[key];
     const objValue = target[key];
     const mergeStrategy = getMergeStrategyForPath2(newPath);
@@ -3950,382 +3950,12 @@ function needsMigration(settings) {
 }
 __name(needsMigration, "needsMigration");
 
-// packages/cli/src/config/environment.ts
-init_esbuild_shims();
-var dotenv = __toESM(require_main(), 1);
-import * as fs3 from "node:fs";
-import * as path2 from "node:path";
-import * as os from "node:os";
-var SETTINGS_DIRECTORY_NAME = QWEN_DIR;
-var RELOAD_EXCLUDED_KEYS = /* @__PURE__ */ new Set([
-  ...PROJECT_ENV_HARDCODED_EXCLUSIONS,
-  "QWEN_SERVER_TOKEN",
-  "QWEN_CLI_ENTRY",
-  "NODE_OPTIONS",
-  "NODE_PATH",
-  "NODE_TLS_REJECT_UNAUTHORIZED",
-  "LD_PRELOAD",
-  "LD_AUDIT",
-  "LD_LIBRARY_PATH",
-  "DYLD_INSERT_LIBRARIES",
-  "DYLD_LIBRARY_PATH",
-  "BASH_ENV",
-  "ENV",
-  "PATH",
-  "HOME",
-  "TMPDIR",
-  "TMP",
-  "TEMP"
-]);
-var dotEnvSourcedKeys = /* @__PURE__ */ new Set();
-var settingsEnvSourcedKeys = /* @__PURE__ */ new Set();
-var lastReloadSnapshot = /* @__PURE__ */ new Map();
-var lastReloadSnapshotSeeded = false;
-function getUserLevelEnvPaths() {
-  const homeDir = os.homedir();
-  const globalQwenDir = Storage.getGlobalQwenDir();
-  const paths = /* @__PURE__ */ new Set([
-    path2.normalize(path2.join(homeDir, ".env")),
-    path2.normalize(path2.join(globalQwenDir, ".env"))
-  ]);
-  const legacyQwenEnv = path2.normalize(path2.join(homeDir, QWEN_DIR, ".env"));
-  paths.add(legacyQwenEnv);
-  return paths;
-}
-__name(getUserLevelEnvPaths, "getUserLevelEnvPaths");
-var homeEnvBootstrapped = false;
-function preResolveHomeEnvOverrides() {
-  if (homeEnvBootstrapped) {
-    return;
-  }
-  homeEnvBootstrapped = true;
-  if (HOME_ENV_BOOTSTRAP_KEYS.every((key) => process.env[key])) {
-    return;
-  }
-  const initialQwenHome = process.env["QWEN_HOME"];
-  const initialQwenDir = Storage.getGlobalQwenDir();
-  const candidates = [path2.join(initialQwenDir, ".env")];
-  if (!initialQwenHome) {
-    candidates.push(path2.join(path2.dirname(initialQwenDir), ".env"));
-  }
-  for (const candidate of candidates) {
-    readHomeEnvInto(candidate);
-  }
-  const discoveredQwenHome = process.env["QWEN_HOME"];
-  if (discoveredQwenHome && discoveredQwenHome !== initialQwenHome) {
-    const discoveredDir = Storage.getGlobalQwenDir();
-    if (discoveredDir !== initialQwenDir) {
-      readHomeEnvInto(path2.join(discoveredDir, ".env"));
-    }
-  }
-}
-__name(preResolveHomeEnvOverrides, "preResolveHomeEnvOverrides");
-function readHomeEnvInto(file) {
-  if (!fs3.existsSync(file)) {
-    return;
-  }
-  try {
-    const parsed = dotenv.parse(fs3.readFileSync(file, "utf-8"));
-    for (const key of PROJECT_ENV_HARDCODED_EXCLUSIONS) {
-      if (parsed[key] && !Object.hasOwn(process.env, key)) {
-        process.env[key] = parsed[key];
-      }
-    }
-  } catch (_e) {
-  }
-}
-__name(readHomeEnvInto, "readHomeEnvInto");
-function resetHomeEnvBootstrapForTesting() {
-  homeEnvBootstrapped = false;
-}
-__name(resetHomeEnvBootstrapForTesting, "resetHomeEnvBootstrapForTesting");
-function resetEnvironmentTrackingForTesting() {
-  dotEnvSourcedKeys.clear();
-  settingsEnvSourcedKeys.clear();
-  lastReloadSnapshot.clear();
-  lastReloadSnapshotSeeded = false;
-}
-__name(resetEnvironmentTrackingForTesting, "resetEnvironmentTrackingForTesting");
-function getHomeEnvFallbackVars(onReadError) {
-  const globalQwenDir = Storage.getGlobalQwenDir();
-  const candidates = [path2.join(globalQwenDir, ".env")];
-  if (!process.env["QWEN_HOME"]) {
-    candidates.push(path2.join(path2.dirname(globalQwenDir), ".env"));
-  }
-  const result = {};
-  for (const candidate of candidates) {
-    if (!fs3.existsSync(candidate)) {
-      continue;
-    }
-    try {
-      const parsed = dotenv.parse(fs3.readFileSync(candidate, "utf-8"));
-      for (const key in parsed) {
-        if (Object.hasOwn(parsed, key) && !Object.hasOwn(process.env, key)) {
-          result[key] ??= parsed[key];
-        }
-      }
-    } catch (e) {
-      onReadError?.(
-        `Failed to read home .env candidate ${candidate}: ${getErrorMessage(e)}`
-      );
-    }
-  }
-  return result;
-}
-__name(getHomeEnvFallbackVars, "getHomeEnvFallbackVars");
-function findEnvFiles(settings, startDir, userLevelPaths = getUserLevelEnvPaths()) {
-  const homeDir = os.homedir();
-  let realStartDir = path2.resolve(startDir);
-  try {
-    realStartDir = fs3.realpathSync(realStartDir);
-  } catch {
-  }
-  const isTrusted = isWorkspaceTrusted(
-    settings,
-    void 0,
-    realStartDir
-  ).isTrusted;
-  const globalQwenDir = Storage.getGlobalQwenDir();
-  const legacyQwenDir = path2.normalize(path2.join(homeDir, QWEN_DIR));
-  const hasCustomConfigDir = path2.normalize(globalQwenDir) !== legacyQwenDir;
-  const found = [];
-  const seen = /* @__PURE__ */ new Set();
-  const canUseEnvFile = /* @__PURE__ */ __name((filePath) => isTrusted !== false || userLevelPaths.has(path2.normalize(filePath)), "canUseEnvFile");
-  const pushCandidate = /* @__PURE__ */ __name((filePath) => {
-    const normalized = path2.normalize(filePath);
-    if (!seen.has(normalized) && fs3.existsSync(filePath) && canUseEnvFile(filePath)) {
-      seen.add(normalized);
-      found.push(filePath);
-      return true;
-    }
-    return false;
-  }, "pushCandidate");
-  const pushHomeCandidates = /* @__PURE__ */ __name(() => {
-    const candidates = [path2.join(globalQwenDir, ".env")];
-    if (hasCustomConfigDir) {
-      candidates.push(path2.join(legacyQwenDir, ".env"));
-    }
-    candidates.push(path2.join(homeDir, ".env"));
-    for (const candidate of candidates) {
-      pushCandidate(candidate);
-    }
-  }, "pushHomeCandidates");
-  let currentDir = realStartDir;
-  let visitedHomeDir = false;
-  while (true) {
-    if (currentDir === homeDir) {
-      visitedHomeDir = true;
-      pushHomeCandidates();
-      return found;
-    } else {
-      const geminiEnvPath = path2.join(currentDir, QWEN_DIR, ".env");
-      if (pushCandidate(geminiEnvPath)) {
-        pushHomeCandidates();
-        return found;
-      }
-      const envPath = path2.join(currentDir, ".env");
-      if (pushCandidate(envPath)) {
-        pushHomeCandidates();
-        return found;
-      }
-    }
-    const parentDir = path2.dirname(currentDir);
-    if (parentDir === currentDir || !parentDir) {
-      if (!visitedHomeDir) {
-        pushHomeCandidates();
-      }
-      return found;
-    }
-    currentDir = parentDir;
-  }
-}
-__name(findEnvFiles, "findEnvFiles");
-function setUpCloudShellEnvironment(envFilePath) {
-  if (envFilePath && fs3.existsSync(envFilePath)) {
-    const envFileContent = fs3.readFileSync(envFilePath);
-    const parsedEnv = dotenv.parse(envFileContent);
-    if (parsedEnv["GOOGLE_CLOUD_PROJECT"]) {
-      process.env["GOOGLE_CLOUD_PROJECT"] = parsedEnv["GOOGLE_CLOUD_PROJECT"];
-    } else {
-      process.env["GOOGLE_CLOUD_PROJECT"] = "cloudshell-gca";
-    }
-  } else {
-    process.env["GOOGLE_CLOUD_PROJECT"] = "cloudshell-gca";
-  }
-}
-__name(setUpCloudShellEnvironment, "setUpCloudShellEnvironment");
-function setUpCloudShellEnvironmentFromFiles(envFilePaths) {
-  for (const envFilePath of envFilePaths) {
-    if (!fs3.existsSync(envFilePath)) {
-      continue;
-    }
-    const envFileContent = fs3.readFileSync(envFilePath);
-    const parsedEnv = dotenv.parse(envFileContent);
-    if (parsedEnv["GOOGLE_CLOUD_PROJECT"]) {
-      process.env["GOOGLE_CLOUD_PROJECT"] = parsedEnv["GOOGLE_CLOUD_PROJECT"];
-      return;
-    }
-  }
-  process.env["GOOGLE_CLOUD_PROJECT"] = "cloudshell-gca";
-}
-__name(setUpCloudShellEnvironmentFromFiles, "setUpCloudShellEnvironmentFromFiles");
-function loadEnvironment(settings, startDir = process.cwd()) {
-  const userLevelPaths = getUserLevelEnvPaths();
-  const envFilePaths = findEnvFiles(settings, startDir, userLevelPaths);
-  if (process.env["CLOUD_SHELL"] === "true") {
-    setUpCloudShellEnvironmentFromFiles(envFilePaths);
-  }
-  for (const envFilePath of envFilePaths) {
-    try {
-      const envFileContent = fs3.readFileSync(envFilePath, "utf-8");
-      const parsedEnv = dotenv.parse(envFileContent);
-      const excludedVars = settings?.advanced?.excludedEnvVars || DEFAULT_EXCLUDED_ENV_VARS;
-      const normalizedEnvFilePath = path2.normalize(envFilePath);
-      const isHomeScopedEnvFile = userLevelPaths.has(normalizedEnvFilePath);
-      const isQwenScopedEnvFile = isHomeScopedEnvFile || path2.basename(path2.dirname(normalizedEnvFilePath)) === QWEN_DIR;
-      for (const key in parsedEnv) {
-        if (Object.hasOwn(parsedEnv, key)) {
-          if (!isHomeScopedEnvFile && PROJECT_ENV_HARDCODED_EXCLUSIONS.includes(key)) {
-            continue;
-          }
-          if (!isQwenScopedEnvFile && excludedVars.includes(key)) {
-            continue;
-          }
-          const existingValue = process.env[key];
-          const isEffectivelyUnset = !Object.hasOwn(process.env, key) || existingValue === "";
-          if (isEffectivelyUnset) {
-            process.env[key] = parsedEnv[key];
-            dotEnvSourcedKeys.add(key);
-          }
-          if (!lastReloadSnapshotSeeded && !lastReloadSnapshot.has(key)) {
-            lastReloadSnapshot.set(key, parsedEnv[key]);
-          }
-        }
-      }
-    } catch (_e) {
-    }
-  }
-  if (settings.env) {
-    for (const [key, value] of Object.entries(settings.env)) {
-      if (PROJECT_ENV_HARDCODED_EXCLUSIONS.includes(key)) {
-        continue;
-      }
-      const existingValue = process.env[key];
-      const isEffectivelyUnset = !Object.hasOwn(process.env, key) || existingValue === "";
-      if (isEffectivelyUnset && typeof value === "string") {
-        process.env[key] = value;
-        settingsEnvSourcedKeys.add(key);
-      }
-      if (!lastReloadSnapshotSeeded && typeof value === "string" && !lastReloadSnapshot.has(key)) {
-        lastReloadSnapshot.set(key, value);
-      }
-    }
-  }
-  lastReloadSnapshotSeeded = true;
-}
-__name(loadEnvironment, "loadEnvironment");
-function reloadEnvironment(settings, workspaceCwd) {
-  const userLevelPaths = getUserLevelEnvPaths();
-  const envFilePaths = findEnvFiles(settings, workspaceCwd, userLevelPaths);
-  if (process.env["CLOUD_SHELL"] === "true") {
-    setUpCloudShellEnvironmentFromFiles(envFilePaths);
-  }
-  let dotEnvReadFailed = false;
-  const newDotEnvKeys = /* @__PURE__ */ new Map();
-  const newSettingsEnvKeys = /* @__PURE__ */ new Map();
-  for (const envFilePath of envFilePaths) {
-    try {
-      const envFileContent = fs3.readFileSync(envFilePath, "utf-8");
-      const parsedEnv = dotenv.parse(envFileContent);
-      const excludedVars = settings?.advanced?.excludedEnvVars || DEFAULT_EXCLUDED_ENV_VARS;
-      const normalizedEnvFilePath = path2.normalize(envFilePath);
-      const isHomeScopedEnvFile = userLevelPaths.has(normalizedEnvFilePath);
-      const isQwenScopedEnvFile = isHomeScopedEnvFile || path2.basename(path2.dirname(normalizedEnvFilePath)) === QWEN_DIR;
-      for (const key in parsedEnv) {
-        if (!Object.hasOwn(parsedEnv, key)) continue;
-        if (RELOAD_EXCLUDED_KEYS.has(key)) continue;
-        if (!isHomeScopedEnvFile && PROJECT_ENV_HARDCODED_EXCLUSIONS.includes(key)) {
-          continue;
-        }
-        if (!isQwenScopedEnvFile && excludedVars.includes(key)) continue;
-        if (!newDotEnvKeys.has(key)) {
-          newDotEnvKeys.set(key, parsedEnv[key]);
-        }
-      }
-    } catch {
-      dotEnvReadFailed = true;
-    }
-  }
-  if (settings.env) {
-    for (const [key, value] of Object.entries(settings.env)) {
-      if (RELOAD_EXCLUDED_KEYS.has(key)) continue;
-      if (PROJECT_ENV_HARDCODED_EXCLUSIONS.includes(key)) continue;
-      if (typeof value !== "string") continue;
-      const dotEnvValue = newDotEnvKeys.get(key);
-      if (dotEnvValue !== void 0 && dotEnvValue !== "") continue;
-      if (dotEnvReadFailed && lastReloadSnapshot.has(key)) continue;
-      newSettingsEnvKeys.set(key, value);
-    }
-  }
-  const allNewKeys = /* @__PURE__ */ new Set([
-    ...newDotEnvKeys.keys(),
-    ...newSettingsEnvKeys.keys()
-  ]);
-  const updatedKeys = [];
-  const removedKeys = [];
-  if (!dotEnvReadFailed) {
-    const previouslyKnown = /* @__PURE__ */ new Set([
-      ...lastReloadSnapshot.keys(),
-      ...dotEnvSourcedKeys,
-      ...settingsEnvSourcedKeys
-    ]);
-    for (const key of previouslyKnown) {
-      if (!allNewKeys.has(key) && !RELOAD_EXCLUDED_KEYS.has(key)) {
-        delete process.env[key];
-        removedKeys.push(key);
-      }
-    }
-  }
-  for (const [key, value] of newDotEnvKeys) {
-    if (value === "" && newSettingsEnvKeys.has(key)) continue;
-    if (process.env[key] !== value) {
-      updatedKeys.push(key);
-    }
-    process.env[key] = value;
-  }
-  for (const [key, value] of newSettingsEnvKeys) {
-    if (process.env[key] !== value) {
-      updatedKeys.push(key);
-    }
-    process.env[key] = value;
-  }
-  if (!dotEnvReadFailed) {
-    dotEnvSourcedKeys.clear();
-    for (const key of newDotEnvKeys.keys()) {
-      dotEnvSourcedKeys.add(key);
-    }
-    lastReloadSnapshot.clear();
-    for (const [key, value] of newDotEnvKeys) {
-      lastReloadSnapshot.set(key, value);
-    }
-    for (const [key, value] of newSettingsEnvKeys) {
-      lastReloadSnapshot.set(key, value);
-    }
-  }
-  settingsEnvSourcedKeys.clear();
-  for (const key of newSettingsEnvKeys.keys()) {
-    settingsEnvSourcedKeys.add(key);
-  }
-  return { updatedKeys, removedKeys };
-}
-__name(reloadEnvironment, "reloadEnvironment");
-
 // packages/cli/src/config/settings.ts
 var debugLogger2 = createDebugLogger("SETTINGS");
-function getMergeStrategyForPath(path4) {
+function getMergeStrategyForPath(path3) {
   let current = void 0;
   let currentSchema = getSettingsSchema();
-  for (const key of path4) {
+  for (const key of path3) {
     if (!currentSchema || !currentSchema[key]) {
       return void 0;
     }
@@ -4340,7 +3970,7 @@ function getUserSettingsPath() {
 }
 __name(getUserSettingsPath, "getUserSettingsPath");
 function getUserSettingsDir() {
-  return path3.dirname(getUserSettingsPath());
+  return path2.dirname(getUserSettingsPath());
 }
 __name(getUserSettingsDir, "getUserSettingsDir");
 var SETTINGS_VERSION = 4;
@@ -4602,14 +4232,14 @@ var LoadedSettings = class {
   reloadScopeFromDisk(scope) {
     const file = this.forScope(scope);
     try {
-      if (!fs4.existsSync(file.path)) {
+      if (!fs3.existsSync(file.path)) {
         file.settings = {};
         file.originalSettings = {};
         file.rawJson = void 0;
         this._merged = this.computeMergedSettings();
         return;
       }
-      const content = fs4.readFileSync(file.path, "utf-8");
+      const content = fs3.readFileSync(file.path, "utf-8");
       const parsed = JSON.parse((0, import_strip_json_comments.default)(content));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
         const resolved = resolveEnvVarsInObject(
@@ -4666,33 +4296,33 @@ function createMinimalSettings() {
 }
 __name(createMinimalSettings, "createMinimalSettings");
 function detectQwenHomeRedirectWithoutMigration(activeUserSettingsPath) {
-  if (!process2.env["QWEN_HOME"]) {
+  if (!process.env["QWEN_HOME"]) {
     return null;
   }
   const activeQwenDir = Storage.getGlobalQwenDir();
-  const savedQwenHome = process2.env["QWEN_HOME"];
-  delete process2.env["QWEN_HOME"];
+  const savedQwenHome = process.env["QWEN_HOME"];
+  delete process.env["QWEN_HOME"];
   let legacyQwenDir;
   try {
     legacyQwenDir = Storage.getGlobalQwenDir();
   } finally {
-    process2.env["QWEN_HOME"] = savedQwenHome;
+    process.env["QWEN_HOME"] = savedQwenHome;
   }
-  if (path3.resolve(activeQwenDir) === path3.resolve(legacyQwenDir)) {
+  if (path2.resolve(activeQwenDir) === path2.resolve(legacyQwenDir)) {
     return null;
   }
-  if (fs4.existsSync(activeUserSettingsPath)) {
+  if (fs3.existsSync(activeUserSettingsPath)) {
     return null;
   }
-  const legacyUserSettings = path3.join(legacyQwenDir, "settings.json");
-  if (!fs4.existsSync(legacyUserSettings)) {
+  const legacyUserSettings = path2.join(legacyQwenDir, "settings.json");
+  if (!fs3.existsSync(legacyUserSettings)) {
     return null;
   }
   return `QWEN_HOME points to "${activeQwenDir}" but no settings.json was found there. Existing config remains at "${legacyQwenDir}" \u2014 OAuth tokens, settings, memory, extensions, and skills are not auto-migrated. Copy them manually if you want them to apply at the new location.`;
 }
 __name(detectQwenHomeRedirectWithoutMigration, "detectQwenHomeRedirectWithoutMigration");
 var CORRUPTED_SUFFIX = ".corrupted";
-function loadSettings(workspaceDir = process2.cwd(), consumeCorruptionEnvVars = true) {
+function loadSettings(workspaceDir = process.cwd(), consumeCorruptionEnvVars = true) {
   const opts = typeof consumeCorruptionEnvVars === "object" ? consumeCorruptionEnvVars : { consumeCorruptionEnvVars };
   preResolveHomeEnvOverrides();
   const userSettingsPath = getUserSettingsPath();
@@ -4705,21 +4335,21 @@ function loadSettings(workspaceDir = process2.cwd(), consumeCorruptionEnvVars =
   const systemSettingsPath = getSystemSettingsPath();
   const systemDefaultsPath = getSystemDefaultsPath();
   const migratedInMemorScopes = /* @__PURE__ */ new Set();
-  const resolvedWorkspaceDir = path3.resolve(workspaceDir);
-  const resolvedHomeDir = path3.resolve(homedir2());
+  const resolvedWorkspaceDir = path2.resolve(workspaceDir);
+  const resolvedHomeDir = path2.resolve(homedir());
   let realWorkspaceDir = resolvedWorkspaceDir;
   try {
-    realWorkspaceDir = fs4.realpathSync(resolvedWorkspaceDir);
+    realWorkspaceDir = fs3.realpathSync(resolvedWorkspaceDir);
   } catch (_e) {
   }
-  const realHomeDir = fs4.realpathSync(resolvedHomeDir);
+  const realHomeDir = fs3.realpathSync(resolvedHomeDir);
   const workspaceSettingsPath = new Storage(
     workspaceDir
   ).getWorkspaceSettingsPath();
   const loadAndMigrate = /* @__PURE__ */ __name((filePath, scope) => {
     try {
-      if (fs4.existsSync(filePath)) {
-        const content = fs4.readFileSync(filePath, "utf-8");
+      if (fs3.existsSync(filePath)) {
+        const content = fs3.readFileSync(filePath, "utf-8");
         let rawSettings;
         const corruptedPath = `${filePath}${CORRUPTED_SUFFIX}`;
         let corruptedSaved = false;
@@ -4731,7 +4361,7 @@ function loadSettings(workspaceDir = process2.cwd(), consumeCorruptionEnvVars =
             `Settings file ${filePath} has invalid JSON (${getErrorMessage(parseError)}). Resetting to empty settings.`
           );
           try {
-            fs4.copyFileSync(filePath, corruptedPath);
+            fs3.copyFileSync(filePath, corruptedPath);
             corruptedSaved = true;
           } catch (copyError) {
             debugLogger2.warn(
@@ -4743,7 +4373,7 @@ function loadSettings(workspaceDir = process2.cwd(), consumeCorruptionEnvVars =
             debugLogger2.warn(warningMsg);
             if (corruptedSaved) {
               try {
-                fs4.writeFileSync(filePath, "{}", "utf-8");
+                fs3.writeFileSync(filePath, "{}", "utf-8");
               } catch {
               }
             }
@@ -4755,12 +4385,12 @@ function loadSettings(workspaceDir = process2.cwd(), consumeCorruptionEnvVars =
             };
           }
         }
-        const envCorruptedPath = process2.env[ENV_CORRUPTED_PATH];
+        const envCorruptedPath = process.env[ENV_CORRUPTED_PATH];
         if ((opts.consumeCorruptionEnvVars ?? true) && envCorruptedPath && envCorruptedPath === corruptedPath && scope === "User" /* User */) {
           corruptedSaved = true;
-          recoveredFromEnvVar = process2.env[ENV_WAS_RECOVERED] === "1";
-          delete process2.env[ENV_CORRUPTED_PATH];
-          delete process2.env[ENV_WAS_RECOVERED];
+          recoveredFromEnvVar = process.env[ENV_WAS_RECOVERED] === "1";
+          delete process.env[ENV_CORRUPTED_PATH];
+          delete process.env[ENV_WAS_RECOVERED];
         }
         if (typeof rawSettings !== "object" || rawSettings === null || Array.isArray(rawSettings)) {
           settingsErrors.push({
@@ -4955,9 +4585,9 @@ function createSettingsUpdate(key, value) {
 __name(createSettingsUpdate, "createSettingsUpdate");
 function saveSettings(settingsFile, updates = settingsFile.originalSettings, replacePath = [], opts = {}) {
   try {
-    const dirPath = path3.dirname(settingsFile.path);
-    if (!fs4.existsSync(dirPath)) {
-      fs4.mkdirSync(dirPath, { recursive: true });
+    const dirPath = path2.dirname(settingsFile.path);
+    if (!fs3.existsSync(dirPath)) {
+      fs3.mkdirSync(dirPath, { recursive: true });
     }
     const written = updateSettingsFilePreservingFormat(
       settingsFile.path,
@@ -5010,15 +4640,6 @@ export {
   backupSettingsFile,
   restoreSettingsFromBackup,
   cleanupSettingsBackup,
-  SETTINGS_DIRECTORY_NAME,
-  preResolveHomeEnvOverrides,
-  resetHomeEnvBootstrapForTesting,
-  resetEnvironmentTrackingForTesting,
-  getHomeEnvFallbackVars,
-  findEnvFiles,
-  setUpCloudShellEnvironment,
-  loadEnvironment,
-  reloadEnvironment,
   getUserSettingsPath,
   getUserSettingsDir,
   SETTINGS_VERSION,