@qwen-code/qwen-code 0.22.0-nightly.20260825.22bb5e8b9f → 0.22.1

package/chunks/{channel-worker-supervisor-NI6JEY4Q.js → channel-worker-supervisor-YSKB5GVB.js}

@@ -3,19 +3,21 @@
 import {
   ChannelWorkerStartupError,
   ChannelWorkerStopError,
-  createChannelWorkerSupervisor
-} from "./chunk-D2IGZJA7.js";
+  cleanupMintedWorkerCaBundleDirs,
+  createChannelWorkerSupervisor,
+  resolveWorkerCaCertPath
+} from "./chunk-PAJGKZAA.js";
 import "./chunk-FYJ7W2PI.js";
 import "./chunk-Z7B6SRPM.js";
 import "./chunk-7CWEZQ6T.js";
-import "./chunk-IFWUT4GY.js";
+import "./chunk-JVPFTDBK.js";
 import "./chunk-GYTKQYDB.js";
 import "./chunk-ALMR3E6Q.js";
 import "./chunk-UDG5EZJI.js";
 import "./chunk-M5GB774H.js";
 import "./chunk-3VUENPWF.js";
 import "./chunk-5HBA2Z7V.js";
-import "./chunk-NFDTDV37.js";
+import "./chunk-E55H6BZ7.js";
 import "./chunk-IW6RQPQB.js";
 import "./chunk-LJZSMWOH.js";
 import "./chunk-TWPJO254.js";
@@ -25,5 +27,7 @@ import "./chunk-J2S4EL5Y.js";
 export {
   ChannelWorkerStartupError,
   ChannelWorkerStopError,
-  createChannelWorkerSupervisor
+  cleanupMintedWorkerCaBundleDirs,
+  createChannelWorkerSupervisor,
+  resolveWorkerCaCertPath
 };

package/chunks/{chunk-CPZQJP6J.js → chunk-27ONXAFY.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-VLEGGCEA.js";
+} from "./chunk-2NNTE2ED.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-FXNLH7E6.js → chunk-2CRNTW2B.js}

@@ -12,7 +12,7 @@ import {
 } from "./chunk-5PA6UEYA.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-NDJ3436G.js";
+} from "./chunk-XNXWEGKB.js";
 import {
   require_main
 } from "./chunk-5M6IDOMF.js";
@@ -20,7 +20,7 @@ import {
   QWEN_DIR,
   Storage,
   getErrorMessage
-} from "./chunk-VLEGGCEA.js";
+} from "./chunk-2NNTE2ED.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -139,6 +139,21 @@ function resetEnvironmentTrackingForTesting() {
   lastReloadSnapshotSeeded = false;
 }
 __name(resetEnvironmentTrackingForTesting, "resetEnvironmentTrackingForTesting");
+function isFileSourcedEnvKey(key) {
+  if (dotEnvSourcedKeys.has(key) || settingsEnvSourcedKeys.has(key)) {
+    return true;
+  }
+  if (process.platform !== "win32") return false;
+  const lower = key.toLowerCase();
+  for (const tracked of dotEnvSourcedKeys) {
+    if (tracked.toLowerCase() === lower) return true;
+  }
+  for (const tracked of settingsEnvSourcedKeys) {
+    if (tracked.toLowerCase() === lower) return true;
+  }
+  return false;
+}
+__name(isFileSourcedEnvKey, "isFileSourcedEnvKey");
 function getHomeEnvFallbackVars(onReadError) {
   const globalQwenDir = Storage.getGlobalQwenDir();
   const candidates = [path.join(globalQwenDir, ".env")];
@@ -517,6 +532,7 @@ export {
   preResolveHomeEnvOverrides,
   resetHomeEnvBootstrapForTesting,
   resetEnvironmentTrackingForTesting,
+  isFileSourcedEnvKey,
   getHomeEnvFallbackVars,
   findEnvFiles,
   setUpCloudShellEnvironment,

package/chunks/{read-package-up-UXSW3YPB.js → chunk-2EAZ43JQ.js}

@@ -4711,6 +4711,7 @@ function readPackageUpSync(options) {
   };
 }
 __name(readPackageUpSync, "readPackageUpSync");
+
 export {
   readPackageUp,
   readPackageUpSync

package/chunks/{chunk-YX4II73B.js → chunk-2FN2HNTI.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   wrapForMultiplexer
-} from "./chunk-RLR7K4JJ.js";
+} from "./chunk-ZWKGZB2K.js";
 import {
   createDebugLogger
-} from "./chunk-VLEGGCEA.js";
+} from "./chunk-2NNTE2ED.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-7KGJGYGA.js → chunk-2MHGD7EE.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   t
-} from "./chunk-E6BJFSLJ.js";
+} from "./chunk-W2WRNJKX.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-H5K5MRU7.js → chunk-2NCVUT3C.js}

@@ -5,18 +5,18 @@ import {
 } from "./chunk-KW7NOTN6.js";
 import {
   DEFAULT_OPENAI_LOG_RETENTION_DAYS
-} from "./chunk-AIT6BMBI.js";
+} from "./chunk-BDHLBR46.js";
 import {
   resolveOpenAILogDir
-} from "./chunk-FZUVUBYH.js";
+} from "./chunk-OX44MOAN.js";
 import {
   FILE_HISTORY_DIR,
   getSubagentsRootDir
-} from "./chunk-UFWRXRQ5.js";
+} from "./chunk-XYX474JQ.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-VLEGGCEA.js";
+} from "./chunk-2NNTE2ED.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-VLEGGCEA.js → chunk-2NNTE2ED.js}

@@ -656,8 +656,14 @@ var IDE_DIR_NAME = "ide";
 var PLANS_DIR_NAME = "plans";
 var DEBUG_DIR_NAME = "debug";
 var ARENA_DIR_NAME = "arena";
+function platformFoldsCase() {
+  return process.platform === "win32" || process.platform === "darwin";
+}
+__name(platformFoldsCase, "platformFoldsCase");
 function isResolvedPathWithinDirectory(childPath, parentPath) {
-  const relativePath = path2.relative(parentPath, childPath);
+  const child = platformFoldsCase() ? childPath.toLowerCase() : childPath;
+  const parent = platformFoldsCase() ? parentPath.toLowerCase() : parentPath;
+  const relativePath = path2.relative(parent, child);
   return relativePath === "" || !relativePath.startsWith(`..${path2.sep}`) && relativePath !== ".." && !path2.isAbsolute(relativePath);
 }
 __name(isResolvedPathWithinDirectory, "isResolvedPathWithinDirectory");
@@ -879,6 +885,170 @@ var Storage = class _Storage {
   static getGlobalArenaDir() {
     return path2.join(_Storage.getGlobalQwenDir(), ARENA_DIR_NAME);
   }
+  /**
+   * Create or adopt the outside-repo landing for /audit reports and sidecars
+   * when the audited repository's ignore state cannot keep them out of
+   * version control. Per-user and per-project, honoring the QWEN_HOME
+   * override; 0700 on POSIX so the quoted (possibly exploitable) module
+   * content stays private to the user.
+   */
+  static ensureAuditFallbackDir(projectRoot) {
+    let resolved = projectRoot;
+    try {
+      resolved = fs2.realpathSync(projectRoot);
+    } catch {
+    }
+    if (platformFoldsCase()) {
+      resolved = resolved.toLowerCase();
+    }
+    const baseDir = _Storage.getGlobalQwenDir();
+    const dir = path2.join(baseDir, "audits", getProjectHash(resolved));
+    _Storage.assertAuditLandingIsOutsideRepo(dir, resolved);
+    try {
+      fs2.mkdirSync(baseDir, { recursive: true });
+    } catch (err) {
+      throw new FatalConfigError(
+        `audit: the QWEN_HOME base ${baseDir} could not be created as a directory (${err.message}) \u2014 remove what stands at that path and re-run.`
+      );
+    }
+    _Storage.assertAuditLandingIsOutsideRepo(dir, resolved);
+    const auditsDir = _Storage.adoptDirectory(
+      path2.join(baseDir, "audits"),
+      "the audit artifact directory"
+    );
+    _Storage.adoptDirectory(dir, "the fallback landing");
+    _Storage.assertAuditLandingIsClean(dir);
+    _Storage.adoptDirectory(auditsDir, "the audit artifact directory");
+    _Storage.adoptDirectory(dir, "the fallback landing");
+    _Storage.assertAuditLandingIsClean(dir);
+    _Storage.assertAuditLandingIsOutsideRepo(dir, resolved, true);
+    _Storage.adoptDirectory(auditsDir, "the audit artifact directory");
+    _Storage.adoptDirectory(dir, "the fallback landing");
+    return dir;
+  }
+  /**
+   * Create one path component and return it only if what is there now is a
+   * real directory (not a symlink). On POSIX a pre-existing component is
+   * tightened to 0700; ownership itself is not checked.
+   *
+   * Non-recursive on purpose: `recursive: true` would silently walk (and
+   * follow) anything already standing in the path. Creating exactly one
+   * component at a time is what makes each component checkable.
+   */
+  static adoptDirectory(dir, what) {
+    try {
+      fs2.mkdirSync(dir, { mode: 448 });
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+    }
+    const stat = fs2.lstatSync(dir);
+    if (!stat.isDirectory()) {
+      throw new FatalConfigError(
+        `audit: ${what} ${dir} is not a directory (it may be a symlink planted ahead of the run) \u2014 remove it and re-run.`
+      );
+    }
+    if (process.platform !== "win32" && (stat.mode & 511) !== 448) {
+      fs2.chmodSync(dir, 448);
+    }
+    return dir;
+  }
+  /**
+   * Refuse a fallback landing whose CONTENTS would redirect writes out of it.
+   *
+   * Validating the leaf alone is not enough: artifacts land at paths BELOW it
+   * (`audit-<ts>.sidecar/sidecar.json`, the dated report), and an
+   * O_NOFOLLOW open only ever guards the final component. A planted symlink
+   * child is therefore a complete escape — `mkdirSync` happily treats a
+   * symlink-to-directory as the directory, and every artifact written
+   * "inside" the landing lands wherever the link points, while the leaf
+   * itself stays a perfectly valid directory that re-validation passes.
+   * A hardlinked regular file is the same story for reads: an existing name
+   * reopened with O_TRUNC writes into the planter's inode.
+   *
+   * Directory children are validated recursively: a planted real
+   * subdirectory holding a symlinked file is the same escape. Entries that
+   * are neither regular files nor directories (a FIFO, socket, or device)
+   * are refused outright: opening one for the report would block, or stream
+   * the content to whoever holds the other end.
+   *
+   * The landing is REUSED across runs (the report and its sidecar are the
+   * durable artifacts), so this cannot refuse a non-empty landing — only
+   * entries that are not what a previous run of this tool would have left.
+   */
+  static assertAuditLandingIsClean(dir) {
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
+    } catch (err) {
+      throw new FatalConfigError(
+        `audit: the fallback landing ${dir} could not be listed for validation (${err.message}) \u2014 remove it and re-run.`
+      );
+    }
+    for (const entry of entries) {
+      let stat;
+      try {
+        stat = fs2.lstatSync(path2.join(dir, entry.name));
+      } catch {
+        continue;
+      }
+      if (stat.isSymbolicLink()) {
+        throw new FatalConfigError(
+          `audit: the fallback landing ${dir} contains a symlink (${entry.name}) \u2014 artifacts written under it would land outside the landing. Remove it and re-run.`
+        );
+      }
+      if (stat.isDirectory()) {
+        _Storage.assertAuditLandingIsClean(path2.join(dir, entry.name));
+        let childStat;
+        try {
+          childStat = fs2.lstatSync(path2.join(dir, entry.name));
+        } catch {
+          continue;
+        }
+        if (!childStat.isDirectory()) {
+          throw new FatalConfigError(
+            `audit: the fallback landing ${dir} contains a symlink (${entry.name}) \u2014 artifacts written under it would land outside the landing. Remove it and re-run.`
+          );
+        }
+        continue;
+      }
+      if (!stat.isFile()) {
+        throw new FatalConfigError(
+          `audit: the fallback landing ${dir} contains a special file (${entry.name}) \u2014 a write to it would block or be captured by whoever holds the other end. Remove it and re-run.`
+        );
+      }
+      if (stat.nlink > 1) {
+        throw new FatalConfigError(
+          `audit: the fallback landing ${dir} contains a hardlinked file (${entry.name}) \u2014 a write to it would also write through its twin. Remove it and re-run.`
+        );
+      }
+    }
+  }
+  /**
+   * Refuse a fallback landing that resolves inside the audited repository.
+   * A resolution failure (a non-directory component, a symlink loop, an
+   * unreadable ancestor) falls through at the pre-adoption sites: such a
+   * path cannot resolve to a usable landing, and the adoption checks that
+   * still run afterwards own that state with the actionable message. At the
+   * final site nothing runs afterwards, so the same failure fails closed
+   * instead of returning an unvalidated landing.
+   */
+  static assertAuditLandingIsOutsideRepo(dir, resolvedProjectRoot, finalCheck = false) {
+    let contained = false;
+    try {
+      contained = _Storage.isPathWithinDirectory(dir, resolvedProjectRoot);
+    } catch (err) {
+      if (finalCheck) {
+        throw new FatalConfigError(
+          `audit: the fallback landing ${dir} could not be validated as outside the audited project root (${err.message}) \u2014 remove it and re-run.`
+        );
+      }
+    }
+    if (contained) {
+      throw new FatalConfigError(
+        `audit: the fallback landing ${dir} resolves inside the audited project root \u2014 point QWEN_HOME outside the repository and re-run.`
+      );
+    }
+  }
   getQwenDir() {
     return path2.join(this.targetDir, QWEN_DIR);
   }

package/chunks/{chunk-LNKZTLTH.js → chunk-2SERYG4T.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   expandHomeDir
-} from "./chunk-VLEGGCEA.js";
+} from "./chunk-2NNTE2ED.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-UEHH33VE.js → chunk-2YDYDDE2.js}

@@ -1,20 +1,20 @@
 // Force strict mode and setup for ESM
 "use strict";
-import {
-  t
-} from "./chunk-E6BJFSLJ.js";
 import {
   require_semver
 } from "./chunk-2AUM35J5.js";
+import {
+  t
+} from "./chunk-W2WRNJKX.js";
 import {
   getNpmCliPath
-} from "./chunk-RLIS2VLZ.js";
+} from "./chunk-7DPKPBOQ.js";
 import {
   getPackageJson
-} from "./chunk-YLFLHKDL.js";
+} from "./chunk-W3N5XAZ6.js";
 import {
   createDebugLogger
-} from "./chunk-VLEGGCEA.js";
+} from "./chunk-2NNTE2ED.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";