@qwen-code/qwen-code 0.23.1-preview.2 → 0.23.2-preview.0

package/chunks/{chunk-ERMAXPXA.js → chunk-HIXUUCGY.js}

@@ -8,6 +8,7 @@ import {
   isWithinRoot
 } from "./chunk-J6MB5ZHZ.js";
 import {
+  atomicWriteFile,
   atomicWriteJSON
 } from "./chunk-XFFRI3WM.js";
 import {
@@ -171,11 +172,17 @@ async function addWorktreeSessionMarkerExclude(worktreePath) {
       existing = await fs2.readFile(excludePath, "utf8");
     } catch {
     }
-    const rule = WORKTREE_SESSION_FILE;
-    if (!existing.split(/\r?\n/).includes(rule)) {
-      const sep = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
-      await fs2.writeFile(excludePath, `${existing}${sep}${rule}
-`, "utf8");
+    const rules = [WORKTREE_SESSION_FILE, `${WORKTREE_SESSION_FILE}.*.tmp`];
+    let next = existing;
+    for (const rule of rules) {
+      if (!next.split(/\r?\n/).includes(rule)) {
+        const sep = next.length === 0 || next.endsWith("\n") ? "" : "\n";
+        next = `${next}${sep}${rule}
+`;
+      }
+    }
+    if (next !== existing) {
+      await fs2.writeFile(excludePath, next, "utf8");
     }
   } catch {
   }
@@ -190,15 +197,32 @@ async function writeWorktreeSessionMarker(worktreePath, sessionId) {
   await addWorktreeSessionMarkerExclude(worktreePath);
 }
 __name(writeWorktreeSessionMarker, "writeWorktreeSessionMarker");
-async function createWorktreeSessionMarkerExclusive(worktreePath, sessionId) {
-  if (sessionId.length === 0 || Buffer.byteLength(sessionId, "utf8") > WORKTREE_SESSION_MARKER_MAX_BYTES || sessionId.trim() !== sessionId) {
-    throw new Error("Invalid worktree session marker owner");
+var WorktreeMarkerCommittedError = class extends Error {
+  static {
+    __name(this, "WorktreeMarkerCommittedError");
   }
+  committedOwner;
+  constructor(committedOwner, options) {
+    super(
+      `Worktree session marker committed for ${committedOwner}; the post-commit close failed`,
+      options
+    );
+    this.name = "WorktreeMarkerCommittedError";
+    this.committedOwner = committedOwner;
+  }
+};
+async function createWorktreeSessionMarkerExclusive(worktreePath, sessionId) {
+  assertValidWorktreeSessionMarkerOwner(sessionId);
   const markerPath = path2.join(worktreePath, WORKTREE_SESSION_FILE);
+  const stagedPath = `${markerPath}.${randomBytes(6).toString("hex")}.tmp`;
   const flags = nodeFs.constants.O_WRONLY | nodeFs.constants.O_CREAT | nodeFs.constants.O_EXCL | (nodeFs.constants.O_NOFOLLOW ?? 0);
-  const handle = await fs2.open(markerPath, flags, 384);
+  const handle = await fs2.open(stagedPath, flags, 384);
+  let stagedDev = 0;
+  let stagedIno = 0;
   try {
     const before = await handle.stat();
+    stagedDev = before.dev;
+    stagedIno = before.ino;
     if (!before.isFile() || before.nlink !== 1 || before.ino === 0) {
       throw new Error("Worktree session marker has an unsafe identity");
     }
@@ -206,17 +230,43 @@ async function createWorktreeSessionMarkerExclusive(worktreePath, sessionId) {
     await handle.sync();
     const [after, pathStats] = await Promise.all([
       handle.stat(),
-      fs2.lstat(markerPath)
+      fs2.lstat(stagedPath)
     ]);
     if (!after.isFile() || after.nlink !== 1 || after.size > WORKTREE_SESSION_MARKER_MAX_BYTES || after.dev !== before.dev || after.ino !== before.ino || pathStats.dev !== after.dev || pathStats.ino !== after.ino) {
       throw new Error("Worktree session marker identity changed");
     }
-  } finally {
+    await fs2.link(stagedPath, markerPath);
+  } catch (error) {
+    await handle.close().catch(() => {
+    });
+    if (stagedIno !== 0) {
+      try {
+        const current = await fs2.lstat(stagedPath);
+        if (current.dev === stagedDev && current.ino === stagedIno) {
+          await fs2.unlink(stagedPath);
+        }
+      } catch {
+      }
+    }
+    throw error;
+  }
+  try {
+    await fs2.unlink(stagedPath);
     await handle.close();
+  } catch (error) {
+    await handle.close().catch(() => {
+    });
+    throw new WorktreeMarkerCommittedError(sessionId, { cause: error });
   }
   await addWorktreeSessionMarkerExclude(worktreePath);
 }
 __name(createWorktreeSessionMarkerExclusive, "createWorktreeSessionMarkerExclusive");
+function assertValidWorktreeSessionMarkerOwner(sessionId) {
+  if (sessionId.length === 0 || Buffer.byteLength(sessionId, "utf8") > WORKTREE_SESSION_MARKER_MAX_BYTES || sessionId.trim() !== sessionId) {
+    throw new Error("Invalid worktree session marker owner");
+  }
+}
+__name(assertValidWorktreeSessionMarkerOwner, "assertValidWorktreeSessionMarkerOwner");
 async function readWorktreeSessionMarkerStrict(worktreePath) {
   const markerPath = path2.join(worktreePath, WORKTREE_SESSION_FILE);
   let handle;
@@ -267,7 +317,13 @@ async function readWorktreeSessionMarkerStrict(worktreePath) {
     if (sessionId.length === 0 || sessionId !== raw || Buffer.byteLength(sessionId, "utf8") > WORKTREE_SESSION_MARKER_MAX_BYTES) {
       return { state: "invalid", reason: "invalid marker owner" };
     }
-    return { state: "valid", sessionId };
+    return {
+      state: "valid",
+      sessionId,
+      uid: process.geteuid === void 0 ? null : after.uid,
+      dev: after.dev,
+      ino: after.ino
+    };
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
       return observedMarker ? { state: "invalid", reason: "marker disappeared during read" } : { state: "missing" };
@@ -282,6 +338,122 @@ async function readWorktreeSessionMarkerStrict(worktreePath) {
   }
 }
 __name(readWorktreeSessionMarkerStrict, "readWorktreeSessionMarkerStrict");
+function readWorktreeSessionMarkerStrictSync(worktreePath) {
+  const markerPath = path2.join(worktreePath, WORKTREE_SESSION_FILE);
+  let fd;
+  let observedMarker = false;
+  try {
+    const flags = nodeFs.constants.O_RDONLY | (nodeFs.constants.O_NOFOLLOW ?? 0) | (nodeFs.constants.O_NONBLOCK ?? 0);
+    const before = nodeFs.lstatSync(markerPath);
+    observedMarker = true;
+    if (before.isSymbolicLink() || !before.isFile() || before.nlink !== 1) {
+      return { state: "invalid", reason: "unsafe marker file type" };
+    }
+    if (before.ino === 0 || before.size > WORKTREE_SESSION_MARKER_MAX_BYTES) {
+      return { state: "invalid", reason: "unsafe marker size or identity" };
+    }
+    fd = nodeFs.openSync(markerPath, flags);
+    const opened = nodeFs.fstatSync(fd);
+    if (!opened.isFile() || opened.nlink !== 1 || opened.dev !== before.dev || opened.ino !== before.ino) {
+      return {
+        state: "invalid",
+        reason: "marker identity changed before read"
+      };
+    }
+    const markerBuffer = Buffer.alloc(WORKTREE_SESSION_MARKER_MAX_BYTES + 1);
+    let bytesRead = 0;
+    while (bytesRead < markerBuffer.length) {
+      const chunk = nodeFs.readSync(
+        fd,
+        markerBuffer,
+        bytesRead,
+        markerBuffer.length - bytesRead,
+        bytesRead
+      );
+      if (chunk === 0) break;
+      bytesRead += chunk;
+    }
+    if (bytesRead > WORKTREE_SESSION_MARKER_MAX_BYTES) {
+      return { state: "invalid", reason: "unsafe marker size or identity" };
+    }
+    const raw = markerBuffer.subarray(0, bytesRead).toString("utf8");
+    const after = nodeFs.fstatSync(fd);
+    const pathStats = nodeFs.lstatSync(markerPath);
+    if (!after.isFile() || after.nlink !== 1 || after.size !== bytesRead || after.size > WORKTREE_SESSION_MARKER_MAX_BYTES || after.dev !== opened.dev || after.ino !== opened.ino || !pathStats.isFile() || pathStats.nlink !== 1 || pathStats.dev !== after.dev || pathStats.ino !== after.ino) {
+      return {
+        state: "invalid",
+        reason: "marker identity changed during read"
+      };
+    }
+    const sessionId = raw.trim();
+    if (sessionId.length === 0 || sessionId !== raw || Buffer.byteLength(sessionId, "utf8") > WORKTREE_SESSION_MARKER_MAX_BYTES) {
+      return { state: "invalid", reason: "invalid marker owner" };
+    }
+    return {
+      state: "valid",
+      sessionId,
+      uid: process.geteuid === void 0 ? null : after.uid,
+      dev: after.dev,
+      ino: after.ino
+    };
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return observedMarker ? { state: "invalid", reason: "marker disappeared during read" } : { state: "missing" };
+    }
+    return {
+      state: "invalid",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    if (fd !== void 0) {
+      try {
+        nodeFs.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+__name(readWorktreeSessionMarkerStrictSync, "readWorktreeSessionMarkerStrictSync");
+async function transferWorktreeSessionMarkerOwner(worktreePath, expectedOwner, newOwner) {
+  assertValidWorktreeSessionMarkerOwner(newOwner);
+  if (expectedOwner !== null) {
+    assertValidWorktreeSessionMarkerOwner(expectedOwner);
+    if (expectedOwner === newOwner) {
+      throw new Error("Worktree marker transfer needs a distinct new owner");
+    }
+  }
+  const opening = await readWorktreeSessionMarkerStrict(worktreePath);
+  if (opening.state === "invalid") {
+    throw new Error(`Worktree marker is invalid: ${opening.reason}`);
+  }
+  if (opening.state === "missing") {
+    if (expectedOwner !== null) {
+      throw new Error("Worktree marker owner does not match the expectation");
+    }
+    await createWorktreeSessionMarkerExclusive(worktreePath, newOwner);
+    return;
+  }
+  if (opening.sessionId !== expectedOwner) {
+    throw new Error("Worktree marker owner does not match the expectation");
+  }
+  const euid = process.geteuid?.();
+  if (euid !== void 0 && opening.uid !== null && opening.uid !== euid) {
+    throw new Error("Worktree marker is owned by a different uid");
+  }
+  const markerPath = path2.join(worktreePath, WORKTREE_SESSION_FILE);
+  await atomicWriteFile(markerPath, newOwner, {
+    mode: 384,
+    noFollow: true,
+    assertCanCommit: /* @__PURE__ */ __name(() => {
+      const current = readWorktreeSessionMarkerStrictSync(worktreePath);
+      if (current.state !== "valid" || current.sessionId !== opening.sessionId || current.dev !== opening.dev || current.ino !== opening.ino || current.uid !== opening.uid) {
+        throw new Error("Worktree marker changed during ownership transfer");
+      }
+    }, "assertCanCommit")
+  });
+  await addWorktreeSessionMarkerExclude(worktreePath);
+}
+__name(transferWorktreeSessionMarkerOwner, "transferWorktreeSessionMarkerOwner");
 async function readWorktreeSessionMarker(worktreePath) {
   const markerPath = path2.join(worktreePath, WORKTREE_SESSION_FILE);
   try {
@@ -1826,9 +1998,12 @@ export {
   clearRuntimeStatus,
   loadSimpleGit,
   worktreeBranchForSlug,
+  WORKTREE_SESSION_FILE,
   writeWorktreeSessionMarker,
+  WorktreeMarkerCommittedError,
   createWorktreeSessionMarkerExclusive,
   readWorktreeSessionMarkerStrict,
+  transferWorktreeSessionMarkerOwner,
   readWorktreeSessionMarker,
   AGENT_WORKTREE_SLUG_PATTERN,
   generateAgentWorktreeSlug,

package/chunks/{chunk-EJNYBDYC.js → chunk-HNLMYDQE.js}

@@ -8,7 +8,7 @@ import {
   isQuotaExhaustedError,
   isQwenQuotaExceededError,
   isRateLimitError
-} from "./chunk-W4LL5RZO.js";
+} from "./chunk-4ALNJDHL.js";
 import {
   createDebugLogger,
   getErrorStatus

package/chunks/{chunk-RCUWMVN3.js → chunk-HZ2HUXX7.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-FETY36NQ.js";
 import {
   WorkspaceDrainingError
-} from "./chunk-F47DITLZ.js";
+} from "./chunk-FAWTMDX7.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-SHX2HIE7.js → chunk-ISPBBKJN.js}

@@ -14,7 +14,7 @@ import {
 init_esbuild_shims();
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.23.1-preview.2";
+  return "0.23.2-preview.0";
 }
 __name(getCliVersion, "getCliVersion");
 

package/chunks/{chunk-QQGAR64U.js → chunk-IUJLW6ZI.js}

@@ -5,7 +5,7 @@ import {
   parseChannelDelivery,
   scheduledTaskRunSessionName,
   scheduledTaskRunSourceId
-} from "./chunk-ZNI3V2XA.js";
+} from "./chunk-TK4XHPKW.js";
 import {
   parseCallerSuppliedSessionId
 } from "./chunk-ZEZKIS2K.js";
@@ -14,10 +14,10 @@ import {
 } from "./chunk-NYWWQ437.js";
 import {
   SCHEDULED_TASK_RUN_SOURCE_TYPE
-} from "./chunk-ZT3XUGSU.js";
+} from "./chunk-63ACHB2H.js";
 import {
   SessionNotFoundError
-} from "./chunk-F47DITLZ.js";
+} from "./chunk-FAWTMDX7.js";
 import {
   canonicalizeWorkspace
 } from "./chunk-6PLDPT2C.js";
@@ -30,7 +30,7 @@ import {
 import {
   SessionService,
   stripTerminalControlSequences
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-43CI6YWJ.js";
 import {
   MAX_JOBS,
   nextDurableFireMs

package/chunks/{chunk-IMWCUWQT.js → chunk-J3TJH52D.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   CHANNEL_STARTUP_PROFILE_VERSION
-} from "./chunk-Z6KFLEG7.js";
+} from "./chunk-PSPAM24S.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-AIMZIXZM.js → chunk-J4ECGDA3.js}

@@ -5,14 +5,14 @@ import {
 } from "./chunk-KW7NOTN6.js";
 import {
   DEFAULT_OPENAI_LOG_RETENTION_DAYS
-} from "./chunk-QW7BUOSI.js";
+} from "./chunk-MWEF5MUK.js";
 import {
   resolveOpenAILogDir
-} from "./chunk-SD7Y2PMC.js";
+} from "./chunk-XI7RST4D.js";
 import {
   FILE_HISTORY_DIR,
   getSubagentsRootDir
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-43CI6YWJ.js";
 import {
   Storage,
   createDebugLogger,
@@ -169,10 +169,8 @@ var STALE_LOCK_MS = 60 * 60 * 1e3;
 async function runThrottledOnce(opts, task) {
   const minIntervalMs = opts.minIntervalMs ?? ONE_DAY_MS;
   const staleLockMs = opts.staleLockMs ?? STALE_LOCK_MS;
-  await mkdir(dirname(opts.lockPath), { recursive: true, mode: 448 }).catch(
-    () => {
-    }
-  );
+  await mkdir(dirname(opts.lockPath), { mode: 448 }).catch(() => {
+  });
   const firstFreshForMs = await markerFreshForMs(
     opts.markerPath,
     minIntervalMs,

package/chunks/{chunk-HPE4LEWX.js → chunk-JDPBJIKI.js}

@@ -64,7 +64,7 @@ async function runExitCleanup(options = {}) {
 }
 __name(runExitCleanup, "runExitCleanup");
 async function cleanupCheckpoints() {
-  const { Storage } = await import("./deferred-core-runtime-DWOXIU5S.js");
+  const { Storage } = await import("./deferred-core-runtime-NJM63YJS.js");
   const storage = new Storage(process.cwd());
   const tempDir = storage.getProjectTempDir();
   const checkpointsDir = join(tempDir, "checkpoints");

package/chunks/{chunk-Y3C5COGI.js → chunk-L6ZME3W7.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   registerCleanup
-} from "./chunk-HPE4LEWX.js";
+} from "./chunk-JDPBJIKI.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-EPZWBYQI.js → chunk-LBKYQ33T.js}

@@ -3,7 +3,7 @@
 import {
   buildModelReasoningConfigPreview,
   resolvePersistedReasoningConfigState
-} from "./chunk-ZJ2LM2SI.js";
+} from "./chunk-2OR32P5M.js";
 import {
   ACP_ROUTE_ID_PREFIX,
   buildAcpModelOptions,
@@ -12,7 +12,7 @@ import {
   parseAcpBaseModelId,
   resolveCliGenerationConfig,
   sanitizeProviderBaseUrl
-} from "./chunk-I7UNCY24.js";
+} from "./chunk-7GZCCHJL.js";
 import {
   snapshotProcessEnv
 } from "./chunk-6RZX2HIH.js";
@@ -21,10 +21,10 @@ import {
 } from "./chunk-FETY36NQ.js";
 import {
   loadSettings
-} from "./chunk-RUMSY4ES.js";
+} from "./chunk-Q2F43WTJ.js";
 import {
   ModelsConfig
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-43CI6YWJ.js";
 import {
   APPROVAL_MODES
 } from "./chunk-JX6XHPTX.js";
@@ -130,8 +130,10 @@ function buildWorkspaceProvidersStatus(workspaceCwd, acpChannelLive, options) {
             model.authType,
             model.id,
             model.registryBaseUrl ?? model.baseUrl
-          )?.generationConfig.thinkingMandatory === true
-        )
+          )?.generationConfig.thinkingMandatory === true,
+          model.capabilities?.reasoning
+        ),
+        model.capabilities?.reasoning
       );
       const providerModel = {
         modelId,

package/chunks/{chunk-KTLT7VCX.js → chunk-LN3WBOKU.js}

@@ -20,12 +20,12 @@ import {
   detectLineEnding,
   getDiffStat,
   needsUtf8Bom
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-43CI6YWJ.js";
 import {
   FileOperationEvent,
   getLanguageFromFilePath,
   logFileOperation
-} from "./chunk-WQBR7LN5.js";
+} from "./chunk-OIPUQE3S.js";
 import {
   fileExists,
   getSpecificMimeType

package/chunks/{chunk-FXYNIZPW.js → chunk-LUVXLLMS.js}

@@ -8,10 +8,10 @@ import {
 } from "./chunk-TXASDT2M.js";
 import {
   t
-} from "./chunk-LD53HMPV.js";
+} from "./chunk-CRZBDVP2.js";
 import {
   So
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-43CI6YWJ.js";
 import {
   createDebugLogger
 } from "./chunk-ZAFYHRVY.js";
@@ -93,6 +93,24 @@ function escapePS(s) {
   return s.replace(/'/g, "''");
 }
 __name(escapePS, "escapePS");
+function resolveUpdateBaseUrl() {
+  const value = process.env["QWEN_UPDATE_BASE_URL"]?.trim();
+  if (!value) return void 0;
+  const invalidUrl = /* @__PURE__ */ __name(() => new Error(
+    "QWEN_UPDATE_BASE_URL must be an absolute HTTPS URL without credentials, query parameters, or a fragment."
+  ), "invalidUrl");
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw invalidUrl();
+  }
+  if (!/^https:\/\//i.test(value) || url.username || url.password || /[?#\s]/.test(value)) {
+    throw invalidUrl();
+  }
+  return url.href.replace(/\/+$/, "");
+}
+__name(resolveUpdateBaseUrl, "resolveUpdateBaseUrl");
 async function tryFetch(url, timeoutMs = FETCH_TIMEOUT_MS) {
   try {
     const { fetch } = await loadUndici();
@@ -110,7 +128,17 @@ async function tryFetch(url, timeoutMs = FETCH_TIMEOUT_MS) {
   }
 }
 __name(tryFetch, "tryFetch");
-async function downloadWithFallback(versionPath, filename, timeoutMs = FETCH_TIMEOUT_MS) {
+async function downloadWithFallback(versionPath, filename, timeoutMs = FETCH_TIMEOUT_MS, baseUrl) {
+  if (baseUrl) {
+    const result = await tryFetch(
+      `${baseUrl}/${versionPath}/${filename}`,
+      timeoutMs
+    );
+    if (result.response) return result.response;
+    throw new Error(
+      `Failed to download ${filename} from QWEN_UPDATE_BASE_URL: ${result.error.message}`
+    );
+  }
   const ossUrl = `${OSS_BASE}/${versionPath}/${filename}`;
   const ossResult = await tryFetch(ossUrl, timeoutMs);
   if (ossResult.response) return ossResult.response;
@@ -122,13 +150,23 @@ async function downloadWithFallback(versionPath, filename, timeoutMs = FETCH_TIM
   );
 }
 __name(downloadWithFallback, "downloadWithFallback");
-async function verifyChecksum(actualHash, filename, versionPath) {
-  const response = await downloadWithFallback(versionPath, "SHA256SUMS");
+async function verifyChecksum(actualHash, filename, versionPath, baseUrl) {
+  const response = await downloadWithFallback(
+    versionPath,
+    "SHA256SUMS",
+    FETCH_TIMEOUT_MS,
+    baseUrl
+  );
   const text = await response.text();
   const requireSig = process.env["QWEN_REQUIRE_SIGNATURE"] === "1";
   let sigResponse;
   try {
-    sigResponse = await downloadWithFallback(versionPath, "SHA256SUMS.sig");
+    sigResponse = await downloadWithFallback(
+      versionPath,
+      "SHA256SUMS.sig",
+      FETCH_TIMEOUT_MS,
+      baseUrl
+    );
   } catch (err) {
     debugLogger.debug("SHA256SUMS.sig not available:", err);
   }
@@ -163,11 +201,12 @@ async function verifyChecksum(actualHash, filename, versionPath) {
 }
 __name(verifyChecksum, "verifyChecksum");
 var MAX_DOWNLOAD_BYTES = 512 * 1024 * 1024;
-async function downloadToFile(versionPath, filename, destPath) {
+async function downloadToFile(versionPath, filename, destPath, baseUrl) {
   const response = await downloadWithFallback(
     versionPath,
     filename,
-    ARCHIVE_TIMEOUT_MS
+    ARCHIVE_TIMEOUT_MS,
+    baseUrl
   );
   const body = response.body;
   if (!body) throw new Error("Empty response body");
@@ -772,6 +811,7 @@ function detectTarget() {
 __name(detectTarget, "detectTarget");
 async function performStandaloneUpdate(standaloneDir, newVersion) {
   const versionPath = normalizeVersion(newVersion);
+  const baseUrl = resolveUpdateBaseUrl();
   let target;
   let isFirstTimeMigration = false;
   const manifestPath = path.join(standaloneDir, "manifest.json");
@@ -823,10 +863,11 @@ async function performStandaloneUpdate(standaloneDir, newVersion) {
     const archiveHash = await downloadToFile(
       versionPath,
       filename,
-      archivePath
+      archivePath,
+      baseUrl
     );
     debugLogger.info("Verifying checksum...");
-    await verifyChecksum(archiveHash, filename, versionPath);
+    await verifyChecksum(archiveHash, filename, versionPath, baseUrl);
     debugLogger.info("Extracting archive...");
     await extractArchive(archivePath, extractDir, target);
     const newInstallDir = path.join(extractDir, "qwen-code");

package/chunks/{chunk-RQNAO42A.js → chunk-M6YLOETP.js}

@@ -3,7 +3,7 @@
 import {
   getGitVersion,
   getNpmVersion
-} from "./chunk-FWH4736Q.js";
+} from "./chunk-EA4NFWVG.js";
 import {
   buildEnvStatusFromEnv,
   snapshotProcessEnv