@qwen-code/qwen-code 0.21.6 → 0.21.7-nightly.20260808.4ec0371e6

package/chunks/{chunk-O7V7N4G7.js → chunk-ACHMWGC5.js}

@@ -5,14 +5,14 @@ import {
   isTranscribableVoiceModel,
   readVoiceLanguage,
   resolveVoiceTransport
-} from "./chunk-C4CBJQKY.js";
+} from "./chunk-LDUGDB5H.js";
 import {
   resolvePath
-} from "./chunk-JELIWHXD.js";
+} from "./chunk-AOHJKPKL.js";
 import {
   createDebugLogger,
   isSubpath
-} from "./chunk-3RXUYQJI.js";
+} from "./chunk-OIVKILPI.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -24,7 +24,7 @@ import {
 init_esbuild_shims();
 import process from "node:process";
 import { lookup as dnsLookup } from "node:dns/promises";
-import { isIP } from "node:net";
+import { BlockList, isIP } from "node:net";
 
 // packages/cli/src/services/voice-keyterms.ts
 init_esbuild_shims();
@@ -238,6 +238,14 @@ var MIN_KEYTERM_ECHO_TOKENS = 8;
 var MIN_ABSOLUTE_KEYTERM_ECHO_TOKENS = 10;
 var MIN_KEYTERM_SET_ECHO_RATIO = 0.3;
 var debugLogger = createDebugLogger("VOICE_TRANSCRIBER");
+var BLOCKED_TRANSITION_IPV6_ADDRESSES = new BlockList();
+for (const [address, prefix] of [
+  ["64:ff9b:1::", 48],
+  ["2001::", 23],
+  ["2002::", 16]
+]) {
+  BLOCKED_TRANSITION_IPV6_ADDRESSES.addSubnet(address, prefix, "ipv6");
+}
 function trimTrailingSlashes(value) {
   return value.replace(/\/+$/, "");
 }
@@ -264,35 +272,78 @@ function normalizeBaseUrl(baseUrl, modelName) {
   } catch {
     throw new Error(`Voice model '${modelName}' has an invalid baseUrl.`);
   }
-  url.username = "";
-  url.password = "";
+  if (url.username || url.password) {
+    throw new Error(
+      `Voice model '${modelName}' baseUrl must not contain embedded credentials.`
+    );
+  }
   return trimTrailingSlashes(url.toString());
 }
 __name(normalizeBaseUrl, "normalizeBaseUrl");
+function normalizeAllowedVoiceBaseUrl(baseUrl) {
+  try {
+    const url = new URL(baseUrl.trim());
+    if (url.username || url.password) {
+      return void 0;
+    }
+    return trimTrailingSlashes(url.toString());
+  } catch {
+    return void 0;
+  }
+}
+__name(normalizeAllowedVoiceBaseUrl, "normalizeAllowedVoiceBaseUrl");
+function isInsecureVoiceBaseUrlAllowed(settings, normalizedBaseUrl) {
+  const allowed = settings.merged.security?.allowedInsecureVoiceBaseUrls;
+  return Array.isArray(allowed) && allowed.some(
+    (candidate) => typeof candidate === "string" && normalizeAllowedVoiceBaseUrl(candidate) === normalizedBaseUrl
+  );
+}
+__name(isInsecureVoiceBaseUrlAllowed, "isInsecureVoiceBaseUrlAllowed");
 function normalizeHostname(hostname) {
   return hostname.toLowerCase().replace(/^\[|\]$/g, "");
 }
 __name(normalizeHostname, "normalizeHostname");
+function normalizeIpAddress(address) {
+  const host = normalizeHostname(address);
+  if (isIP(host) !== 6) {
+    return host;
+  }
+  try {
+    return normalizeHostname(new URL(`http://[${host}]/`).hostname);
+  } catch {
+    return host;
+  }
+}
+__name(normalizeIpAddress, "normalizeIpAddress");
 function isLoopbackHost(hostname) {
   const host = normalizeHostname(hostname);
   return host === "localhost" || host === "127.0.0.1" || host === "::1";
 }
 __name(isLoopbackHost, "isLoopbackHost");
+function isAwsIpv6MetadataAddress(hostname) {
+  const host = normalizeHostname(hostname);
+  if (isIP(host) !== 6) {
+    return false;
+  }
+  try {
+    return normalizeHostname(new URL(`http://[${host}]/`).hostname) === "fd00:ec2::254";
+  } catch {
+    return false;
+  }
+}
+__name(isAwsIpv6MetadataAddress, "isAwsIpv6MetadataAddress");
 function readIpv4CompatibleIpv6(host) {
   if (!host.startsWith("::") || host.startsWith("::ffff:")) {
     return void 0;
   }
   const parts = host.slice(2).split(":");
-  if (parts.length === 0 || parts.length > 2 || parts.some((p) => !p)) {
+  if (parts.length === 0 || parts.length > 2 || parts.some((part) => !part)) {
     return void 0;
   }
   if (parts.some((part) => !/^[0-9a-f]{1,4}$/i.test(part))) {
     return void 0;
   }
   const hextets = parts.map((part) => Number.parseInt(part, 16));
-  if (hextets.some((part) => !Number.isInteger(part) || part < 0 || part > 65535)) {
-    return void 0;
-  }
   const value = hextets.length === 1 ? hextets[0] : hextets[0] << 16 | hextets[1];
   return [
     value >>> 24 & 255,
@@ -302,39 +353,130 @@ function readIpv4CompatibleIpv6(host) {
   ].join(".");
 }
 __name(readIpv4CompatibleIpv6, "readIpv4CompatibleIpv6");
-function isPrivateNetworkIp(hostname) {
-  const host = normalizeHostname(hostname);
-  if (isLoopbackHost(host)) {
-    return false;
+function readIpv4MappedIpv6(host) {
+  const dotted = host.match(/^::ffff:(\d+(?:\.\d+){3})$/i);
+  if (dotted && isIP(dotted[1]) === 4) {
+    return dotted[1];
   }
-  const ipv4Mapped = host.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/);
+  const hex = host.match(/^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i);
+  if (!hex) {
+    return void 0;
+  }
+  return readIpv4HexPair(hex[1], hex[2]);
+}
+__name(readIpv4MappedIpv6, "readIpv4MappedIpv6");
+function readIpv4HexPair(highHex, lowHex) {
+  const high = Number.parseInt(highHex, 16);
+  const low = Number.parseInt(lowHex, 16);
+  return [high >>> 8, high & 255, low >>> 8, low & 255].join(".");
+}
+__name(readIpv4HexPair, "readIpv4HexPair");
+function readWellKnownNat64Ipv6(host) {
+  const prefix = "64:ff9b::";
+  if (!host.startsWith(prefix)) {
+    return void 0;
+  }
+  const suffix = host.slice(prefix.length);
+  if (!suffix) {
+    return "0.0.0.0";
+  }
+  const groups = suffix.split(":");
+  if (groups.length > 2 || groups.some((group) => !/^[0-9a-f]{1,4}$/i.test(group))) {
+    return void 0;
+  }
+  return groups.length === 1 ? readIpv4HexPair("0", groups[0]) : readIpv4HexPair(groups[0], groups[1]);
+}
+__name(readWellKnownNat64Ipv6, "readWellKnownNat64Ipv6");
+function isBlockedTransitionIpv6Address(host) {
+  return isIP(host) === 6 && BLOCKED_TRANSITION_IPV6_ADDRESSES.check(host, "ipv6");
+}
+__name(isBlockedTransitionIpv6Address, "isBlockedTransitionIpv6Address");
+function unwrapIpv6TransitionStep(host) {
+  const ipv4Mapped = readIpv4MappedIpv6(host);
   if (ipv4Mapped) {
-    return isPrivateNetworkIp(ipv4Mapped[1]);
+    return { address: ipv4Mapped };
   }
-  const ipv4Compatible = host.match(/^::(\d+\.\d+\.\d+\.\d+)$/);
+  const ipv4Compatible = readIpv4CompatibleIpv6(host);
   if (ipv4Compatible) {
-    return isPrivateNetworkIp(ipv4Compatible[1]);
+    return { address: ipv4Compatible };
   }
-  const normalizedIpv4Compatible = readIpv4CompatibleIpv6(host);
-  if (normalizedIpv4Compatible) {
-    return isPrivateNetworkIp(normalizedIpv4Compatible);
+  const nat64 = readWellKnownNat64Ipv6(host);
+  if (nat64) {
+    return { address: nat64 };
   }
   if (host.startsWith("::ffff:")) {
+    return "blocked";
+  }
+  return void 0;
+}
+__name(unwrapIpv6TransitionStep, "unwrapIpv6TransitionStep");
+function isPrivateNetworkIp(hostname) {
+  const host = normalizeIpAddress(hostname);
+  if (isBlockedTransitionIpv6Address(host)) {
     return true;
   }
+  if (isLoopbackHost(host)) {
+    return false;
+  }
+  const step = unwrapIpv6TransitionStep(host);
+  if (step === "blocked") {
+    return true;
+  }
+  if (step) {
+    return isPrivateNetworkIp(step.address);
+  }
   if (isIP(host) === 4) {
     const [first = 0, second = 0] = host.split(".").map(Number);
     return first === 0 || first === 10 || first === 127 || first === 169 && second === 254 || first === 172 && second >= 16 && second <= 31 || first === 192 && second === 168 || first === 100 && second >= 64 && second <= 127;
   }
   if (isIP(host) === 6) {
-    const firstHextet = Number.parseInt(host.split(":", 1)[0] || "", 16);
-    const isLinkLocal = firstHextet >= 65152 && firstHextet <= 65215;
-    const isUniqueLocal = (firstHextet & 65024) === 64512;
-    return host === "::" || isLinkLocal || isUniqueLocal;
+    const firstHextet = Number.parseInt(host.split(":", 1)[0] || "0", 16);
+    return host === "::" || (firstHextet & 65472) === 65152 || (firstHextet & 65024) === 64512;
   }
   return false;
 }
 __name(isPrivateNetworkIp, "isPrivateNetworkIp");
+function isAlwaysBlockedVoiceAddress(address) {
+  const host = normalizeIpAddress(address);
+  if (isBlockedTransitionIpv6Address(host)) {
+    return true;
+  }
+  if (isLoopbackHost(host)) {
+    return true;
+  }
+  const step = unwrapIpv6TransitionStep(host);
+  if (step === "blocked") {
+    return true;
+  }
+  if (step) {
+    return isAlwaysBlockedVoiceAddress(step.address);
+  }
+  if (isIP(host) === 4) {
+    const [first = 0, second = 0] = host.split(".").map(Number);
+    return first === 0 || first === 127 || first === 169 && second === 254 || host === "100.100.100.200";
+  }
+  if (isIP(host) === 6) {
+    const firstHextet = Number.parseInt(host.split(":", 1)[0] || "0", 16);
+    return host === "::" || isAwsIpv6MetadataAddress(host) || (firstHextet & 65472) === 65152;
+  }
+  return false;
+}
+__name(isAlwaysBlockedVoiceAddress, "isAlwaysBlockedVoiceAddress");
+function isLoopbackVoiceAddress(address) {
+  const host = normalizeIpAddress(address);
+  if (isLoopbackHost(host)) {
+    return true;
+  }
+  const step = unwrapIpv6TransitionStep(host);
+  if (step && step !== "blocked") {
+    return isLoopbackVoiceAddress(step.address);
+  }
+  if (isIP(host) === 4) {
+    return host.startsWith("127.");
+  }
+  return false;
+}
+__name(isLoopbackVoiceAddress, "isLoopbackVoiceAddress");
 async function defaultLookupHost(hostname) {
   return dnsLookup(hostname, { all: true });
 }
@@ -345,9 +487,9 @@ async function assertVoiceBaseUrlNetworkAllowed(voiceConfig, lookupHost, abortSi
     return;
   }
   if (isIP(hostname) !== 0) {
-    if (isPrivateNetworkIp(hostname)) {
+    if (isAlwaysBlockedVoiceAddress(hostname) || !voiceConfig.allowInsecureBaseUrl && isPrivateNetworkIp(hostname)) {
       throw new Error(
-        `Voice model '${voiceConfig.model}' resolved to a private-network address.`
+        isLoopbackVoiceAddress(hostname) ? `Voice model '${voiceConfig.model}' uses a loopback address outside the accepted spellings. To use a local ASR endpoint, set the baseUrl to http://localhost, http://127.0.0.1, or http://[::1].` : `Voice model '${voiceConfig.model}' resolved to a private-network address.`
       );
     }
     return;
@@ -378,9 +520,13 @@ async function assertVoiceBaseUrlNetworkAllowed(voiceConfig, lookupHost, abortSi
     if (onAbort) abortSignal?.removeEventListener("abort", onAbort);
   }
   const records = Array.isArray(result) ? result : [result];
-  if (records.some((record) => isPrivateNetworkIp(record.address))) {
+  if (records.some(
+    (record) => isAlwaysBlockedVoiceAddress(record.address) || !voiceConfig.allowInsecureBaseUrl && isPrivateNetworkIp(record.address)
+  )) {
     throw new Error(
-      `Voice model '${voiceConfig.model}' resolved to a private-network address.`
+      records.some((record) => isLoopbackVoiceAddress(record.address)) ? `Voice model '${voiceConfig.model}' resolved to a loopback address. Loopback DNS results are always blocked; to use a local ASR endpoint, configure an explicit loopback baseUrl: http://localhost, http://127.0.0.1, or http://[::1].` : voiceConfig.allowInsecureBaseUrl && records.some(
+        (record) => isAlwaysBlockedVoiceAddress(record.address)
+      ) ? `Voice model '${voiceConfig.model}' resolved to an address that is always blocked (metadata, link-local, or transition range), even when the baseUrl is listed in security.allowedInsecureVoiceBaseUrls.` : `Voice model '${voiceConfig.model}' resolved to a private-network address.`
     );
   }
 }
@@ -390,7 +536,8 @@ function readApiKey(settings, model, baseUrl, env) {
     return void 0;
   }
   const envKey = model.envKey ?? DEFAULT_OPENAI_API_KEY;
-  const envValue = (env ?? process.env)[envKey];
+  const envSource = env ?? process.env;
+  const envValue = Object.hasOwn(envSource, envKey) ? envSource[envKey] : void 0;
   if (envValue && envValue.trim().length > 0) {
     return envValue.trim();
   }
@@ -431,14 +578,28 @@ function resolveVoiceTranscriptionConfig({
   const normalizedBaseUrl = normalizeBaseUrl(baseUrl, voiceModel);
   const parsedBaseUrl = new URL(normalizedBaseUrl);
   const isLocalhost = isLoopbackHost(parsedBaseUrl.hostname);
-  if (parsedBaseUrl.protocol !== "https:" && !isLocalhost) {
+  const allowInsecureBaseUrl = isInsecureVoiceBaseUrlAllowed(
+    settings,
+    normalizedBaseUrl
+  );
+  if (parsedBaseUrl.protocol !== "http:" && parsedBaseUrl.protocol !== "https:") {
+    throw new Error(
+      `Voice model '${voiceModel}' must use an http or https baseUrl.`
+    );
+  }
+  if (!isLocalhost && isAlwaysBlockedVoiceAddress(parsedBaseUrl.hostname)) {
+    throw new Error(
+      isLoopbackVoiceAddress(parsedBaseUrl.hostname) ? `Voice model '${voiceModel}' uses a loopback address outside the accepted spellings. To use a local ASR endpoint, set the baseUrl to http://localhost, http://127.0.0.1, or http://[::1].` : `Voice model '${voiceModel}' must not use a private-network baseUrl.`
+    );
+  }
+  if (parsedBaseUrl.protocol !== "https:" && !isLocalhost && !allowInsecureBaseUrl) {
     throw new Error(
-      `Voice model '${voiceModel}' must use an https baseUrl. Voice audio must not be transmitted in cleartext.`
+      `Voice model '${voiceModel}' must use an https baseUrl. Voice audio must not be transmitted in cleartext. To trust this managed endpoint, add its exact complete normalized URL (${normalizedBaseUrl}) to security.allowedInsecureVoiceBaseUrls. This setting is only honored from User, System, or SystemDefaults scope settings; Workspace entries are ignored.`
     );
   }
-  if (isPrivateNetworkIp(parsedBaseUrl.hostname)) {
+  if (!isLocalhost && !allowInsecureBaseUrl && isPrivateNetworkIp(parsedBaseUrl.hostname)) {
     throw new Error(
-      `Voice model '${voiceModel}' must not use a private-network baseUrl.`
+      `Voice model '${voiceModel}' must not use a private-network baseUrl. To trust this managed endpoint, add its exact complete normalized URL (${normalizedBaseUrl}) to security.allowedInsecureVoiceBaseUrls. This setting is only honored from User, System, or SystemDefaults scope settings; Workspace entries are ignored.`
     );
   }
   const apiKey = readApiKey(settings, model, normalizedBaseUrl, env);
@@ -448,7 +609,8 @@ function resolveVoiceTranscriptionConfig({
   return {
     model: voiceModel,
     baseUrl: normalizedBaseUrl,
-    ...apiKey ? { apiKey } : {}
+    ...apiKey ? { apiKey } : {},
+    ...allowInsecureBaseUrl ? { allowInsecureBaseUrl: true } : {}
   };
 }
 __name(resolveVoiceTranscriptionConfig, "resolveVoiceTranscriptionConfig");
@@ -472,6 +634,7 @@ function resolveVoiceStreamConfig(args) {
     baseUrl: base.baseUrl,
     model: base.model,
     ...base.apiKey ? { apiKey: base.apiKey } : {},
+    ...base.allowInsecureBaseUrl ? { allowInsecureBaseUrl: true } : {},
     ...language ? { language } : {},
     ...keytermsContext ? { keytermsContext } : {}
   };

package/chunks/{chunk-NKSF7HYF.js → chunk-AG3P2RES.js}

@@ -6,7 +6,7 @@ import {
   getNestedProperty,
   getPersistScopeForModelSelection,
   restoreSettingsFromBackup
-} from "./chunk-PPUOYL77.js";
+} from "./chunk-77WOUGCA.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-6PEXNQTX.js → chunk-ALFTV7GA.js}

@@ -9,6 +9,23 @@ import {
 
 // packages/cli/src/config/shared-env-keys.ts
 init_esbuild_shims();
+
+// packages/cli/src/config/acp-channel-fallback.ts
+init_esbuild_shims();
+var QWEN_CODE_SERVE_ENV = "QWEN_CODE_SERVE";
+var QWEN_CODE_DESKTOP_ENV = "QWEN_CODE_DESKTOP";
+function resolveAcpChannelFallback(env = process.env) {
+  if (env[QWEN_CODE_DESKTOP_ENV]) {
+    return "desktop";
+  }
+  if (env[QWEN_CODE_SERVE_ENV]) {
+    return "daemon";
+  }
+  return "ACP";
+}
+__name(resolveAcpChannelFallback, "resolveAcpChannelFallback");
+
+// packages/cli/src/config/shared-env-keys.ts
 var DEFAULT_EXCLUDED_ENV_VARS = ["DEBUG", "DEBUG_MODE"];
 var ENV_CORRUPTED_PATH = "QWEN_CODE_SETTINGS_CORRUPTED_PATH";
 var ENV_WAS_RECOVERED = "QWEN_CODE_SETTINGS_WAS_RECOVERED";
@@ -17,6 +34,10 @@ var PROJECT_ENV_HARDCODED_EXCLUSIONS = [
   "QWEN_RUNTIME_DIR",
   "QWEN_CODE_MCP_APPROVALS_PATH",
   "QWEN_CODE_TRUSTED_FOLDERS_PATH",
+  // Runtime attribution markers are stamped by trusted launchers. A project
+  // `.env` must not spoof client channel telemetry.
+  QWEN_CODE_SERVE_ENV,
+  QWEN_CODE_DESKTOP_ENV,
   ENV_CORRUPTED_PATH,
   ENV_WAS_RECOVERED,
   // QWEN_TLS_INSECURE (and NODE_TLS_REJECT_UNAUTHORIZED, which it mirrors)
@@ -49,6 +70,9 @@ function publishPendingCompileCache(env = process.env) {
 __name(publishPendingCompileCache, "publishPendingCompileCache");
 
 export {
+  QWEN_CODE_SERVE_ENV,
+  QWEN_CODE_DESKTOP_ENV,
+  resolveAcpChannelFallback,
   DEFAULT_EXCLUDED_ENV_VARS,
   ENV_CORRUPTED_PATH,
   ENV_WAS_RECOVERED,
@@ -58,11 +82,11 @@ export {
 };
 /**
  * @license
- * Copyright 2025 Qwen Team
+ * Copyright 2026 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
  * @license
- * Copyright 2026 Qwen Team
+ * Copyright 2025 Qwen Team
  * SPDX-License-Identifier: Apache-2.0
  */

package/chunks/{chunk-JELIWHXD.js → chunk-AOHJKPKL.js}

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