@qwen-code/qwen-code 0.19.8 → 0.19.9-nightly.20260714.9dd8389eb

package/chunks/{chunk-6VK6FIMQ.js → chunk-WM5HY72H.js}

@@ -1,243 +1,35 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  updateEventEmitter
+} from "./chunk-YAF2MQZ6.js";
 import {
   require_undici
-} from "./chunk-54YZOP7P.js";
+} from "./chunk-L573Z2QZ.js";
+import {
+  t
+} from "./chunk-SE74CIZD.js";
 import {
-  So,
-  isGitRepository
-} from "./chunk-3GNOQZDC.js";
+  So
+} from "./chunk-SSFDPGFN.js";
 import {
   createDebugLogger
-} from "./chunk-22MNNNXE.js";
+} from "./chunk-7NFB7LBQ.js";
 import {
   init_esbuild_shims
-} from "./chunk-A4BMJM77.js";
+} from "./chunk-5O2XNYP6.js";
 import {
   __name,
   __toESM
 } 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 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 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 updateCommand = process.platform === "win32" ? `powershell -ExecutionPolicy Bypass -c "irm ${STANDALONE_WINDOWS_INSTALLER} | iex"` : `curl -fsSL ${STANDALONE_UNIX_INSTALLER} | 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");
-
 // packages/cli/src/utils/standalone-update.ts
 init_esbuild_shims();
 var import_undici = __toESM(require_undici(), 1);
 import { createHash } from "node:crypto";
-import * as fs2 from "node:fs";
+import * as fs from "node:fs";
 import * as os from "node:os";
-import * as path2 from "node:path";
+import * as path from "node:path";
 import { Readable, Transform } from "node:stream";
 import { spawn, execFile } from "node:child_process";
 import { pipeline } from "node:stream/promises";
@@ -268,7 +60,7 @@ function verifySignature(sha256sumsContent, signatureBase64) {
 __name(verifySignature, "verifySignature");
 
 // packages/cli/src/utils/standalone-update.ts
-var debugLogger2 = createDebugLogger("STANDALONE_UPDATE");
+var debugLogger = createDebugLogger("STANDALONE_UPDATE");
 var OSS_BASE = "https://qwen-code-assets.oss-cn-hangzhou.aliyuncs.com/releases/qwen-code";
 var GITHUB_BASE = "https://github.com/QwenLM/qwen-code/releases/download";
 var FETCH_TIMEOUT_MS = 3e4;
@@ -314,7 +106,7 @@ async function tryFetch(url, timeoutMs = FETCH_TIMEOUT_MS) {
     return { error: new Error(`HTTP ${res.status} ${res.statusText}`) };
   } catch (err) {
     const error = err instanceof Error ? err : new Error(String(err));
-    debugLogger2.debug(`Fetch failed for ${url}: ${error.message}`);
+    debugLogger.debug(`Fetch failed for ${url}: ${error.message}`);
     return { error };
   }
 }
@@ -339,18 +131,18 @@ async function verifyChecksum(actualHash, filename, versionPath) {
   try {
     sigResponse = await downloadWithFallback(versionPath, "SHA256SUMS.sig");
   } catch (err) {
-    debugLogger2.debug("SHA256SUMS.sig not available:", err);
+    debugLogger.debug("SHA256SUMS.sig not available:", err);
   }
   if (sigResponse) {
     const sigContent = await sigResponse.text();
     verifySignature(text, sigContent.trim());
-    debugLogger2.info("SHA256SUMS signature verified.");
+    debugLogger.info("SHA256SUMS signature verified.");
   } else if (requireSig) {
     throw new Error(
       "SHA256SUMS.sig not found and QWEN_REQUIRE_SIGNATURE=1 is set"
     );
   } else {
-    debugLogger2.warn(
+    debugLogger.warn(
       "SHA256SUMS.sig not available \u2014 update integrity relies on SHA256 checksum only. Set QWEN_REQUIRE_SIGNATURE=1 to enforce signature verification."
     );
   }
@@ -390,7 +182,7 @@ async function downloadToFile(versionPath, filename, destPath) {
   }
   const hash = createHash("sha256");
   let bytesWritten = 0;
-  const dest = fs2.createWriteStream(destPath);
+  const dest = fs.createWriteStream(destPath);
   const sizeGuard = new Transform({
     transform(chunk, _encoding, callback) {
       bytesWritten += chunk.length;
@@ -408,19 +200,89 @@ async function downloadToFile(versionPath, filename, destPath) {
   return hash.digest("hex");
 }
 __name(downloadToFile, "downloadToFile");
-function validateExtractedPaths(resolvedDest) {
-  const entries = fs2.readdirSync(resolvedDest, {
+function isPathInside(base, candidate) {
+  const rel = path.relative(base, candidate);
+  return rel === "" || !!rel && rel !== ".." && !rel.startsWith(`..${path.sep}`) && !path.isAbsolute(rel);
+}
+__name(isPathInside, "isPathInside");
+function normalizeTarEntryPath(entryPath) {
+  const parts = entryPath.split(/[\\/]+/).filter((part) => part && part !== ".");
+  if (parts.length === 0 || parts.includes("..")) {
+    return null;
+  }
+  return parts.join("/");
+}
+__name(normalizeTarEntryPath, "normalizeTarEntryPath");
+function isSafeTarLinkTarget(entryPath, linkPath, resolvedDest) {
+  if (path.posix.isAbsolute(linkPath) || path.win32.isAbsolute(linkPath)) {
+    return false;
+  }
+  const normalizedEntryPath = normalizeTarEntryPath(entryPath);
+  if (!normalizedEntryPath) {
+    return false;
+  }
+  const archiveRoot = normalizedEntryPath.split("/")[0];
+  const linkTarget = path.resolve(
+    resolvedDest,
+    path.posix.dirname(normalizedEntryPath),
+    linkPath
+  );
+  return isPathInside(path.join(resolvedDest, archiveRoot), linkTarget);
+}
+__name(isSafeTarLinkTarget, "isSafeTarLinkTarget");
+function getTarEntryType(entry) {
+  if ("type" in entry) return entry.type;
+  if ("isFile" in entry && entry.isFile()) return "File";
+  if ("isDirectory" in entry && entry.isDirectory()) return "Directory";
+  if ("isSymbolicLink" in entry && entry.isSymbolicLink()) {
+    return "SymbolicLink";
+  }
+  return void 0;
+}
+__name(getTarEntryType, "getTarEntryType");
+function isSafeTarEntry(entryPath, entry, resolvedDest) {
+  if (!isSafeTarEntryPath(entryPath)) return false;
+  const entryType = getTarEntryType(entry);
+  const linkPath = "linkpath" in entry ? entry.linkpath : void 0;
+  if (entryType !== "File" && entryType !== "Directory" && entryType !== "SymbolicLink") {
+    return false;
+  }
+  if (entryType === "SymbolicLink") {
+    if (linkPath === void 0) return false;
+    return isSafeTarLinkTarget(entryPath, String(linkPath), resolvedDest);
+  }
+  return true;
+}
+__name(isSafeTarEntry, "isSafeTarEntry");
+function isAlreadyExistsError(err) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "EEXIST";
+}
+__name(isAlreadyExistsError, "isAlreadyExistsError");
+function validateExtractedPaths(resolvedDest, options = {}) {
+  const entries = fs.readdirSync(resolvedDest, {
     recursive: true,
     withFileTypes: true
   });
   for (const entry of entries) {
-    const fullPath = path2.join(
+    if (options.symlinksOnly && !entry.isSymbolicLink()) {
+      continue;
+    }
+    const fullPath = path.join(
       String(entry.parentPath || entry.path),
       entry.name
     );
-    const resolved = fs2.realpathSync(fullPath);
-    if (!resolved.startsWith(resolvedDest + path2.sep) && resolved !== resolvedDest) {
-      fs2.rmSync(resolvedDest, { recursive: true, force: true });
+    let resolved;
+    try {
+      resolved = fs.realpathSync(fullPath);
+    } catch (err) {
+      fs.rmSync(resolvedDest, { recursive: true, force: true });
+      const detail = err instanceof Error ? err.message : String(err);
+      throw new Error(
+        `Invalid archive entry: ${entry.name} could not be resolved (${detail})`
+      );
+    }
+    if (!isPathInside(resolvedDest, resolved)) {
+      fs.rmSync(resolvedDest, { recursive: true, force: true });
       throw new Error(
         `Path traversal detected in archive: ${entry.name} resolves to ${resolved}`
       );
@@ -430,14 +292,14 @@ function validateExtractedPaths(resolvedDest) {
 __name(validateExtractedPaths, "validateExtractedPaths");
 function isSafeTarEntryPath(entryPath) {
   if (entryPath.length === 0) return false;
-  if (path2.posix.isAbsolute(entryPath) || path2.win32.isAbsolute(entryPath)) {
+  if (path.posix.isAbsolute(entryPath) || path.win32.isAbsolute(entryPath)) {
     return false;
   }
-  return !entryPath.split(/[\\/]+/).includes("..");
+  return normalizeTarEntryPath(entryPath) !== null;
 }
 __name(isSafeTarEntryPath, "isSafeTarEntryPath");
 async function extractArchive(archivePath, destDir, target) {
-  fs2.mkdirSync(destDir, { recursive: true });
+  fs.mkdirSync(destDir, { recursive: true });
   if (target.startsWith("win")) {
     await new Promise((resolve2, reject) => {
       const ps = spawn(
@@ -455,30 +317,17 @@ async function extractArchive(archivePath, destDir, target) {
       );
       ps.on("error", reject);
     });
-    const resolvedDest = fs2.realpathSync(destDir);
+    const resolvedDest = fs.realpathSync(destDir);
     validateExtractedPaths(resolvedDest);
   } else {
-    const resolvedDest = path2.resolve(destDir);
+    const resolvedDest = fs.realpathSync(destDir);
     await So({
       file: archivePath,
       cwd: destDir,
       preservePaths: false,
-      filter: /* @__PURE__ */ __name((p, entry) => {
-        if (!isSafeTarEntryPath(p)) return false;
-        if ("type" in entry && entry.type === "SymbolicLink" && "linkpath" in entry) {
-          const linkTarget = path2.resolve(
-            resolvedDest,
-            path2.dirname(p),
-            String(entry.linkpath)
-          );
-          if (!linkTarget.startsWith(resolvedDest + path2.sep) && linkTarget !== resolvedDest) {
-            return false;
-          }
-        }
-        return true;
-      }, "filter")
+      filter: /* @__PURE__ */ __name((p, entry) => isSafeTarEntry(p, entry, resolvedDest), "filter")
     });
-    validateExtractedPaths(fs2.realpathSync(destDir));
+    validateExtractedPaths(fs.realpathSync(destDir), { symlinksOnly: true });
   }
 }
 __name(extractArchive, "extractArchive");
@@ -513,13 +362,13 @@ function spawnAndCapture(command, args, timeoutMs) {
 }
 __name(spawnAndCapture, "spawnAndCapture");
 async function smokeTest(newInstallDir, target) {
-  const resolvedInstallDir = path2.resolve(newInstallDir);
-  const nodeBin = target.startsWith("win") ? path2.join(resolvedInstallDir, "node", "node.exe") : path2.join(resolvedInstallDir, "node", "bin", "node");
-  const cliBin = path2.join(resolvedInstallDir, "lib", "cli.js");
-  if (!fs2.existsSync(nodeBin)) {
+  const resolvedInstallDir = path.resolve(newInstallDir);
+  const nodeBin = target.startsWith("win") ? path.join(resolvedInstallDir, "node", "node.exe") : path.join(resolvedInstallDir, "node", "bin", "node");
+  const cliBin = path.join(resolvedInstallDir, "lib", "cli.js");
+  if (!fs.existsSync(nodeBin)) {
     throw new Error(`Smoke test failed: node binary not found at ${nodeBin}`);
   }
-  if (!fs2.existsSync(cliBin)) {
+  if (!fs.existsSync(cliBin)) {
     throw new Error(`Smoke test failed: cli.js not found at ${cliBin}`);
   }
   const { exitCode, stdout, stderr } = await spawnAndCapture(
@@ -539,56 +388,109 @@ async function smokeTest(newInstallDir, target) {
       `Smoke test failed: unexpected version output "${version}"`
     );
   }
-  debugLogger2.info(`Smoke test passed: ${version}`);
+  debugLogger.info(`Smoke test passed: ${version}`);
 }
 __name(smokeTest, "smokeTest");
-function acquireLock(lockPath) {
+function checkDeferredSwap(standaloneDir) {
+  const deferredMarker = `${standaloneDir}.deferred`;
+  if (fs.existsSync(deferredMarker)) {
+    try {
+      const batPid = parseInt(
+        fs.readFileSync(deferredMarker, "utf-8").trim(),
+        10
+      );
+      if (!Number.isNaN(batPid) && isProcessAlive(batPid)) {
+        throw new Error(
+          "A previous update is still being applied. Please wait a moment and try again."
+        );
+      }
+    } catch (readErr) {
+      if (readErr instanceof Error && readErr.message.startsWith("A previous update")) {
+        throw readErr;
+      }
+    }
+    try {
+      fs.unlinkSync(deferredMarker);
+    } catch {
+    }
+  }
+  if (fs.existsSync(`${standaloneDir}.new`)) {
+    throw new Error(
+      `A previous update left a pending swap at ${standaloneDir}.new. If no qwen-update.bat process is running, remove the pending swap and .qwen-update.lock, then try again.`
+    );
+  }
+}
+__name(checkDeferredSwap, "checkDeferredSwap");
+function acquireLock(lockPath, standaloneDir) {
   try {
-    fs2.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+    fs.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+    if (standaloneDir) {
+      checkDeferredSwap(standaloneDir);
+    }
     return true;
-  } catch {
-    try {
-      const pidStr = fs2.readFileSync(lockPath, "utf-8").trim();
-      const pid = parseInt(pidStr, 10);
-      if (Number.isNaN(pid) || !isProcessAlive(pid)) {
-        fs2.unlinkSync(lockPath);
-        try {
-          fs2.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
-          return true;
-        } catch {
-          return false;
-        }
+  } catch (fastPathErr) {
+    if (fastPathErr instanceof Error && (fastPathErr.message.startsWith("A previous update") || fastPathErr.message.includes("pending swap"))) {
+      try {
+        fs.unlinkSync(lockPath);
+      } catch {
       }
+      throw fastPathErr;
+    }
+    let pidStr;
+    try {
+      pidStr = fs.readFileSync(lockPath, "utf-8").trim();
+    } catch {
+      return false;
+    }
+    const pid = parseInt(pidStr, 10);
+    if (!Number.isNaN(pid) && isProcessAlive(pid)) {
+      return false;
+    }
+    if (standaloneDir) {
+      checkDeferredSwap(standaloneDir);
+    }
+    try {
+      fs.unlinkSync(lockPath);
+      fs.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+      return true;
     } catch {
+      return false;
     }
-    return false;
   }
 }
 __name(acquireLock, "acquireLock");
 function releaseLock(lockPath) {
   try {
-    fs2.unlinkSync(lockPath);
+    fs.unlinkSync(lockPath);
   } catch {
   }
 }
 __name(releaseLock, "releaseLock");
 function cleanupEmptyStandaloneDir(standaloneDir) {
-  const manifestPath = path2.join(standaloneDir, "manifest.json");
-  if (fs2.existsSync(standaloneDir) && !fs2.existsSync(manifestPath)) {
-    fs2.rmSync(standaloneDir, { recursive: true, force: true });
+  const manifestPath = path.join(standaloneDir, "manifest.json");
+  if (fs.existsSync(standaloneDir) && !fs.existsSync(manifestPath)) {
+    fs.rmSync(standaloneDir, { recursive: true, force: true });
   }
 }
 __name(cleanupEmptyStandaloneDir, "cleanupEmptyStandaloneDir");
-var UNSAFE_SHELL_CHARS = /["`$\\;\n\r]/;
+var UNSAFE_SHELL_CHARS = /[\0\n\r]/;
 var UNSAFE_CMD_CHARS = /[&|<>^%!"`\n\r]/;
-function assertSafeForShellEmbed(p, context) {
+function assertSafeForSingleQuotedShellPath(p, context) {
   if (UNSAFE_SHELL_CHARS.test(p)) {
     throw new Error(
       `${context} contains characters unsafe for shell embedding: ${p}`
     );
   }
 }
-__name(assertSafeForShellEmbed, "assertSafeForShellEmbed");
+__name(assertSafeForSingleQuotedShellPath, "assertSafeForSingleQuotedShellPath");
+function shellQuoteForSh(p) {
+  return `'${p.replace(/'/g, "'\\''")}'`;
+}
+__name(shellQuoteForSh, "shellQuoteForSh");
+function shellQuoteForFish(p) {
+  return shellQuoteForSh(p);
+}
+__name(shellQuoteForFish, "shellQuoteForFish");
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -601,8 +503,8 @@ __name(isProcessAlive, "isProcessAlive");
 function atomicReplace(standaloneDir, newDir, lockPath) {
   const oldDir = `${standaloneDir}.old`;
   const pendingDir = `${standaloneDir}.new`;
-  if (fs2.existsSync(oldDir)) {
-    fs2.rmSync(oldDir, { recursive: true, force: true });
+  if (fs.existsSync(oldDir)) {
+    fs.rmSync(oldDir, { recursive: true, force: true });
   }
   if (os.platform() === "win32") {
     if (UNSAFE_CMD_CHARS.test(standaloneDir) || UNSAFE_CMD_CHARS.test(oldDir) || UNSAFE_CMD_CHARS.test(pendingDir)) {
@@ -610,12 +512,13 @@ function atomicReplace(standaloneDir, newDir, lockPath) {
         "Installation path contains characters unsafe for deferred update script"
       );
     }
-    if (fs2.existsSync(pendingDir)) {
-      fs2.rmSync(pendingDir, { recursive: true, force: true });
+    if (fs.existsSync(pendingDir)) {
+      fs.rmSync(pendingDir, { recursive: true, force: true });
     }
-    fs2.renameSync(newDir, pendingDir);
+    fs.renameSync(newDir, pendingDir);
     const lockFile = lockPath;
-    const logFile = path2.join(path2.dirname(standaloneDir), "qwen-update.log");
+    const deferredMarker = `${standaloneDir}.deferred`;
+    const logFile = path.join(path.dirname(standaloneDir), "qwen-update.log");
     const script = [
       "@echo off",
       "set /a TRIES=0",
@@ -643,27 +546,38 @@ function atomicReplace(standaloneDir, newDir, lockPath) {
       `  echo [%DATE% %TIME%] rollback succeeded >> "${logFile}"`,
       ")",
       ":cleanup",
+      `del /F /Q "${deferredMarker}" 2>nul`,
       `del /F /Q "${lockFile}" 2>nul`,
       `del "%~f0"`
     ].join("\r\n");
-    const scriptPath = path2.join(
-      path2.dirname(standaloneDir),
+    const scriptPath = path.join(
+      path.dirname(standaloneDir),
       "qwen-update.bat"
     );
-    fs2.writeFileSync(scriptPath, script);
-    spawn("cmd.exe", ["/c", scriptPath], {
+    fs.writeFileSync(scriptPath, script);
+    const child = spawn("cmd.exe", ["/c", scriptPath], {
       detached: true,
       stdio: "ignore",
       windowsHide: true
-    }).unref();
+    });
+    child.on("error", (err) => {
+      debugLogger.warn("Deferred bat script failed to spawn:", err);
+    });
+    child.unref();
+    if (!child.pid) {
+      throw new Error(
+        "Failed to spawn deferred update script. Update was not applied."
+      );
+    }
+    fs.writeFileSync(deferredMarker, String(child.pid));
     return "deferred";
   } else {
-    fs2.renameSync(standaloneDir, oldDir);
+    fs.renameSync(standaloneDir, oldDir);
     try {
-      fs2.renameSync(newDir, standaloneDir);
+      fs.renameSync(newDir, standaloneDir);
     } catch (promoteErr) {
       try {
-        fs2.renameSync(oldDir, standaloneDir);
+        fs.renameSync(oldDir, standaloneDir);
       } catch (rollbackErr) {
         const detail = `Standalone update failed AND rollback failed.
 Original error: ${promoteErr.message}
@@ -678,75 +592,164 @@ Manual recovery: mv "${oldDir}" "${standaloneDir}"`;
 }
 __name(atomicReplace, "atomicReplace");
 function ensureBinWrapper(standaloneDir, target) {
-  const binDir = path2.join(path2.dirname(standaloneDir), "..", "bin");
+  const binDir = path.join(path.dirname(standaloneDir), "..", "bin");
+  const artifacts = { wrapperCreated: false };
   try {
-    fs2.mkdirSync(binDir, { recursive: true });
+    fs.mkdirSync(binDir, { recursive: true });
     if (target.startsWith("win")) {
       if (UNSAFE_CMD_CHARS.test(standaloneDir)) {
         throw new Error(
           "standaloneDir contains characters unsafe for cmd.exe wrapper"
         );
       }
-      const wrapperPath = path2.join(binDir, "qwen.cmd");
-      if (!fs2.existsSync(wrapperPath)) {
-        const content = `@echo off\r
+      const wrapperPath = path.join(binDir, "qwen.cmd");
+      artifacts.wrapperPath = wrapperPath;
+      const content = `@echo off\r
 call "${standaloneDir}\\bin\\qwen.cmd" %*\r
 `;
-        fs2.writeFileSync(wrapperPath, content);
+      try {
+        fs.writeFileSync(wrapperPath, content, { flag: "wx" });
+        artifacts.wrapperCreated = true;
+      } catch (err) {
+        if (!isAlreadyExistsError(err)) {
+          throw err;
+        }
+        artifacts.wrapperNeedsAttention = !existingWrapperMatches(
+          wrapperPath,
+          standaloneDir
+        );
       }
     } else {
-      assertSafeForShellEmbed(standaloneDir, "standaloneDir");
-      const wrapperPath = path2.join(binDir, "qwen");
-      if (!fs2.existsSync(wrapperPath)) {
-        const content = `#!/bin/sh
-exec "${standaloneDir}/bin/qwen" "$@"
+      assertSafeForSingleQuotedShellPath(standaloneDir, "standaloneDir");
+      const wrapperPath = path.join(binDir, "qwen");
+      artifacts.wrapperPath = wrapperPath;
+      const quotedQwenBin = shellQuoteForSh(
+        path.join(standaloneDir, "bin", "qwen")
+      );
+      const content = `#!/usr/bin/env sh
+exec ${quotedQwenBin} "$@"
 `;
-        fs2.writeFileSync(wrapperPath, content, { mode: 493 });
+      try {
+        fs.writeFileSync(wrapperPath, content, { mode: 493, flag: "wx" });
+        artifacts.wrapperCreated = true;
+      } catch (err) {
+        if (!isAlreadyExistsError(err)) {
+          throw err;
+        }
+        artifacts.wrapperNeedsAttention = !existingWrapperMatches(
+          wrapperPath,
+          standaloneDir
+        );
       }
-      ensurePathInShellRc(binDir);
+      artifacts.shellPathUpdate = ensurePathInShellRc(binDir);
     }
+    return artifacts;
   } catch (err) {
-    debugLogger2.warn("Failed to create bin wrapper:", err);
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to create bin wrapper: ${detail}`);
   }
 }
 __name(ensureBinWrapper, "ensureBinWrapper");
+function existingWrapperMatches(wrapperPath, standaloneDir) {
+  try {
+    return fs.readFileSync(wrapperPath, "utf-8").includes(standaloneDir);
+  } catch {
+    return false;
+  }
+}
+__name(existingWrapperMatches, "existingWrapperMatches");
 function ensurePathInShellRc(binDir) {
-  assertSafeForShellEmbed(binDir, "binDir");
+  assertSafeForSingleQuotedShellPath(binDir, "binDir");
   const shell = process.env["SHELL"] || "";
   let rcFile = null;
   const home = process.env["HOME"] || os.homedir();
   if (shell.endsWith("/zsh")) {
-    rcFile = path2.join(home, ".zshrc");
+    rcFile = path.join(home, ".zshrc");
   } else if (shell.endsWith("/bash")) {
-    const bashrc = path2.join(home, ".bashrc");
-    const profile = path2.join(home, ".bash_profile");
-    if (os.platform() === "darwin") {
-      rcFile = fs2.existsSync(profile) ? profile : bashrc;
+    const bashrc = path.join(home, ".bashrc");
+    const profile = path.join(home, ".bash_profile");
+    if (fs.existsSync(bashrc)) {
+      rcFile = bashrc;
+    } else if (fs.existsSync(profile)) {
+      rcFile = profile;
     } else {
       rcFile = bashrc;
     }
   } else if (shell.endsWith("/fish")) {
-    rcFile = path2.join(home, ".config", "fish", "config.fish");
+    rcFile = path.join(home, ".config", "fish", "config.fish");
   }
-  if (!rcFile) return;
+  if (!rcFile) return { blockAdded: false };
   try {
-    const content = fs2.existsSync(rcFile) ? fs2.readFileSync(rcFile, "utf-8") : "";
-    const marker = "# Added by Qwen Code standalone installer";
-    if (content.includes(marker)) return;
-    const exportLine = shell.endsWith("/fish") ? `
-${marker}
-fish_add_path "${binDir}"
-` : `
-${marker}
-export PATH="${binDir}:$PATH"
+    const content = fs.existsSync(rcFile) ? fs.readFileSync(rcFile, "utf-8") : "";
+    const beginMarker = "# Qwen Code PATH block begin";
+    const endMarker = "# Qwen Code PATH block end";
+    const legacyMarker = "# Added by Qwen Code standalone installer";
+    if (content.includes(beginMarker) && content.includes(endMarker)) {
+      return { rcFile, blockAdded: false };
+    }
+    if (content.includes(legacyMarker)) return { rcFile, blockAdded: false };
+    const exportLine = shell.endsWith("/fish") ? `set -gx PATH ${shellQuoteForFish(binDir)} $PATH` : `export PATH=${shellQuoteForSh(binDir)}:$PATH`;
+    const block = `
+${beginMarker}
+${exportLine}
+${endMarker}
 `;
-    fs2.appendFileSync(rcFile, exportLine);
-    debugLogger2.info(`Added ${binDir} to ${rcFile}`);
+    fs.mkdirSync(path.dirname(rcFile), { recursive: true });
+    fs.appendFileSync(rcFile, block);
+    debugLogger.info(`Added ${binDir} to ${rcFile}`);
+    return { rcFile, blockAdded: true };
   } catch (err) {
-    debugLogger2.debug("Failed to update shell rc:", err);
+    debugLogger.debug("Failed to update shell rc:", err);
+    return {
+      rcFile,
+      blockAdded: false,
+      error: err instanceof Error ? err.message : String(err)
+    };
   }
 }
 __name(ensurePathInShellRc, "ensurePathInShellRc");
+function surfaceBinWrapperWarnings(artifacts) {
+  if (!artifacts) return;
+  if (artifacts.wrapperNeedsAttention && artifacts.wrapperPath) {
+    const message = `Update completed, but the existing wrapper at ${artifacts.wrapperPath} does not point to this standalone installation.`;
+    debugLogger.warn(message);
+    updateEventEmitter.emit("update-info", { message });
+  }
+  if (artifacts.shellPathUpdate?.error && artifacts.shellPathUpdate.rcFile) {
+    const message = `Update completed, but ${artifacts.shellPathUpdate.rcFile} could not be updated. Add ~/.local/bin to PATH manually.`;
+    debugLogger.warn(message);
+    updateEventEmitter.emit("update-info", { message });
+  }
+}
+__name(surfaceBinWrapperWarnings, "surfaceBinWrapperWarnings");
+function cleanupShellPathBlock(rcFile) {
+  try {
+    if (!fs.existsSync(rcFile)) return;
+    const content = fs.readFileSync(rcFile, "utf-8");
+    const blockPattern = /\n?# Qwen Code PATH block begin\n(?:.|\n)*?\n# Qwen Code PATH block end\n?/;
+    const nextContent = content.replace(blockPattern, "");
+    if (nextContent !== content) {
+      fs.writeFileSync(rcFile, nextContent);
+    }
+  } catch (err) {
+    debugLogger.debug("Failed to roll back shell rc PATH block:", err);
+  }
+}
+__name(cleanupShellPathBlock, "cleanupShellPathBlock");
+function cleanupFirstTimeMigrationArtifacts(artifacts) {
+  if (!artifacts) return;
+  if (artifacts.wrapperCreated && artifacts.wrapperPath) {
+    try {
+      fs.unlinkSync(artifacts.wrapperPath);
+    } catch (err) {
+      debugLogger.debug("Failed to roll back bin wrapper:", err);
+    }
+  }
+  if (artifacts.shellPathUpdate?.blockAdded && artifacts.shellPathUpdate.rcFile) {
+    cleanupShellPathBlock(artifacts.shellPathUpdate.rcFile);
+  }
+}
+__name(cleanupFirstTimeMigrationArtifacts, "cleanupFirstTimeMigrationArtifacts");
 function detectTarget() {
   const platform2 = os.platform();
   const arch2 = os.arch();
@@ -765,12 +768,12 @@ async function performStandaloneUpdate(standaloneDir, newVersion) {
   const versionPath = normalizeVersion(newVersion);
   let target;
   let isFirstTimeMigration = false;
-  const manifestPath = path2.join(standaloneDir, "manifest.json");
-  if (fs2.existsSync(manifestPath)) {
-    const manifestRaw = fs2.readFileSync(manifestPath, "utf-8");
+  const manifestPath = path.join(standaloneDir, "manifest.json");
+  if (fs.existsSync(manifestPath)) {
+    const manifestRaw = fs.readFileSync(manifestPath, "utf-8");
     const manifest = JSON.parse(manifestRaw);
     target = manifest.target ?? detectTarget();
-  } else if (fs2.existsSync(standaloneDir)) {
+  } else if (fs.existsSync(standaloneDir)) {
     throw new Error(
       `${standaloneDir} exists but is not a Qwen Code standalone install. Remove it manually to proceed.`
     );
@@ -780,58 +783,67 @@ async function performStandaloneUpdate(standaloneDir, newVersion) {
   }
   validateTarget(target);
   const filename = archiveFilename(target);
-  const parentDir = path2.dirname(standaloneDir);
-  fs2.mkdirSync(parentDir, { recursive: true });
-  const lockPath = path2.join(parentDir, ".qwen-update.lock");
-  if (!acquireLock(lockPath)) {
+  const parentDir = path.dirname(standaloneDir);
+  fs.mkdirSync(parentDir, { recursive: true });
+  const lockPath = path.join(parentDir, ".qwen-update.lock");
+  if (!acquireLock(lockPath, standaloneDir)) {
     throw new Error("Another update is already in progress");
   }
   if (isFirstTimeMigration) {
-    fs2.mkdirSync(standaloneDir, { recursive: true });
+    try {
+      fs.mkdirSync(standaloneDir, { recursive: true });
+    } catch (err) {
+      releaseLock(lockPath);
+      throw err;
+    }
   }
-  const tempDir = fs2.mkdtempSync(path2.join(os.tmpdir(), "qwen-code-update-"));
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "qwen-code-update-"));
   let extractDir;
   let updateResult;
+  let migrationArtifacts;
   try {
-    extractDir = fs2.mkdtempSync(path2.join(parentDir, ".qwen-code-update-"));
+    extractDir = fs.mkdtempSync(path.join(parentDir, ".qwen-code-update-"));
   } catch (err) {
-    fs2.rmSync(tempDir, { recursive: true, force: true });
+    fs.rmSync(tempDir, { recursive: true, force: true });
     releaseLock(lockPath);
     throw err;
   }
   try {
-    const archivePath = path2.join(tempDir, filename);
-    debugLogger2.info(`Downloading ${filename} (${versionPath})...`);
+    const archivePath = path.join(tempDir, filename);
+    debugLogger.info(`Downloading ${filename} (${versionPath})...`);
+    updateEventEmitter.emit("update-info", {
+      message: t("Downloading update...")
+    });
     const archiveHash = await downloadToFile(
       versionPath,
       filename,
       archivePath
     );
-    debugLogger2.info("Verifying checksum...");
+    debugLogger.info("Verifying checksum...");
     await verifyChecksum(archiveHash, filename, versionPath);
-    debugLogger2.info("Extracting archive...");
+    debugLogger.info("Extracting archive...");
     await extractArchive(archivePath, extractDir, target);
-    const newInstallDir = path2.join(extractDir, "qwen-code");
-    if (!fs2.existsSync(path2.join(newInstallDir, "manifest.json"))) {
+    const newInstallDir = path.join(extractDir, "qwen-code");
+    if (!fs.existsSync(path.join(newInstallDir, "manifest.json"))) {
       throw new Error(
         "Extracted archive does not contain expected qwen-code directory"
       );
     }
-    debugLogger2.info("Running smoke test...");
+    debugLogger.info("Running smoke test...");
     await smokeTest(newInstallDir, target);
-    debugLogger2.info("Replacing installation...");
+    debugLogger.info("Replacing installation...");
     updateResult = atomicReplace(standaloneDir, newInstallDir, lockPath);
     const oldDir = `${standaloneDir}.old`;
-    if (fs2.existsSync(oldDir)) {
+    if (fs.existsSync(oldDir)) {
       if (isFirstTimeMigration) {
-        fs2.rmSync(oldDir, { recursive: true, force: true });
+        fs.rmSync(oldDir, { recursive: true, force: true });
       } else {
         try {
-          const oldManifestPath = path2.join(oldDir, "manifest.json");
+          const oldManifestPath = path.join(oldDir, "manifest.json");
           let oldVersion = "unknown";
-          if (fs2.existsSync(oldManifestPath)) {
+          if (fs.existsSync(oldManifestPath)) {
             const oldManifest = JSON.parse(
-              fs2.readFileSync(oldManifestPath, "utf-8")
+              fs.readFileSync(oldManifestPath, "utf-8")
             );
             oldVersion = oldManifest.version || "unknown";
           }
@@ -841,43 +853,61 @@ async function performStandaloneUpdate(standaloneDir, newVersion) {
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
             reason: "auto-update"
           };
-          fs2.writeFileSync(
-            path2.join(oldDir, ".qwen-rollback-info.json"),
+          fs.writeFileSync(
+            path.join(oldDir, ".qwen-rollback-info.json"),
             JSON.stringify(rollbackInfo, null, 2)
           );
         } catch {
         }
       }
     }
-    ensureBinWrapper(standaloneDir, target);
-    debugLogger2.info("Standalone update complete.");
+    try {
+      migrationArtifacts = ensureBinWrapper(standaloneDir, target);
+      surfaceBinWrapperWarnings(migrationArtifacts);
+    } catch (wrapperErr) {
+      debugLogger.warn("Failed to refresh bin wrapper:", wrapperErr);
+      updateEventEmitter.emit("update-info", {
+        message: isFirstTimeMigration ? "Update installed, but the PATH wrapper could not be created. Add the standalone bin directory to your PATH manually, or re-run the update." : "Update completed, but the PATH wrapper could not be refreshed. The existing installation remains usable."
+      });
+    }
+    debugLogger.info("Standalone update complete.");
     return updateResult;
   } catch (err) {
     const pendingDir = `${standaloneDir}.new`;
-    if (fs2.existsSync(pendingDir)) {
-      fs2.rmSync(pendingDir, { recursive: true, force: true });
+    if (updateResult !== "deferred" && fs.existsSync(pendingDir)) {
+      fs.rmSync(pendingDir, { recursive: true, force: true });
     }
     cleanupEmptyStandaloneDir(standaloneDir);
+    if (isFirstTimeMigration) {
+      cleanupFirstTimeMigrationArtifacts(migrationArtifacts);
+    }
     throw err;
   } finally {
     if (updateResult !== "deferred") {
       releaseLock(lockPath);
+      const deferredMarker = `${standaloneDir}.deferred`;
+      if (fs.existsSync(deferredMarker)) {
+        try {
+          fs.unlinkSync(deferredMarker);
+        } catch {
+        }
+      }
     }
     try {
-      fs2.rmSync(tempDir, { recursive: true, force: true });
+      fs.rmSync(tempDir, { recursive: true, force: true });
     } catch {
     }
     try {
-      fs2.rmSync(extractDir, { recursive: true, force: true });
+      fs.rmSync(extractDir, { recursive: true, force: true });
     } catch {
     }
   }
 }
 __name(performStandaloneUpdate, "performStandaloneUpdate");
 function rollbackStandaloneUpdate(standaloneDir) {
-  const lockPath = path2.join(path2.dirname(standaloneDir), ".qwen-update.lock");
+  const lockPath = path.join(path.dirname(standaloneDir), ".qwen-update.lock");
   try {
-    const pidStr = fs2.readFileSync(lockPath, "utf-8").trim();
+    const pidStr = fs.readFileSync(lockPath, "utf-8").trim();
     const pid = parseInt(pidStr, 10);
     if (!Number.isNaN(pid) && isProcessAlive(pid)) {
       return {
@@ -889,12 +919,12 @@ function rollbackStandaloneUpdate(standaloneDir) {
   } catch {
   }
   const oldDir = `${standaloneDir}.old`;
-  if (!fs2.existsSync(oldDir)) {
+  if (!fs.existsSync(oldDir)) {
     return { ok: false, reason: "no-old", detail: `${oldDir} does not exist` };
   }
-  const oldManifest = path2.join(oldDir, "manifest.json");
-  if (!fs2.existsSync(oldManifest)) {
-    debugLogger2.error("Rollback failed: .old directory has no manifest.json");
+  const oldManifest = path.join(oldDir, "manifest.json");
+  if (!fs.existsSync(oldManifest)) {
+    debugLogger.error("Rollback failed: .old directory has no manifest.json");
     return {
       ok: false,
       reason: "no-manifest",
@@ -903,23 +933,23 @@ function rollbackStandaloneUpdate(standaloneDir) {
   }
   const failedDir = `${standaloneDir}.failed`;
   try {
-    if (fs2.existsSync(failedDir)) {
-      fs2.rmSync(failedDir, { recursive: true, force: true });
+    if (fs.existsSync(failedDir)) {
+      fs.rmSync(failedDir, { recursive: true, force: true });
     }
-    fs2.renameSync(standaloneDir, failedDir);
-    fs2.renameSync(oldDir, standaloneDir);
-    debugLogger2.info("Rollback successful.");
+    fs.renameSync(standaloneDir, failedDir);
+    fs.renameSync(oldDir, standaloneDir);
+    debugLogger.info("Rollback successful.");
     try {
-      fs2.rmSync(failedDir, { recursive: true, force: true });
+      fs.rmSync(failedDir, { recursive: true, force: true });
     } catch {
-      debugLogger2.debug(`Leftover .failed dir at ${failedDir}, safe to delete`);
+      debugLogger.debug(`Leftover .failed dir at ${failedDir}, safe to delete`);
     }
     return { ok: true };
   } catch (err) {
-    debugLogger2.error("Rollback failed:", err);
-    if (!fs2.existsSync(standaloneDir) && fs2.existsSync(failedDir)) {
+    debugLogger.error("Rollback failed:", err);
+    if (!fs.existsSync(standaloneDir) && fs.existsSync(failedDir)) {
       try {
-        fs2.renameSync(failedDir, standaloneDir);
+        fs.renameSync(failedDir, standaloneDir);
         return {
           ok: false,
           reason: "rename-failed",
@@ -938,7 +968,13 @@ function rollbackStandaloneUpdate(standaloneDir) {
 __name(rollbackStandaloneUpdate, "rollbackStandaloneUpdate");
 
 export {
-  getInstallationInfo,
+  isSafeTarLinkTarget,
+  isSafeTarEntry,
+  isSafeTarEntryPath,
+  acquireLock,
+  ensureBinWrapper,
+  ensurePathInShellRc,
+  cleanupFirstTimeMigrationArtifacts,
   performStandaloneUpdate,
   rollbackStandaloneUpdate
 };