@qwen-code/qwen-code 0.20.0-nightly.20260722.b98306b7e → 0.20.0

package/chunks/{chunk-6X4GWOPW.js → chunk-BDBMYST4.js}

@@ -3,7 +3,7 @@
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-C27BYUX6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-25WFJZL5.js → chunk-BMWMT5Y2.js}

@@ -7,12 +7,16 @@ import {
   isQwenQuotaExceededError,
   isRateLimitError,
   retryContext
-} from "./chunk-D7ZI5C7O.js";
+} from "./chunk-ZFKNWQGQ.js";
+import {
+  isTlsVerificationDisabled
+} from "./chunk-6EFTQYW7.js";
 import {
   createDebugLogger,
+  getErrorMessage,
   getErrorStatus,
   isAbortError
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-C27BYUX6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -493,13 +497,379 @@ function logRetryAtStatusLevel(message, retryDiagnostics, error, errorStatus) {
 }
 __name(logRetryAtStatusLevel, "logRetryAtStatusLevel");
 
+// packages/core/src/utils/fetch.ts
+init_esbuild_shims();
+import { URL } from "node:url";
+var PRIVATE_IP_RANGES = [
+  /^10\./,
+  /^127\./,
+  /^172\.(1[6-9]|2[0-9]|3[0-1])\./,
+  /^192\.168\./,
+  // IPv4 link-local (incl. cloud metadata endpoints) and CGNAT 100.64.0.0/10.
+  /^169\.254\./,
+  /^100\.(6[4-9]|[7-9][0-9]|1[01][0-9]|12[0-7])\./,
+  /^0\.0\.0\.0$/,
+  /^::1$/,
+  /^::$/,
+  // ULA fc00::/7 covers fc00: through fdff: (fd00: is the common prefix in
+  // practice); link-local fe80::/10 covers fe80: through febf:.
+  /^f[cd][0-9a-f]{2}:/i,
+  /^fe[89ab][0-9a-f]:/i
+];
+var TLS_ERROR_CODES = /* @__PURE__ */ new Set([
+  "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+  "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+  "SELF_SIGNED_CERT_IN_CHAIN",
+  "DEPTH_ZERO_SELF_SIGNED_CERT",
+  "CERT_HAS_EXPIRED",
+  "ERR_TLS_CERT_ALTNAME_INVALID"
+]);
+var FETCH_TROUBLESHOOTING_ERROR_CODES = /* @__PURE__ */ new Set([
+  ...TLS_ERROR_CODES,
+  "ECONNRESET",
+  "ETIMEDOUT",
+  "ECONNREFUSED",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "EHOSTUNREACH",
+  "ENETUNREACH"
+]);
+var FetchError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "FetchError";
+  }
+  static {
+    __name(this, "FetchError");
+  }
+};
+var CONNECTION_LEVEL_ERROR_CODES = /* @__PURE__ */ new Set([
+  ...TLS_ERROR_CODES,
+  "ECONNREFUSED",
+  "EPROTO",
+  "ERR_SSL_WRONG_VERSION_NUMBER",
+  // Servers that don't speak TLS on 443 often reset during the handshake
+  // rather than refusing the connection. Safe to include: the http fallback
+  // only ever fires for URLs the caller requested as http.
+  "ECONNRESET",
+  "UND_ERR_SOCKET",
+  // Filtered port 443 (silent drop): undici's own bounded connect timeout.
+  // Deliberately NOT the full-budget ETIMEDOUT — that can fire mid-body on
+  // a healthy https server, and a fallback there would double a worst-case
+  // 60s wait for an ambiguous gain.
+  "UND_ERR_CONNECT_TIMEOUT"
+]);
+function isConnectionLevelError(error) {
+  return error instanceof FetchError && error.code !== void 0 && CONNECTION_LEVEL_ERROR_CODES.has(error.code);
+}
+__name(isConnectionLevelError, "isConnectionLevelError");
+function mappedIpv4(hostname) {
+  const match = /^::ffff:(.+)$/i.exec(hostname);
+  if (!match) return void 0;
+  const tail = match[1];
+  if (tail.includes(".")) return tail;
+  const groups = tail.split(":");
+  if (groups.length !== 2) return void 0;
+  const hi = Number.parseInt(groups[0], 16);
+  const lo = Number.parseInt(groups[1], 16);
+  if (Number.isNaN(hi) || Number.isNaN(lo)) return void 0;
+  return `${hi >> 8}.${hi & 255}.${lo >> 8}.${lo & 255}`;
+}
+__name(mappedIpv4, "mappedIpv4");
+function isPrivateIp(url) {
+  try {
+    const hostname = new URL(url).hostname.replace(/^\[|\]$/g, "");
+    const target = mappedIpv4(hostname) ?? hostname;
+    return PRIVATE_IP_RANGES.some((range) => range.test(target));
+  } catch (_e) {
+    return false;
+  }
+}
+__name(isPrivateIp, "isPrivateIp");
+var INTERNAL_HOST_SUFFIXES = [".local", ".internal", ".lan", ".home.arpa"];
+function isPrivateHost(url) {
+  try {
+    const hostname = new URL(url).hostname.toLowerCase();
+    return hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "host.docker.internal" || // Single-label hostnames (intranet, ci, printserver) are never public.
+    // IPv6 literals are bracketed and dot-free but CAN be public — they
+    // are classified by isPrivateIp below, not by this heuristic.
+    !hostname.includes(".") && !hostname.startsWith("[") || INTERNAL_HOST_SUFFIXES.some((suffix) => hostname.endsWith(suffix)) || isPrivateIp(url);
+  } catch {
+    return false;
+  }
+}
+__name(isPrivateHost, "isPrivateHost");
+var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+function isPermittedRedirect(originalUrl, redirectUrl) {
+  try {
+    const original = new URL(originalUrl);
+    const redirect = new URL(redirectUrl);
+    if (redirect.protocol !== original.protocol) return false;
+    if (redirect.port !== original.port) return false;
+    if (redirect.username || redirect.password) return false;
+    const stripWww = /* @__PURE__ */ __name((hostname) => hostname.replace(/^www\./, ""), "stripWww");
+    return stripWww(original.hostname) === stripWww(redirect.hostname);
+  } catch {
+    return false;
+  }
+}
+__name(isPermittedRedirect, "isPermittedRedirect");
+var RETRYABLE_STATUSES = /* @__PURE__ */ new Set([403, 429]);
+var RETRYABLE_ERROR_CODES = /* @__PURE__ */ new Set([
+  "ECONNRESET",
+  "EAI_AGAIN",
+  "UND_ERR_SOCKET"
+]);
+var RETRY_DELAY_MS = 500;
+async function fetchWithPolicy(url, options) {
+  const timeoutSignal = AbortSignal.timeout(options.timeoutMs);
+  const signal = options.signal ? AbortSignal.any([options.signal, timeoutSignal]) : timeoutSignal;
+  const abortError = /* @__PURE__ */ __name(() => {
+    if (options.signal?.aborted) {
+      return options.signal.reason instanceof Error ? options.signal.reason : new FetchError("Request aborted", "ABORT_ERR");
+    }
+    if (timeoutSignal.aborted) {
+      return new FetchError(
+        `Request timed out after ${options.timeoutMs}ms`,
+        "ETIMEDOUT"
+      );
+    }
+    return void 0;
+  }, "abortError");
+  let first;
+  try {
+    first = await fetchPolicyAttempt(url, options, signal, timeoutSignal);
+  } catch (error) {
+    if (error instanceof FetchError && error.code !== void 0 && RETRYABLE_ERROR_CODES.has(error.code) && !signal.aborted) {
+      try {
+        await delay(RETRY_DELAY_MS, signal);
+      } catch {
+        throw abortError() ?? error;
+      }
+      return fetchPolicyAttempt(url, options, signal, timeoutSignal);
+    }
+    throw error;
+  }
+  if (first.kind === "response" && RETRYABLE_STATUSES.has(first.status) && !signal.aborted) {
+    try {
+      await delay(RETRY_DELAY_MS, signal);
+      return await fetchPolicyAttempt(url, options, signal, timeoutSignal);
+    } catch {
+      const aborted = abortError();
+      if (aborted) throw aborted;
+      return first;
+    }
+  }
+  return first;
+}
+__name(fetchWithPolicy, "fetchWithPolicy");
+async function fetchPolicyAttempt(url, options, signal, timeoutSignal) {
+  const wrapAbort = /* @__PURE__ */ __name((error) => {
+    if (options.signal?.aborted) {
+      throw options.signal.reason instanceof Error ? options.signal.reason : new FetchError("Request aborted", "ABORT_ERR");
+    }
+    if (timeoutSignal.aborted) {
+      throw new FetchError(
+        `Request timed out after ${options.timeoutMs}ms`,
+        "ETIMEDOUT"
+      );
+    }
+    if (error instanceof FetchError) throw error;
+    const code = getErrorCode(error) ?? (error instanceof Error ? getErrorCode(error.cause) : void 0);
+    throw new FetchError(getErrorMessage(error), code);
+  }, "wrapAbort");
+  let currentUrl = url;
+  for (let hop = 0; hop <= options.maxRedirects; hop++) {
+    let response;
+    try {
+      response = await fetch(currentUrl, {
+        signal,
+        headers: options.headers,
+        redirect: "manual"
+      });
+    } catch (error) {
+      return wrapAbort(error);
+    }
+    if (REDIRECT_STATUSES.has(response.status)) {
+      const location = response.headers.get("location");
+      await response.body?.cancel().catch(() => {
+      });
+      if (!location) {
+        throw new FetchError("Redirect response missing Location header");
+      }
+      let redirectUrl;
+      try {
+        redirectUrl = new URL(location, currentUrl).toString();
+      } catch {
+        throw new FetchError(
+          `Redirect response has a malformed Location header: ${location}`
+        );
+      }
+      if (!isPermittedRedirect(currentUrl, redirectUrl)) {
+        return {
+          kind: "cross-host-redirect",
+          originalUrl: currentUrl,
+          redirectUrl,
+          status: response.status
+        };
+      }
+      currentUrl = redirectUrl;
+      continue;
+    }
+    if (response.status < 200 || response.status >= 300) {
+      await response.body?.cancel().catch(() => {
+      });
+      return {
+        kind: "response",
+        status: response.status,
+        statusText: response.statusText,
+        contentType: response.headers.get("content-type") ?? "",
+        contentDisposition: response.headers.get("content-disposition") ?? "",
+        body: Buffer.alloc(0),
+        finalUrl: currentUrl
+      };
+    }
+    const contentLength = Number(response.headers.get("content-length"));
+    if (Number.isFinite(contentLength) && contentLength > options.maxBytes) {
+      await response.body?.cancel().catch(() => {
+      });
+      throw new FetchError(
+        `Response too large: ${contentLength} bytes exceeds the ${options.maxBytes}-byte limit`,
+        "EMSGSIZE"
+      );
+    }
+    const chunks = [];
+    let total = 0;
+    if (response.body) {
+      const reader = response.body.getReader();
+      try {
+        for (; ; ) {
+          const { done, value } = await reader.read();
+          if (done) break;
+          total += value.byteLength;
+          if (total > options.maxBytes) {
+            throw new FetchError(
+              `Response too large: exceeded the ${options.maxBytes}-byte limit while streaming`,
+              "EMSGSIZE"
+            );
+          }
+          chunks.push(value);
+        }
+      } catch (error) {
+        await reader.cancel().catch(() => {
+        });
+        if (error instanceof FetchError) throw error;
+        return wrapAbort(error);
+      } finally {
+        reader.releaseLock();
+      }
+    }
+    return {
+      kind: "response",
+      status: response.status,
+      statusText: response.statusText,
+      contentType: response.headers.get("content-type") ?? "",
+      contentDisposition: response.headers.get("content-disposition") ?? "",
+      body: Buffer.concat(chunks, total),
+      finalUrl: currentUrl
+    };
+  }
+  throw new FetchError(
+    `Too many redirects (exceeded ${options.maxRedirects})`,
+    "EMAXREDIRECTS"
+  );
+}
+__name(fetchPolicyAttempt, "fetchPolicyAttempt");
+function getErrorCode(error) {
+  if (!error || typeof error !== "object") {
+    return void 0;
+  }
+  if ("code" in error && typeof error["code"] === "string") {
+    return error["code"];
+  }
+  return void 0;
+}
+__name(getErrorCode, "getErrorCode");
+function formatUnknownErrorMessage(error) {
+  if (typeof error === "string") {
+    return error;
+  }
+  if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint") {
+    return String(error);
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (!error || typeof error !== "object") {
+    return void 0;
+  }
+  const message = error["message"];
+  if (typeof message === "string") {
+    return message;
+  }
+  return void 0;
+}
+__name(formatUnknownErrorMessage, "formatUnknownErrorMessage");
+function formatErrorCause(error) {
+  if (!(error instanceof Error)) {
+    return void 0;
+  }
+  const cause = error.cause;
+  if (!cause) {
+    return void 0;
+  }
+  const causeCode = getErrorCode(cause);
+  const causeMessage = formatUnknownErrorMessage(cause);
+  if (!causeCode && !causeMessage) {
+    return void 0;
+  }
+  if (causeCode && causeMessage && !causeMessage.includes(causeCode)) {
+    return `${causeCode}: ${causeMessage}`;
+  }
+  return causeMessage ?? causeCode;
+}
+__name(formatErrorCause, "formatErrorCause");
+function formatFetchErrorForUser(error, options = {}) {
+  const errorMessage = getErrorMessage(error);
+  const code = error instanceof Error ? getErrorCode(error.cause) ?? getErrorCode(error) : getErrorCode(error);
+  const cause = formatErrorCause(error);
+  const fullErrorMessage = [
+    errorMessage,
+    cause ? `(cause: ${cause})` : void 0
+  ].filter(Boolean).join(" ");
+  const shouldShowFetchHints = errorMessage.toLowerCase().includes("fetch failed") || code != null && FETCH_TROUBLESHOOTING_ERROR_CODES.has(code);
+  const shouldShowTlsHint = code != null && TLS_ERROR_CODES.has(code);
+  if (!shouldShowFetchHints) {
+    return fullErrorMessage;
+  }
+  const hintLines = [
+    "",
+    "Troubleshooting:",
+    ...options.url ? [`- Confirm you can reach ${options.url} from this machine.`] : [],
+    "- If you are behind a proxy, pass `--proxy <url>` (or set `proxy` in settings).",
+    ...shouldShowTlsHint ? isTlsVerificationDisabled() ? [
+      "- TLS verification is already disabled (`--insecure` / `QWEN_TLS_INSECURE`), so this is likely a network or protocol issue rather than a certificate trust problem."
+    ] : [
+      "- If your network uses a corporate TLS inspection CA, set `NODE_EXTRA_CA_CERTS` to your CA bundle.",
+      "- For a trusted self-signed endpoint, pass `--insecure` (or set `QWEN_TLS_INSECURE=1`) to skip certificate verification."
+    ] : []
+  ];
+  return `${fullErrorMessage}${hintLines.join("\n")}`;
+}
+__name(formatFetchErrorForUser, "formatFetchErrorForUser");
+
 export {
   classifyRetryError,
   isFallbackEligible,
   isTransientCapacityError,
   isUnattendedMode,
   delay,
-  retryWithBackoff
+  retryWithBackoff,
+  isConnectionLevelError,
+  isPrivateHost,
+  fetchWithPolicy,
+  formatFetchErrorForUser
 };
 /**
  * @license

package/chunks/{chunk-EDANOBFR.js → chunk-BRRF37CO.js}

@@ -1,21 +1,21 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  formatFetchErrorForUser
+} from "./chunk-BMWMT5Y2.js";
 import {
   openBrowserSecurely
 } from "./chunk-JESCGQM3.js";
 import {
-  formatFetchErrorForUser
-} from "./chunk-GMLTZG4O.js";
+  atomicWriteFile
+} from "./chunk-BDBMYST4.js";
 import {
   combineAbortSignals
 } from "./chunk-DJ2GSRLV.js";
-import {
-  atomicWriteFile
-} from "./chunk-6X4GWOPW.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-C27BYUX6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-QLJUC7TG.js → chunk-BVLROR2T.js}

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

package/chunks/{chunk-OQB4EXO4.js → chunk-C27BYUX6.js}

@@ -4,7 +4,7 @@ import {
   init_esm,
   isSpanContextValid,
   trace
-} from "./chunk-THJNPLI4.js";
+} from "./chunk-TB6UDU4T.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -574,16 +574,14 @@ var Storage = class _Storage {
     __name(this, "Storage");
   }
   targetDir;
-  runtimeBaseDir;
   /**
    * Custom runtime output base directory set via settings.
    * When null, falls back to getGlobalQwenDir().
    */
   static runtimeBaseDir = null;
   static runtimeBaseDirContext = new AsyncLocalStorage();
-  constructor(targetDir, runtimeBaseDir = _Storage.getRuntimeBaseDir()) {
+  constructor(targetDir) {
     this.targetDir = targetDir;
-    this.runtimeBaseDir = path2.resolve(runtimeBaseDir);
   }
   /**
    * Expands tilde and resolves relative paths to absolute.
@@ -636,9 +634,6 @@ var Storage = class _Storage {
     const resolved = _Storage.resolveRuntimeBaseDir(dir, cwd);
     return _Storage.runtimeBaseDirContext.run(resolved, fn);
   }
-  static hasRuntimeBaseDirContext() {
-    return _Storage.runtimeBaseDirContext.getStore() !== void 0;
-  }
   /**
    * Returns the base directory for all runtime output (temp files, debug logs,
    * session data, todos, insights, etc.).
@@ -775,17 +770,17 @@ var Storage = class _Storage {
   getQwenDir() {
     return path2.join(this.targetDir, QWEN_DIR);
   }
-  getRuntimeBaseDir() {
-    return this.runtimeBaseDir;
-  }
   getProjectDir() {
     const projectId = sanitizeCwd(this.getProjectRoot());
-    const projectsDir = path2.join(this.runtimeBaseDir, PROJECT_DIR_NAME);
+    const projectsDir = path2.join(
+      _Storage.getRuntimeBaseDir(),
+      PROJECT_DIR_NAME
+    );
     return path2.join(projectsDir, projectId);
   }
   getProjectTempDir() {
     const hash = getProjectHash(this.getProjectRoot());
-    const tempDir = path2.join(this.runtimeBaseDir, TMP_DIR_NAME);
+    const tempDir = _Storage.getGlobalTempDir();
     const targetDir = path2.join(tempDir, hash);
     return targetDir;
   }
@@ -912,6 +907,10 @@ async function updateSymlink(linkPath, targetPath, options) {
 }
 __name(updateSymlink, "updateSymlink");
 
+// packages/core/src/telemetry/trace-context.ts
+init_esbuild_shims();
+init_esm();
+
 // packages/core/src/telemetry/session-context.ts
 init_esbuild_shims();
 var sessionRootContext;
@@ -931,8 +930,6 @@ function getCurrentSessionId() {
 __name(getCurrentSessionId, "getCurrentSessionId");
 
 // packages/core/src/telemetry/trace-context.ts
-init_esbuild_shims();
-init_esm();
 function extractTraceContext(span) {
   const ctx = span?.spanContext();
   if (ctx && isSpanContextValid(ctx)) {

package/chunks/{chunk-GDBCCE2J.js → chunk-CB2HFGRV.js}

@@ -2,28 +2,28 @@
 "use strict";
 import {
   getExtensionManager
-} from "./chunk-7FNV372W.js";
+} from "./chunk-MJ6S23WZ.js";
 import {
   getPlugin,
   parseChannelConfig,
   registerPlugin
-} from "./chunk-QD6BRERJ.js";
+} from "./chunk-YWEW33JY.js";
 import {
   sanitizeLogText
-} from "./chunk-RVLZCXEE.js";
+} from "./chunk-NIJEXGV6.js";
 import {
   loadSettings
-} from "./chunk-DGKZ6QL3.js";
+} from "./chunk-33XUAINQ.js";
 import {
   writeStderrLine,
   writeStdoutLine
 } from "./chunk-OWAK7LMW.js";
 import {
   hashDaemonWorkspace
-} from "./chunk-D7ZI5C7O.js";
+} from "./chunk-ZFKNWQGQ.js";
 import {
   Storage
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-C27BYUX6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -158,30 +158,6 @@ function registerToolCallDispatch(bridge, router, channels) {
   });
 }
 __name(registerToolCallDispatch, "registerToolCallDispatch");
-function registerBackgroundResponseRelay(bridge, router, channels) {
-  bridge.on("backgroundResponse", (sessionId, text) => {
-    const target = router.getTarget(sessionId);
-    if (!target) {
-      writeStderrLine(
-        `[Channel] No route for background response from session ${sanitizeLogText(sessionId, 128)}`
-      );
-      return;
-    }
-    const channel = channels.get(target.channelName);
-    if (!channel) {
-      writeStderrLine(
-        `[Channel] No channel "${sanitizeLogText(target.channelName, 64)}" for background response from session ${sanitizeLogText(sessionId, 128)}`
-      );
-      return;
-    }
-    void channel.dispatchBackgroundResponse(sessionId, text).catch((err) => {
-      writeStderrLine(
-        `[Channel] Background response relay failed for session ${sanitizeLogText(sessionId, 128)}: ${err instanceof Error ? sanitizeLogText(err.message, 512) : sanitizeLogText(String(err), 512)}`
-      );
-    });
-  });
-}
-__name(registerBackgroundResponseRelay, "registerBackgroundResponseRelay");
 function cancelPermissionRequest(bridge, requestId) {
   if (!bridge.respondToPermission) {
     return;
@@ -282,7 +258,6 @@ export {
   createChannel,
   selectFirstModel,
   registerToolCallDispatch,
-  registerBackgroundResponseRelay,
   registerPermissionRelay,
   registerSessionCleanup,
   parseConfiguredChannels