@qwen-code/qwen-code 0.20.0 → 0.20.1-nightly.20260724.7d17c44a3

package/cli-entry.js

@@ -9,7 +9,7 @@
 /**
  * Production bin entry wrapper.
  *
- * For most commands: launches dist/cli.js with --expose-gc so that
+ * For most commands: launches the bundled CLI with --expose-gc so that
  * global.gc() is available for the memory-pressure monitor's critical-tier
  * cleanup.
  *
@@ -60,13 +60,150 @@ if (isTopLevelVersion && process.env['CLI_VERSION']) {
   process.exit(0);
 }
 
-const { existsSync, realpathSync } = await import('node:fs');
+const { existsSync, readFileSync, realpathSync, statSync } = await import(
+  'node:fs'
+);
+const { createHash } = await import('node:crypto');
+const { homedir, tmpdir } = await import('node:os');
+const { parseEnv } = await import('node:util');
 const { fileURLToPath, pathToFileURL } = await import('node:url');
 const { delimiter, dirname, join, parse, resolve, sep } = await import(
   'node:path'
 );
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
+const currentEntryPath = realpathSync(fileURLToPath(import.meta.url));
+
+function getHomeDir() {
+  try {
+    return homedir() || tmpdir();
+  } catch {
+    return tmpdir();
+  }
+}
+
+function resolveQwenHome() {
+  const configured = process.env['QWEN_HOME'];
+  if (!configured) return join(getHomeDir(), '.qwen');
+  if (configured === '~') return getHomeDir();
+  if (configured.startsWith('~/') || configured.startsWith('~\\')) {
+    return join(
+      getHomeDir(),
+      ...configured
+        .slice(2)
+        .split(/[/\\]+/)
+        .filter(Boolean),
+    );
+  }
+  return resolve(configured);
+}
+
+function preResolveQwenHome() {
+  if (Object.hasOwn(process.env, 'QWEN_HOME')) return;
+  const home = getHomeDir();
+  for (const candidate of [join(home, '.qwen', '.env'), join(home, '.env')]) {
+    try {
+      const source = readFileSync(candidate, 'utf8')
+        .replace(/^\uFEFF/, '')
+        .replace(/^(\s*(?:export\s+)?QWEN_HOME):[^\S\r\n]+/gm, '$1=');
+      const configured = parseEnv(source)['QWEN_HOME'];
+      if (configured) {
+        process.env['QWEN_HOME'] = configured;
+        return;
+      }
+    } catch {
+      // Match the CLI's quiet handling of missing or invalid home env files.
+    }
+  }
+}
+
+delete process.env['QWEN_CODE_MANAGED_NPM_UPDATE'];
+preResolveQwenHome();
+
+function getManagedNpmPin() {
+  try {
+    const pin = JSON.parse(process.env['QWEN_CODE_MANAGED_NPM_PIN'] ?? '');
+    if (pin.bootstrap !== currentEntryPath) return undefined;
+    if (
+      typeof pin.updateRoot !== 'string' ||
+      resolve(pin.updateRoot) !== pin.updateRoot
+    ) {
+      return undefined;
+    }
+    if (pin.version === null) {
+      return { version: null, updateRoot: pin.updateRoot };
+    }
+    return typeof pin.version === 'string' &&
+      /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(
+        pin.version,
+      )
+      ? { version: pin.version, updateRoot: pin.updateRoot }
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+const managedNpmPin = getManagedNpmPin();
+const managedNpmUpdateRoot =
+  managedNpmPin?.updateRoot ?? join(resolveQwenHome(), 'updates', 'npm');
+
+function getManagedNpmInstallation() {
+  try {
+    if (managedNpmPin?.version === null) return undefined;
+    const launcherRoot = join(
+      managedNpmUpdateRoot,
+      createHash('sha256').update(currentEntryPath).digest('hex').slice(0, 16),
+    );
+    let version = managedNpmPin?.version;
+    if (version === undefined) {
+      const active = JSON.parse(
+        readFileSync(join(launcherRoot, 'active.json'), 'utf8'),
+      );
+      const basePackageJsonPath = [
+        join(__dirname, 'package.json'),
+        join(__dirname, '..', 'package.json'),
+      ].find((candidate) => existsSync(candidate));
+      if (!basePackageJsonPath) return undefined;
+      const basePackage = JSON.parse(readFileSync(basePackageJsonPath, 'utf8'));
+      if (
+        typeof active.version !== 'string' ||
+        !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(
+          active.version,
+        ) ||
+        typeof active.bootstrap !== 'string' ||
+        realpathSync(active.bootstrap) !== currentEntryPath ||
+        active.baseVersion !== basePackage.version ||
+        active.bootstrapCtimeMs !== statSync(currentEntryPath).ctimeMs
+      ) {
+        return undefined;
+      }
+      version = active.version;
+    }
+    const packageRoot = join(
+      launcherRoot,
+      'versions',
+      version,
+      'node_modules',
+      '@qwen-code',
+      'qwen-code',
+    );
+    const packageJsonPath = join(packageRoot, 'package.json');
+    const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+    const cliPath = join(packageRoot, 'cli.js');
+    if (
+      pkg.name !== '@qwen-code/qwen-code' ||
+      pkg.version !== version ||
+      !existsSync(cliPath)
+    ) {
+      return undefined;
+    }
+    process.env['QWEN_CODE_MANAGED_NPM_UPDATE'] = 'true';
+    return { cliPath, packageJsonPath, version };
+  } catch {
+    return undefined;
+  }
+}
 
 // The entry a subprocess should call to reach THIS build.
 //
@@ -81,9 +218,9 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 // Assignment, not `||=`: an inherited value is another session's CLI — an outer
 // qwen shelling out to this one — and honouring it re-creates the exact skew above,
 // one level up. Each entry stamps itself, so nested sessions each call their own
-// build. Nothing downstream overwrites this: the spawn below runs dist/cli.js,
-// which never re-executes this wrapper, and the post-update relaunch re-enters
-// through the launcher's own wrapper — which stamps the updated entry, as it must.
+// build. The managed-version pin keeps nested calls on the running session's build
+// even if a background update changes the active pointer. A post-update relaunch
+// clears that pin so the launcher's wrapper selects the newly active build.
 //
 // One exception, and it points the SAME way: the standalone package launches this
 // file through a shim (`bin/qwen`) that selects the BUNDLED Node — the host may
@@ -98,19 +235,33 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 // wearing this one's stamp.
 const standaloneShim = process.env['QWEN_CODE_LAUNCHER_PATH'];
 delete process.env['QWEN_CODE_LAUNCHER_PATH'];
-process.env['QWEN_CODE_CLI'] =
-  standaloneShim && existsSync(standaloneShim)
-    ? standaloneShim
-    : fileURLToPath(import.meta.url);
 
+const managedNpmInstallation = getManagedNpmInstallation();
+const validStandaloneShim =
+  standaloneShim && existsSync(standaloneShim) ? standaloneShim : undefined;
+process.env['QWEN_CODE_CLI'] =
+  validStandaloneShim ?? fileURLToPath(import.meta.url);
+if (validStandaloneShim) {
+  delete process.env['QWEN_CODE_MANAGED_NPM_PIN'];
+  delete process.env['QWEN_CODE_MANAGED_NPM_ROOT'];
+} else {
+  process.env['QWEN_CODE_MANAGED_NPM_ROOT'] = managedNpmUpdateRoot;
+  process.env['QWEN_CODE_MANAGED_NPM_PIN'] = JSON.stringify({
+    bootstrap: currentEntryPath,
+    version: managedNpmInstallation?.version ?? null,
+    updateRoot: managedNpmUpdateRoot,
+  });
+}
 const cliPathCandidates = [
+  managedNpmInstallation?.cliPath,
   join(__dirname, 'cli.js'),
   join(__dirname, '..', 'dist', 'cli.js'),
-];
+].filter(Boolean);
 const packageJsonPathCandidates = [
+  managedNpmInstallation?.packageJsonPath,
   join(__dirname, 'package.json'),
   join(__dirname, '..', 'package.json'),
-];
+].filter(Boolean);
 const cliPath =
   cliPathCandidates.find((candidate) => existsSync(candidate)) ??
   cliPathCandidates[0];
@@ -193,7 +344,7 @@ if (isInProcessFastPath()) {
   } else {
     if (!launcher) {
       process.stderr.write(
-        'Update installed. Restart Qwen Code to use the new version.\n',
+        'Update successful! The new version will be used on your next run.\n',
       );
       process.exit(0);
     }
@@ -202,6 +353,7 @@ if (isInProcessFastPath()) {
       QWEN_CODE_RELAUNCH_ARGS: JSON.stringify(cliArgs),
       QWEN_CODE_SKIP_UPDATE_CHECK_ONCE: 'true',
     };
+    delete relaunchEnv['QWEN_CODE_MANAGED_NPM_PIN'];
     const relaunchResult =
       process.platform === 'win32' && launcher.endsWith('.cmd')
         ? spawnSync(

package/cli.js

@@ -2,14 +2,14 @@
 "use strict";
 import {
   initCpuProfiler
-} from "./chunks/chunk-VZQUV7VK.js";
+} from "./chunks/chunk-CKTMY3EP.js";
+import "./chunks/chunk-EL2IQ2S5.js";
 import {
   initStartupProfiler
 } from "./chunks/chunk-QSWDGAIC.js";
 import {
   normalizeServeFastPathArgv
 } from "./chunks/chunk-Q7YDKOGY.js";
-import "./chunks/chunk-DP5GXXNZ.js";
 import {
   init_esbuild_shims
 } from "./chunks/chunk-5O2XNYP6.js";
@@ -152,7 +152,7 @@ async function buildTopLevelHelpParser() {
   const { default: yargs } = await import("./chunks/yargs-6H2AUULL.js");
   const parser = yargs([]).scriptName("qwen").usage(
     "Usage: qwen [options] [command]\n\nQwen Code - Launch an interactive CLI, use -p/--prompt for non-interactive mode"
-  ).version("0.20.0").alias("v", "version").help().alias("h", "help").strict().demandCommand(0, 0);
+  ).version("0.20.1-nightly.20260724.7d17c44a3").alias("v", "version").help().alias("h", "help").strict().demandCommand(0, 0);
   for (const [option, config] of TOP_LEVEL_HELP_OPTIONS) {
     parser.option(option, config);
   }
@@ -225,11 +225,11 @@ function printMcpHelp() {
 }
 __name(printMcpHelp, "printMcpHelp");
 async function printBootstrapVersion() {
-  if ("0.20.0") {
-    writeStdoutLine("0.20.0");
+  if ("0.20.1-nightly.20260724.7d17c44a3") {
+    writeStdoutLine("0.20.1-nightly.20260724.7d17c44a3");
     return;
   }
-  const { getCliVersion } = await import("./chunks/version-AZMG6KWL.js");
+  const { getCliVersion } = await import("./chunks/version-75VRONIL.js");
   writeStdoutLine(await getCliVersion());
 }
 __name(printBootstrapVersion, "printBootstrapVersion");
@@ -242,7 +242,7 @@ async function runMcpFastPath(rawArgv) {
   }
   const [{ default: yargsInstance }, { mcpCommand }] = await Promise.all([
     import("./chunks/yargs-6H2AUULL.js"),
-    import("./chunks/mcp-QH7QNXOH.js")
+    import("./chunks/mcp-6SOORKTY.js")
   ]);
   const parser = yargsInstance([]).scriptName("qwen").command(mcpCommand).version(false).help().alias("h", "help").strict().strictCommands().demandCommand(1, "You need at least one command before continuing.").fail((message, error, yargs) => {
     writeStderrLine(message || error?.message || "Unknown argument error");
@@ -293,6 +293,13 @@ async function parseYargsCommand(parser, argv) {
 }
 __name(parseYargsCommand, "parseYargsCommand");
 async function runCliEntry(rawArgv = process.argv.slice(2)) {
+  const managedUpdateVersion = process.env["QWEN_CODE_MANAGED_NPM_UPDATE_VERSION"];
+  if (managedUpdateVersion) {
+    delete process.env["QWEN_CODE_MANAGED_NPM_UPDATE_VERSION"];
+    const { installManagedNpmUpdate } = await import("./chunks/managed-npm-update-N42DO5QW.js");
+    await installManagedNpmUpdate(managedUpdateVersion);
+    return;
+  }
   const argv = normalizeServeFastPathArgv(rawArgv);
   const route = resolveBootstrapRoute(argv);
   if (route === "version") {
@@ -300,7 +307,7 @@ async function runCliEntry(rawArgv = process.argv.slice(2)) {
     return;
   }
   if (route === "serve") {
-    const { tryRunServeFastPath } = await import("./chunks/fast-path-M6RP2ING.js");
+    const { tryRunServeFastPath } = await import("./chunks/fast-path-IDHBVIT6.js");
     if (await tryRunServeFastPath(argv)) {
       return;
     }
@@ -313,10 +320,10 @@ async function runCliEntry(rawArgv = process.argv.slice(2)) {
   }
   const acpStartupProfiler = rawArgv.some(
     (arg) => arg === "--acp" || arg === "--experimental-acp"
-  ) ? await import("./chunks/acp-startup-profiler-N3RHHXJ3.js") : void 0;
+  ) ? await import("./chunks/acp-startup-profiler-RV3IV562.js") : void 0;
   acpStartupProfiler?.initializeAcpStartupProfiler();
   acpStartupProfiler?.markAcpStartup("geminiImportStart");
-  const { main } = await import("./chunks/gemini-H4PHBJTL.js");
+  const { main } = await import("./chunks/gemini-2AFQJMX5.js");
   acpStartupProfiler?.markAcpStartup("geminiImportEnd");
   await main();
 }
@@ -346,8 +353,8 @@ function isExpectedPtyRaceError(error) {
 __name(isExpectedPtyRaceError, "isExpectedPtyRaceError");
 async function handleCriticalError(error) {
   const [{ FatalError }, { AlreadyReportedError }] = await Promise.all([
-    import("./chunks/src-43LM7JLB.js"),
-    import("./chunks/errors-LEOF5QG4.js")
+    import("./chunks/src-LKKTJ4NG.js"),
+    import("./chunks/errors-LCPFS62A.js")
   ]);
   if (error instanceof FatalError) {
     let errorMessage = error.message;