@qwen-code/qwen-code 0.22.0 → 0.22.1

package/chunks/{chunk-A5F2YNO6.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);
   }
@@ -1023,11 +1193,51 @@ function getSessionIdFromContext(ctx) {
 }
 __name(getSessionIdFromContext, "getSessionIdFromContext");
 
+// packages/core/src/utils/sessionIdContext.ts
+init_esbuild_shims();
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+var sessionIdContext = new AsyncLocalStorage2();
+var projectDirBySession = /* @__PURE__ */ new Map();
+function registerSessionProjectDir(sessionId, projectDir) {
+  if (sessionId && projectDir) projectDirBySession.set(sessionId, projectDir);
+}
+__name(registerSessionProjectDir, "registerSessionProjectDir");
+function getSessionProjectDir(sessionId) {
+  return projectDirBySession.get(sessionId);
+}
+__name(getSessionProjectDir, "getSessionProjectDir");
+function unregisterSessionProjectDir(sessionId) {
+  projectDirBySession.delete(sessionId);
+}
+__name(unregisterSessionProjectDir, "unregisterSessionProjectDir");
+var modelBySession = /* @__PURE__ */ new Map();
+var modelIdentityBySession = /* @__PURE__ */ new Map();
+function registerSessionModel(sessionId, model, identity) {
+  if (!sessionId || !model) return;
+  modelBySession.set(sessionId, model);
+  if (identity) modelIdentityBySession.set(sessionId, identity);
+  else modelIdentityBySession.delete(sessionId);
+}
+__name(registerSessionModel, "registerSessionModel");
+function getSessionModel(sessionId) {
+  return modelBySession.get(sessionId);
+}
+__name(getSessionModel, "getSessionModel");
+function getSessionModelIdentity(sessionId) {
+  return modelIdentityBySession.get(sessionId);
+}
+__name(getSessionModelIdentity, "getSessionModelIdentity");
+function unregisterSessionModel(sessionId) {
+  modelBySession.delete(sessionId);
+  modelIdentityBySession.delete(sessionId);
+}
+__name(unregisterSessionModel, "unregisterSessionModel");
+
 // packages/core/src/utils/debugLogger.ts
 init_esbuild_shims();
 import { promises as fs4 } from "node:fs";
 import path4 from "node:path";
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "node:async_hooks";
 import util from "node:util";
 
 // packages/core/src/utils/symlink.ts
@@ -1114,7 +1324,9 @@ var ensureDebugDirPromise = null;
 var ensuredDebugDirPath = null;
 var hasWriteFailure = false;
 var globalSession = null;
-var sessionContext = new AsyncLocalStorage2();
+var lastAliasedKey = null;
+var aliasChain = Promise.resolve();
+var sessionContext = new AsyncLocalStorage3();
 function isDebugLogFileEnabled() {
   const value = process.env["QWEN_DEBUG_LOG_FILE"];
   if (!value) return false;
@@ -1125,7 +1337,12 @@ __name(isDebugLogFileEnabled, "isDebugLogFileEnabled");
 function getActiveSession() {
   const contextSession = sessionContext.getStore();
   if (contextSession === false) return null;
-  return contextSession ?? globalSession;
+  if (contextSession) return contextSession;
+  const sessionId = sessionIdContext.getStore();
+  if (sessionId) {
+    return { getSessionId: /* @__PURE__ */ __name(() => sessionId, "getSessionId") };
+  }
+  return globalSession;
 }
 __name(getActiveSession, "getActiveSession");
 function ensureDebugDirExists() {
@@ -1167,6 +1384,7 @@ function writeLog(session, level, tag, args) {
   const message = formatArgs(args);
   const traceCtx = getTraceContext();
   const line = buildLogLine(level, message, tag, traceCtx);
+  updateLatestDebugLogAlias(sessionId);
   void ensureDebugDirExists().then(() => fs4.appendFile(logFilePath, line, "utf8")).catch(() => {
     hasWriteFailure = true;
   });
@@ -1178,6 +1396,13 @@ function isDebugLoggingDegraded() {
 __name(isDebugLoggingDegraded, "isDebugLoggingDegraded");
 var DEBUG_LATEST_ALIAS = "latest";
 var SESSION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function doUpdateLatestDebugLogAlias(sessionId) {
+  const aliasPath = path4.join(Storage.getGlobalDebugDir(), DEBUG_LATEST_ALIAS);
+  const targetPath = Storage.getDebugLogPath(sessionId);
+  return ensureDebugDirExists().then(() => updateSymlink(aliasPath, targetPath, { fallbackCopy: false })).catch(() => {
+  });
+}
+__name(doUpdateLatestDebugLogAlias, "doUpdateLatestDebugLogAlias");
 function updateLatestDebugLogAlias(sessionId) {
   if (!isDebugLogFileEnabled()) {
     return;
@@ -1185,10 +1410,12 @@ function updateLatestDebugLogAlias(sessionId) {
   if (!SESSION_ID_PATTERN.test(sessionId)) {
     return;
   }
-  const aliasPath = path4.join(Storage.getGlobalDebugDir(), DEBUG_LATEST_ALIAS);
-  const targetPath = Storage.getDebugLogPath(sessionId);
-  void ensureDebugDirExists().then(() => updateSymlink(aliasPath, targetPath, { fallbackCopy: false })).catch(() => {
-  });
+  const key = path4.join(Storage.getGlobalDebugDir(), sessionId);
+  if (key === lastAliasedKey) {
+    return;
+  }
+  lastAliasedKey = key;
+  aliasChain = aliasChain.then(() => doUpdateLatestDebugLogAlias(sessionId));
 }
 __name(updateLatestDebugLogAlias, "updateLatestDebugLogAlias");
 function setDebugLogSession(session) {
@@ -1274,6 +1501,14 @@ export {
   formatTraceparent,
   setShellTracePropagation,
   isShellTracePropagationEnabled,
+  sessionIdContext,
+  registerSessionProjectDir,
+  getSessionProjectDir,
+  unregisterSessionProjectDir,
+  registerSessionModel,
+  getSessionModel,
+  getSessionModelIdentity,
+  unregisterSessionModel,
   isDebugLogFileEnabled,
   isDebugLoggingDegraded,
   setDebugLogSession,
@@ -1287,11 +1522,11 @@ export {
  */
 /**
  * @license
- * Copyright 2025 Qwen Code
+ * Copyright 2025 Qwen
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
  * @license
- * Copyright 2025 Qwen
+ * Copyright 2025 Qwen Code
  * SPDX-License-Identifier: Apache-2.0
  */

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

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

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

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