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

package/chunks/{chunk-NBMIC7DR.js → chunk-SX4PK3FC.js}

@@ -2,9 +2,12 @@
 "use strict";
 import {
   CHANNEL_DAEMON_WORKER_SENTINEL,
+  CHANNEL_DELIVERY_IPC_TIMEOUT_MS,
   CHANNEL_WEBHOOK_TASK_IPC_TIMEOUT_MS,
   CHANNEL_WORKER_HEARTBEAT_INTERVAL_MS,
+  ChannelDeliveryError,
   ChannelWebhookEnqueueError,
+  MAX_CHANNEL_DELIVERIES_IN_FLIGHT,
   MAX_CHANNEL_STARTUP_FAILURES,
   MAX_CHANNEL_STARTUP_FAILURE_CHANNEL_LENGTH,
   MAX_CHANNEL_STARTUP_FAILURE_CODE_LENGTH,
@@ -13,18 +16,20 @@ import {
   QWEN_DAEMON_URL_ENV,
   QWEN_DAEMON_WORKSPACE_ENV,
   QWEN_SERVER_TOKEN_ENV,
+  createChannelDeliveryMessage,
   createChannelWebhookTaskMessage,
   createWorkerDiagnosticRedactor,
+  isChannelDeliveryResultMessage,
   isChannelStartupReportMessage,
   isChannelStartupReportType,
   isChannelWebhookEnqueueErrorCode,
   isChannelWebhookTaskResultMessage,
   normalizeWorkerDiagnostic,
   sanitizeWorkerDiagnostic
-} from "./chunk-Y2ENGUD6.js";
+} from "./chunk-UPF7PTBI.js";
 import {
   channelSelectionNames
-} from "./chunk-TJTKSVIV.js";
+} from "./chunk-JLU636DO.js";
 import {
   CHANNEL_WORKER_KILL_GRACE_MS,
   CHANNEL_WORKER_STARTUP_TIMEOUT_MS,
@@ -32,7 +37,7 @@ import {
 } from "./chunk-5HBA2Z7V.js";
 import {
   sanitizeLogText
-} from "./chunk-NIJEXGV6.js";
+} from "./chunk-ZXYUQXY5.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -263,6 +268,7 @@ function createChannelWorkerSupervisor(opts) {
   let staleHeartbeatTimer;
   let restartAttemptTimes = [];
   const pendingWebhookTasks = /* @__PURE__ */ new Map();
+  const pendingChannelDeliveries = /* @__PURE__ */ new Map();
   let restarting;
   let disposed = false;
   const snapshotCopy = /* @__PURE__ */ __name(() => ({
@@ -273,7 +279,8 @@ function createChannelWorkerSupervisor(opts) {
       startupFailures: snapshot.startupFailures.map((failure) => ({
         ...failure
       }))
-    } : {}
+    } : {},
+    ...snapshot.adapters ? { adapters: snapshot.adapters.map((adapter) => ({ ...adapter })) } : {}
   }), "snapshotCopy");
   const clearRestartTimer = /* @__PURE__ */ __name(() => {
     if (restartTimer) {
@@ -325,6 +332,39 @@ function createChannelWorkerSupervisor(opts) {
     }
     return true;
   }, "settleWebhookTask");
+  const rejectPendingChannelDeliveries = /* @__PURE__ */ __name((code, message) => {
+    for (const pending of pendingChannelDeliveries.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new ChannelDeliveryError(code, message));
+    }
+    pendingChannelDeliveries.clear();
+  }, "rejectPendingChannelDeliveries");
+  const rejectPendingChannelDelivery = /* @__PURE__ */ __name((id, error) => {
+    const pending = pendingChannelDeliveries.get(id);
+    if (!pending) return;
+    pendingChannelDeliveries.delete(id);
+    clearTimeout(pending.timer);
+    pending.reject(error);
+  }, "rejectPendingChannelDelivery");
+  const settleChannelDelivery = /* @__PURE__ */ __name((message) => {
+    if (!isChannelDeliveryResultMessage(message)) return false;
+    const pending = pendingChannelDeliveries.get(message.id);
+    if (!pending) return true;
+    if (message.ok) {
+      pendingChannelDeliveries.delete(message.id);
+      clearTimeout(pending.timer);
+      pending.resolve({ delivered: true });
+    } else {
+      rejectPendingChannelDelivery(
+        message.id,
+        new ChannelDeliveryError(
+          message.code,
+          message.error || "Channel delivery failed."
+        )
+      );
+    }
+    return true;
+  }, "settleChannelDelivery");
   const pruneRestartAttempts = /* @__PURE__ */ __name((nowMs) => {
     restartAttemptTimes = restartAttemptTimes.filter(
       (attemptMs) => nowMs - attemptMs < restartPolicy.windowMs
@@ -432,6 +472,12 @@ function createChannelWorkerSupervisor(opts) {
       state: "starting",
       channels: channelSelectionNames(opts.selection),
       ...requestedChannels ? { requestedChannels } : {},
+      ...requestedChannels ? {
+        adapters: requestedChannels.map((name) => ({
+          name,
+          state: "starting"
+        }))
+      } : {},
       startedAt,
       restartCount: snapshot.restartCount ?? 0,
       ...snapshot.lastExitAt ? { lastExitAt: snapshot.lastExitAt } : {},
@@ -615,7 +661,14 @@ function createChannelWorkerSupervisor(opts) {
         };
         snapshot = {
           ...snapshot,
-          startupFailures: [...snapshot.startupFailures ?? [], failure]
+          startupFailures: [...snapshot.startupFailures ?? [], failure],
+          adapters: snapshot.adapters?.map(
+            (adapter) => adapter.name === failure.channel ? {
+              name: adapter.name,
+              state: "error",
+              error: failure.message
+            } : adapter
+          )
         };
         acknowledgeStartupReport();
       }, "handleStartupReport");
@@ -637,6 +690,22 @@ function createChannelWorkerSupervisor(opts) {
         if (message.requestedChannels?.length) {
           next.requestedChannels = [...message.requestedChannels];
         }
+        const adapterNames = message.requestedChannels?.length ? message.requestedChannels : next.requestedChannels ?? next.channels;
+        const connected = new Set(next.channels);
+        const failures = new Map(
+          next.startupFailures?.map((failure) => [failure.channel, failure])
+        );
+        next.adapters = adapterNames.map((name) => {
+          if (connected.has(name)) {
+            return { name, state: "connected" };
+          }
+          const failure = failures.get(name);
+          return {
+            name,
+            state: "error",
+            ...failure ? { error: failure.message } : {}
+          };
+        });
         snapshot = next;
         armStaleHeartbeatTimer(startedChild);
         notifyReady(opts.onReady, snapshotCopy());
@@ -656,6 +725,9 @@ function createChannelWorkerSupervisor(opts) {
       }, "handleHeartbeat");
       function handleMessage(message) {
         if (child !== startedChild) return;
+        if (settleChannelDelivery(message)) {
+          return;
+        }
         if (settleWebhookTask(message)) {
           return;
         }
@@ -684,6 +756,10 @@ function createChannelWorkerSupervisor(opts) {
           "channel_worker_unavailable",
           "Channel worker exited."
         );
+        rejectPendingChannelDeliveries(
+          "channel_worker_unavailable",
+          "Channel worker exited."
+        );
         child = void 0;
         if ((ready || kind === "restart") && !stopping) {
           scheduleRestart();
@@ -759,6 +835,10 @@ function createChannelWorkerSupervisor(opts) {
         "channel_worker_unavailable",
         "Channel worker stopped."
       );
+      rejectPendingChannelDeliveries(
+        "channel_worker_unavailable",
+        "Channel worker stopped."
+      );
       if (!child || snapshot.state === "exited" || snapshot.state === "failed" && hasObservedExit(snapshot) || snapshot.state === "stopped") {
         child = void 0;
         snapshot = { ...snapshot, state: "stopped" };
@@ -803,6 +883,10 @@ function createChannelWorkerSupervisor(opts) {
         "channel_worker_unavailable",
         "Channel worker stopped."
       );
+      rejectPendingChannelDeliveries(
+        "channel_worker_unavailable",
+        "Channel worker stopped."
+      );
       if (!child || snapshot.state === "exited" || snapshot.state === "failed" && hasObservedExit(snapshot) || snapshot.state === "stopped") {
         clearRestartTimer();
         clearStaleHeartbeatTimer();
@@ -825,6 +909,62 @@ function createChannelWorkerSupervisor(opts) {
     snapshot() {
       return snapshotCopy();
     },
+    async deliverChannelMessage(request) {
+      const startedChild = child;
+      if (!startedChild || snapshot.state !== "running") {
+        throw new ChannelDeliveryError(
+          "channel_worker_unavailable",
+          "Channel worker is not running."
+        );
+      }
+      const send = startedChild.send;
+      if (!send) {
+        throw new ChannelDeliveryError(
+          "channel_worker_unavailable",
+          "Channel worker IPC send failed."
+        );
+      }
+      if (pendingChannelDeliveries.size >= MAX_CHANNEL_DELIVERIES_IN_FLIGHT) {
+        throw new ChannelDeliveryError(
+          "channel_delivery_queue_full",
+          "Channel delivery queue is full."
+        );
+      }
+      const message = createChannelDeliveryMessage(request);
+      return await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pendingChannelDeliveries.delete(message.id);
+          reject(
+            new ChannelDeliveryError(
+              "channel_delivery_timeout",
+              "Channel delivery IPC timed out."
+            )
+          );
+        }, CHANNEL_DELIVERY_IPC_TIMEOUT_MS);
+        timer.unref();
+        pendingChannelDeliveries.set(message.id, { resolve, reject, timer });
+        try {
+          send.call(startedChild, message, (error) => {
+            if (!error) return;
+            rejectPendingChannelDelivery(
+              message.id,
+              new ChannelDeliveryError(
+                "channel_worker_unavailable",
+                `Channel worker IPC send failed: ${error.message}`
+              )
+            );
+          });
+        } catch (error) {
+          rejectPendingChannelDelivery(
+            message.id,
+            new ChannelDeliveryError(
+              "channel_worker_unavailable",
+              `Channel worker IPC send failed: ${error instanceof Error ? error.message : String(error)}`
+            )
+          );
+        }
+      });
+    },
     async enqueueWebhookTask(task) {
       const startedChild = child;
       if (!startedChild || snapshot.state !== "running") {

package/chunks/chunk-T3452DP5.js

@@ -0,0 +1,246 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  require_semver
+} from "./chunk-DP3IHZGG.js";
+import {
+  getNpmCliPath
+} from "./chunk-BSNWBC33.js";
+import {
+  t
+} from "./chunk-ZT4POVWC.js";
+import {
+  getPackageJson
+} from "./chunk-VJNBRRZG.js";
+import {
+  createDebugLogger
+} from "./chunk-OQB4EXO4.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/ui/utils/updateCheck.ts
+init_esbuild_shims();
+var import_semver = __toESM(require_semver(), 1);
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var debugLogger = createDebugLogger("UPDATE_CHECK");
+var FETCH_TIMEOUT_MS = 5e3;
+var UpdateCheckTimeoutError = class extends Error {
+  static {
+    __name(this, "UpdateCheckTimeoutError");
+  }
+  distTag;
+  constructor(timeoutMs, distTag) {
+    const suffix = distTag ? ` for ${distTag}` : "";
+    super(`update check timed out after ${timeoutMs}ms${suffix}`);
+    this.name = "UpdateCheckTimeoutError";
+    this.distTag = distTag;
+  }
+};
+var NETWORK_ERROR_CODES = [
+  "ENOTFOUND",
+  "ECONNREFUSED",
+  "EAI_AGAIN",
+  "ETIMEDOUT",
+  "ENETUNREACH"
+];
+function classifyUpdateCheckError(error) {
+  if (error instanceof UpdateCheckTimeoutError) return "timeout";
+  if (error instanceof Error) {
+    if ("killed" in error && error.killed === true && "signal" in error && error.signal === "SIGTERM") {
+      return "timeout";
+    }
+    const errors = [error];
+    if (error.cause instanceof Error) errors.push(error.cause);
+    const matchesCode = /* @__PURE__ */ __name((code) => errors.some(
+      (error2) => error2.code === code || error2.message.includes(code)
+    ), "matchesCode");
+    if (NETWORK_ERROR_CODES.some(matchesCode)) return "offline";
+  }
+  return "registry";
+}
+__name(classifyUpdateCheckError, "classifyUpdateCheckError");
+function describeUpdateCheckFailure(error, timeoutMs = FETCH_TIMEOUT_MS) {
+  switch (classifyUpdateCheckError(error)) {
+    case "timeout":
+      return t("registry did not respond within {{seconds}}s", {
+        seconds: String(Math.round(timeoutMs / 1e3))
+      });
+    case "offline":
+      return t("registry unreachable");
+    default:
+      return t("registry error");
+  }
+}
+__name(describeUpdateCheckFailure, "describeUpdateCheckFailure");
+async function fetchInfoWithTimeout(notifier, timeoutMs, distTag) {
+  let timer;
+  try {
+    return await Promise.race([
+      Promise.resolve(notifier.fetchInfo()),
+      new Promise((_, reject) => {
+        timer = setTimeout(
+          () => reject(new UpdateCheckTimeoutError(timeoutMs, distTag)),
+          timeoutMs
+        );
+      })
+    ]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+__name(fetchInfoWithTimeout, "fetchInfoWithTimeout");
+var execFileAsync = promisify(execFile);
+async function runGlobalNpm(args, run = execFileAsync, platform = process.platform, nodePath = process.execPath, resolveNpmCliPath = getNpmCliPath) {
+  const { stdout } = await run(
+    nodePath,
+    [resolveNpmCliPath(nodePath, platform), ...args],
+    {
+      encoding: "utf8",
+      timeout: FETCH_TIMEOUT_MS
+    }
+  );
+  return String(stdout).trim();
+}
+__name(runGlobalNpm, "runGlobalNpm");
+async function fetchGlobalNpmUpdateInfo(packageName, currentVersion, distTag, run = execFileAsync) {
+  const output = await runGlobalNpm(
+    ["view", packageName, `dist-tags.${distTag}`, "--json", "--global"],
+    run
+  );
+  if (output === "") {
+    return {
+      latest: currentVersion,
+      current: currentVersion,
+      type: "latest",
+      name: packageName
+    };
+  }
+  const parsed = JSON.parse(output);
+  const latest = typeof parsed === "string" ? parsed : Array.isArray(parsed) && parsed.length === 1 && typeof parsed[0] === "string" ? parsed[0] : void 0;
+  if (latest === void 0) {
+    throw new Error(`Invalid npm ${distTag} version response`);
+  }
+  return {
+    latest,
+    current: currentVersion,
+    type: "latest",
+    name: packageName
+  };
+}
+__name(fetchGlobalNpmUpdateInfo, "fetchGlobalNpmUpdateInfo");
+function getBestAvailableUpdate(nightly, stable) {
+  if (!nightly) return stable || null;
+  if (!stable) return nightly || null;
+  const nightlyVer = nightly.latest;
+  const stableVer = stable.latest;
+  if (import_semver.default.coerce(stableVer)?.version === import_semver.default.coerce(nightlyVer)?.version) {
+    return nightly;
+  }
+  return import_semver.default.gt(stableVer, nightlyVer) ? stable : nightly;
+}
+__name(getBestAvailableUpdate, "getBestAvailableUpdate");
+async function checkForUpdatesDetailed(fetchGlobalNpm = fetchGlobalNpmUpdateInfo) {
+  let currentVersion;
+  try {
+    if (process.env["DEV"] === "true") {
+      return { status: "skipped", reason: "development mode" };
+    }
+    const packageJson = await getPackageJson();
+    if (!packageJson || !packageJson.name || !packageJson.version) {
+      return { status: "skipped", reason: "package metadata unavailable" };
+    }
+    const { name, version } = packageJson;
+    currentVersion = version;
+    const isNightly = version.includes("nightly");
+    const createNotifier = /* @__PURE__ */ __name((distTag) => ({
+      fetchInfo: /* @__PURE__ */ __name(() => fetchGlobalNpm(name, version, distTag), "fetchInfo")
+    }), "createNotifier");
+    if (isNightly) {
+      const [nightlyUpdateInfo, latestUpdateInfo] = await Promise.all([
+        fetchInfoWithTimeout(
+          createNotifier("nightly"),
+          FETCH_TIMEOUT_MS,
+          "nightly"
+        ),
+        fetchInfoWithTimeout(
+          createNotifier("latest"),
+          FETCH_TIMEOUT_MS,
+          "latest"
+        )
+      ]);
+      debugLogger.debug(
+        `fetchInfo returned nightly=${JSON.stringify(nightlyUpdateInfo)} latest=${JSON.stringify(latestUpdateInfo)} for current=${version}`
+      );
+      const bestUpdate = getBestAvailableUpdate(
+        nightlyUpdateInfo,
+        latestUpdateInfo
+      );
+      if (bestUpdate && import_semver.default.gt(bestUpdate.latest, version)) {
+        return {
+          status: "update",
+          info: {
+            message: t(
+              "A new version of Qwen Code is available! {{current}} \u2192 {{latest}}",
+              { current: version, latest: bestUpdate.latest }
+            ),
+            update: { ...bestUpdate, current: version }
+          }
+        };
+      }
+    } else {
+      const updateInfo = await fetchInfoWithTimeout(
+        createNotifier("latest"),
+        FETCH_TIMEOUT_MS,
+        "latest"
+      );
+      debugLogger.debug(
+        `fetchInfo returned ${JSON.stringify(updateInfo)} for current=${version}`
+      );
+      if (updateInfo && import_semver.default.gt(updateInfo.latest, version)) {
+        return {
+          status: "update",
+          info: {
+            message: t("Qwen Code update available! {{current}} \u2192 {{latest}}", {
+              current: version,
+              latest: updateInfo.latest
+            }),
+            update: { ...updateInfo, current: version }
+          }
+        };
+      }
+    }
+    return { status: "up-to-date", currentVersion: version };
+  } catch (e) {
+    const error = e instanceof Error ? e : new Error(String(e));
+    debugLogger.warn("Failed to check for updates: " + error);
+    return { status: "error", error, currentVersion };
+  }
+}
+__name(checkForUpdatesDetailed, "checkForUpdatesDetailed");
+async function checkForUpdates(fetchGlobalNpm = fetchGlobalNpmUpdateInfo) {
+  const result = await checkForUpdatesDetailed(fetchGlobalNpm);
+  return result.status === "update" ? result.info : null;
+}
+__name(checkForUpdates, "checkForUpdates");
+
+export {
+  FETCH_TIMEOUT_MS,
+  UpdateCheckTimeoutError,
+  classifyUpdateCheckError,
+  describeUpdateCheckFailure,
+  runGlobalNpm,
+  fetchGlobalNpmUpdateInfo,
+  checkForUpdatesDetailed,
+  checkForUpdates
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-TB6UDU4T.js → chunk-THJNPLI4.js}

@@ -620,6 +620,16 @@ var init_context_api = __esm({
   }
 });
 
+// node_modules/@opentelemetry/api/build/esm/diag-api.js
+var diag;
+var init_diag_api = __esm({
+  "node_modules/@opentelemetry/api/build/esm/diag-api.js"() {
+    init_esbuild_shims();
+    init_diag();
+    diag = DiagAPI.instance();
+  }
+});
+
 // node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js
 var TraceFlags;
 var init_trace_flags = __esm({
@@ -1089,7 +1099,7 @@ function createBaggage(entries) {
 }
 function baggageEntryMetadataFromString(str) {
   if (typeof str !== "string") {
-    diag.error("Cannot create baggage metadata from unknown type: " + typeof str);
+    diag2.error("Cannot create baggage metadata from unknown type: " + typeof str);
     str = "";
   }
   return {
@@ -1099,14 +1109,14 @@ function baggageEntryMetadataFromString(str) {
     }, "toString")
   };
 }
-var diag;
+var diag2;
 var init_utils = __esm({
   "node_modules/@opentelemetry/api/build/esm/baggage/utils.js"() {
     init_esbuild_shims();
     init_diag();
     init_baggage_impl();
     init_symbol();
-    diag = DiagAPI.instance();
+    diag2 = DiagAPI.instance();
     __name(createBaggage, "createBaggage");
     __name(baggageEntryMetadataFromString, "baggageEntryMetadataFromString");
   }
@@ -1482,16 +1492,6 @@ var init_utils2 = __esm({
   }
 });
 
-// node_modules/@opentelemetry/api/build/esm/diag-api.js
-var diag2;
-var init_diag_api = __esm({
-  "node_modules/@opentelemetry/api/build/esm/diag-api.js"() {
-    init_esbuild_shims();
-    init_diag();
-    diag2 = DiagAPI.instance();
-  }
-});
-
 // node_modules/@opentelemetry/api/build/esm/metrics/NoopMeterProvider.js
 var NoopMeterProvider, NOOP_METER_PROVIDER;
 var init_NoopMeterProvider = __esm({
@@ -1701,7 +1701,7 @@ __export(esm_exports, {
   default: () => esm_default,
   defaultTextMapGetter: () => defaultTextMapGetter,
   defaultTextMapSetter: () => defaultTextMapSetter,
-  diag: () => diag2,
+  diag: () => diag,
   isSpanContextValid: () => isSpanContextValid,
   isValidSpanId: () => isValidSpanId,
   isValidTraceId: () => isValidTraceId,
@@ -1736,7 +1736,7 @@ var init_esm = __esm({
     init_trace_api();
     esm_default = {
       context,
-      diag: diag2,
+      diag,
       metrics,
       propagation,
       trace
@@ -1753,7 +1753,7 @@ export {
   SpanKind,
   SpanStatusCode,
   context,
-  diag2 as diag,
+  diag,
   metrics,
   propagation,
   trace,

package/chunks/{chunk-T4TZQJ7W.js → chunk-TWPJO254.js}

@@ -4,16 +4,14 @@ import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
 import {
-  __esm,
-  __export,
   __name
 } from "./chunk-J2S4EL5Y.js";
 
+// node_modules/strip-ansi/index.js
+init_esbuild_shims();
+
 // node_modules/ansi-regex/index.js
-var ansi_regex_exports = {};
-__export(ansi_regex_exports, {
-  default: () => ansiRegex
-});
+init_esbuild_shims();
 function ansiRegex({ onlyFirst = false } = {}) {
   const ST = "(?:\\u0007|\\u001B\\u005C|\\u009C)";
   const osc = `(?:\\u001B\\][\\s\\S]*?${ST})`;
@@ -21,16 +19,9 @@ function ansiRegex({ onlyFirst = false } = {}) {
   const pattern = `${osc}|${csi}`;
   return new RegExp(pattern, onlyFirst ? void 0 : "g");
 }
-var init_ansi_regex = __esm({
-  "node_modules/ansi-regex/index.js"() {
-    init_esbuild_shims();
-    __name(ansiRegex, "ansiRegex");
-  }
-});
+__name(ansiRegex, "ansiRegex");
 
 // node_modules/strip-ansi/index.js
-init_esbuild_shims();
-init_ansi_regex();
 var regex = ansiRegex();
 function stripAnsi(string) {
   if (typeof string !== "string") {
@@ -42,7 +33,5 @@ __name(stripAnsi, "stripAnsi");
 
 export {
   ansiRegex,
-  ansi_regex_exports,
-  init_ansi_regex,
   stripAnsi
 };