@qwen-code/qwen-code 0.20.2-jobbench-no-todo-write.0 → 0.21.0

package/chunks/chunk-2SCDWPXI.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-ZNAUOR2I.js";
+import {
+  t
+} from "./chunk-LKEJ26GS.js";
+import {
+  getPackageJson
+} from "./chunk-VJNBRRZG.js";
+import {
+  createDebugLogger
+} from "./chunk-NL7LTRLR.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-JK26TQON.js → chunk-2X55UKQE.js}

@@ -2,16 +2,16 @@
 "use strict";
 import {
   useKeypress
-} from "./chunk-6VPLV3L3.js";
+} from "./chunk-LQIW3YFY.js";
 import {
   require_react
 } from "./chunk-5QWWOFGG.js";
 import {
   t
-} from "./chunk-V7WNRZL7.js";
+} from "./chunk-LKEJ26GS.js";
 import {
   APPROVAL_MODES
-} from "./chunk-WHGVTP7Q.js";
+} from "./chunk-L26JL52R.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-7VUQQBR7.js → chunk-3QMGYBFN.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-NL7LTRLR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -456,68 +456,6 @@ function detectTodoChanges(oldTodos, newTodos) {
 }
 __name(detectTodoChanges, "detectTodoChanges");
 
-// packages/core/src/hooks/registerSkillHooks.ts
-init_esbuild_shims();
-var debugLogger2 = createDebugLogger("SKILL_HOOKS");
-function registerSkillHooks(sessionHooksManager, sessionId, skill) {
-  if (!skill.hooks) {
-    debugLogger2.debug(`Skill '${skill.name}' has no hooks to register`);
-    return 0;
-  }
-  const hooksSettings = skill.hooks;
-  let registeredCount = 0;
-  for (const eventName of Object.keys(hooksSettings)) {
-    const matchers = hooksSettings[eventName];
-    if (!matchers) continue;
-    for (const matcher of matchers) {
-      const matcherPattern = matcher.matcher || "";
-      for (const hook of matcher.hooks) {
-        if (hook.type === "function" /* Function */) {
-          debugLogger2.debug(
-            "Skipping function hook from skill (not supported in frontmatter)"
-          );
-          continue;
-        }
-        const hookConfig = prepareHookConfig(
-          hook,
-          skill.skillRoot
-        );
-        sessionHooksManager.addSessionHook(
-          sessionId,
-          eventName,
-          matcherPattern,
-          hookConfig,
-          { skillRoot: skill.skillRoot }
-        );
-        registeredCount++;
-        debugLogger2.debug(
-          `Registered hook for ${eventName} with matcher '${matcherPattern}' from skill '${skill.name}'`
-        );
-      }
-    }
-  }
-  if (registeredCount > 0) {
-    debugLogger2.info(
-      `Registered ${registeredCount} hooks from skill '${skill.name}'`
-    );
-  }
-  return registeredCount;
-}
-__name(registerSkillHooks, "registerSkillHooks");
-function prepareHookConfig(hook, skillRoot) {
-  if (hook.type === "command" && skillRoot) {
-    return {
-      ...hook,
-      env: {
-        ...hook.env,
-        QWEN_SKILL_ROOT: skillRoot
-      }
-    };
-  }
-  return hook;
-}
-__name(prepareHookConfig, "prepareHookConfig");
-
 export {
   HooksConfigSource,
   HookEventName,
@@ -544,8 +482,7 @@ export {
   PreCompactTrigger,
   PostCompactTrigger,
   AgentType,
-  detectTodoChanges,
-  registerSkillHooks
+  detectTodoChanges
 };
 /**
  * @license

package/chunks/{chunk-UMCULC5M.js → chunk-3RN6GBKS.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   BaseJsonOutputAdapter
-} from "./chunk-7TLUW4ZE.js";
+} from "./chunk-BKHWX6I2.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-QR6U5QPP.js → chunk-3SJ43L4W.js}

@@ -13,8 +13,10 @@ var LOAD_REPLAY_BULK_MODE = "bulk";
 var LOAD_REPLAY_VERSION = 1;
 var CHANNEL_STARTUP_PROFILE_META_KEY = "qwen.daemon.channelStartupProfile";
 var CHANNEL_STARTUP_PROFILE_VERSION = 1;
+var DAEMON_CHANNEL_DELIVERY_META_KEY = "qwen.daemon.channelDelivery";
 var MID_TURN_QUEUE_DRAIN_METHOD = "craft/drainMidTurnQueue";
 var TODO_STOP_GUARD_QUEUE_RELEASE_METHOD = "craft/todoStopGuardQueueReleased";
+var PROMPT_CANCEL_METHOD = "craft/cancelPendingPrompt";
 var CLIENT_MCP_OVER_WS_CONFIG_FLAG = "__clientMcpOverWs";
 
 export {
@@ -25,8 +27,10 @@ export {
   LOAD_REPLAY_VERSION,
   CHANNEL_STARTUP_PROFILE_META_KEY,
   CHANNEL_STARTUP_PROFILE_VERSION,
+  DAEMON_CHANNEL_DELIVERY_META_KEY,
   MID_TURN_QUEUE_DRAIN_METHOD,
   TODO_STOP_GUARD_QUEUE_RELEASE_METHOD,
+  PROMPT_CANCEL_METHOD,
   CLIENT_MCP_OVER_WS_CONFIG_FLAG
 };
 /**

package/chunks/chunk-46UV252V.js

@@ -0,0 +1,128 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/utils/request-tokenizer/textTokenizer.ts
+init_esbuild_shims();
+var NON_ASCII_RE = /[\u0080-\uffff]/;
+var TOKEN_ESTIMATE_UNITS_PER_TOKEN = 20;
+function estimateTextTokens(text) {
+  if (!text || text.length === 0) {
+    return 0;
+  }
+  if (!NON_ASCII_RE.test(text)) {
+    return Math.ceil(text.length / 4);
+  }
+  const nonAsciiChars = countNonAsciiChars(text);
+  const asciiChars = text.length - nonAsciiChars;
+  return Math.ceil(asciiChars / 4 + nonAsciiChars * 1.1);
+}
+__name(estimateTextTokens, "estimateTextTokens");
+function estimateTextTokenUnits(text) {
+  if (!text || text.length === 0) {
+    return 0;
+  }
+  if (!NON_ASCII_RE.test(text)) {
+    return text.length * 5;
+  }
+  const nonAsciiChars = countNonAsciiChars(text);
+  const asciiChars = text.length - nonAsciiChars;
+  return asciiChars * 5 + nonAsciiChars * 22;
+}
+__name(estimateTextTokenUnits, "estimateTextTokenUnits");
+function countNonAsciiChars(text) {
+  let count = 0;
+  for (let i = 0; i < text.length; i++) {
+    if (text.charCodeAt(i) >= 128) {
+      count++;
+    }
+  }
+  return count;
+}
+__name(countNonAsciiChars, "countNonAsciiChars");
+var TextTokenizer = class {
+  static {
+    __name(this, "TextTokenizer");
+  }
+  /**
+   * Calculate tokens for text content
+   *
+   * @param text - The text to estimate tokens for
+   * @returns The estimated token count
+   */
+  async calculateTokens(text) {
+    return this.calculateTokensSync(text);
+  }
+  /**
+   * Calculate tokens for multiple text strings
+   *
+   * @param texts - Array of text strings to estimate tokens for
+   * @returns Array of token counts corresponding to each input text
+   */
+  async calculateTokensBatch(texts) {
+    return texts.map((text) => this.calculateTokensSync(text));
+  }
+  calculateTokensSync(text) {
+    return estimateTextTokens(text);
+  }
+};
+
+// packages/core/src/utils/tool-name-utils.ts
+init_esbuild_shims();
+var MAX_TOOL_NAME_LENGTH = 63;
+var PROVIDER_SAFE_TOOL_NAME = /^[A-Za-z][A-Za-z0-9_-]*$/;
+function normalizeToolNameForProvider(name) {
+  if (name.length <= MAX_TOOL_NAME_LENGTH && PROVIDER_SAFE_TOOL_NAME.test(name)) {
+    return name;
+  }
+  const normalized = sanitizeToolNameForProvider(name);
+  const suffix = `_${stableToolNameHash(name)}`;
+  return `${normalized.slice(0, MAX_TOOL_NAME_LENGTH - suffix.length)}${suffix}`;
+}
+__name(normalizeToolNameForProvider, "normalizeToolNameForProvider");
+function sanitizeToolNameForProvider(name) {
+  const sanitized = name.replace(/[^A-Za-z0-9_-]/g, "_");
+  return /^[A-Za-z]/.test(sanitized) ? sanitized : `tool_${sanitized}`;
+}
+__name(sanitizeToolNameForProvider, "sanitizeToolNameForProvider");
+function normalizeMcpToolName(name) {
+  return name.startsWith("mcp__") ? normalizeToolNameForProvider(name) : name;
+}
+__name(normalizeMcpToolName, "normalizeMcpToolName");
+function generateLegacyMcpToolName(name) {
+  let legacyName = name.replace(/[^A-Za-z0-9_.-]/g, "_");
+  if (legacyName.length > MAX_TOOL_NAME_LENGTH) {
+    legacyName = legacyName.slice(0, 28) + "___" + legacyName.slice(-32);
+  }
+  return legacyName;
+}
+__name(generateLegacyMcpToolName, "generateLegacyMcpToolName");
+function stableToolNameHash(name) {
+  let hash = 2166136261;
+  for (let index = 0; index < name.length; index += 1) {
+    hash = Math.imul(hash ^ name.charCodeAt(index), 16777619);
+  }
+  return (hash >>> 0).toString(36).padStart(7, "0");
+}
+__name(stableToolNameHash, "stableToolNameHash");
+
+export {
+  TOKEN_ESTIMATE_UNITS_PER_TOKEN,
+  estimateTextTokens,
+  estimateTextTokenUnits,
+  TextTokenizer,
+  normalizeToolNameForProvider,
+  sanitizeToolNameForProvider,
+  normalizeMcpToolName,
+  generateLegacyMcpToolName
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-GPMVHZP4.js → chunk-4WIZGAH3.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   resolveChannelCwd
-} from "./chunk-6ZBPS62S.js";
+} from "./chunk-7ZCNENPP.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -21,12 +21,12 @@ function ensureBuiltins() {
   if (!builtinsPromise) {
     builtinsPromise = (async () => {
       const labelled = [
-        { name: "telegram", promise: import("./dist-XBJVSWS2.js") },
-        { name: "weixin", promise: import("./dist-UIFWIFRO.js") },
-        { name: "dingtalk", promise: import("./dist-XRYV6TJP.js") },
-        { name: "wecom", promise: import("./dist-OAV7LJGJ.js") },
-        { name: "feishu", promise: import("./dist-OMW6WDEO.js") },
-        { name: "qqbot", promise: import("./dist-PJLG2XYX.js") }
+        { name: "telegram", promise: import("./dist-BBLXMS3N.js") },
+        { name: "weixin", promise: import("./dist-46NQKLTW.js") },
+        { name: "dingtalk", promise: import("./dist-AIKFMUKK.js") },
+        { name: "wecom", promise: import("./dist-YFNEUWSE.js") },
+        { name: "feishu", promise: import("./dist-F6IBUDR4.js") },
+        { name: "qqbot", promise: import("./dist-WEAHOXDM.js") }
       ];
       const results = await Promise.allSettled(labelled.map((l) => l.promise));
       for (let i = 0; i < results.length; i++) {