@qwen-code/qwen-code 0.21.1-simplify-system-prompt.0 → 0.21.2

package/chunks/{chunk-COH43MRJ.js → chunk-XCGIMOLN.js}

@@ -11,6 +11,8 @@ import {
 init_esbuild_shims();
 var DEFAULT_COMPACTED_REPLAY_MAX_BYTES = 4 * 1024 * 1024;
 var MAX_COMPACTED_REPLAY_MAX_BYTES = 256 * 1024 * 1024;
+var DEFAULT_MAX_JOURNAL_EVENTS = 1e4;
+var DEFAULT_MAX_JOURNAL_BYTES = 8 * 1024 * 1024;
 function normalizeCompactedReplayMaxBytes(value) {
   if (value === void 0) return DEFAULT_COMPACTED_REPLAY_MAX_BYTES;
   if (!Number.isSafeInteger(value) || value < 1 || value > MAX_COMPACTED_REPLAY_MAX_BYTES) {
@@ -21,11 +23,35 @@ function normalizeCompactedReplayMaxBytes(value) {
   return value;
 }
 __name(normalizeCompactedReplayMaxBytes, "normalizeCompactedReplayMaxBytes");
+function normalizeMaxJournalEvents(value) {
+  if (value === void 0) return DEFAULT_MAX_JOURNAL_EVENTS;
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new TypeError(
+      `Invalid maxJournalEvents: ${value}. Must be a positive safe integer.`
+    );
+  }
+  return value;
+}
+__name(normalizeMaxJournalEvents, "normalizeMaxJournalEvents");
+function normalizeMaxJournalBytes(value) {
+  if (value === void 0) return DEFAULT_MAX_JOURNAL_BYTES;
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new TypeError(
+      `Invalid maxJournalBytes: ${value}. Must be a positive safe integer.`
+    );
+  }
+  return value;
+}
+__name(normalizeMaxJournalBytes, "normalizeMaxJournalBytes");
 
 export {
   DEFAULT_COMPACTED_REPLAY_MAX_BYTES,
   MAX_COMPACTED_REPLAY_MAX_BYTES,
-  normalizeCompactedReplayMaxBytes
+  DEFAULT_MAX_JOURNAL_EVENTS,
+  DEFAULT_MAX_JOURNAL_BYTES,
+  normalizeCompactedReplayMaxBytes,
+  normalizeMaxJournalEvents,
+  normalizeMaxJournalBytes
 };
 /**
  * @license

package/chunks/{chunk-FY3M44RD.js → chunk-XP4L6KS3.js}

@@ -6,16 +6,16 @@ import {
   extractGeminiContent,
   extractOpenAiContent,
   stringifyGenAiJson
-} from "./chunk-SQBYH7PX.js";
+} from "./chunk-QDK4F2N5.js";
 import {
   createDebugLogger
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-E2BHWIDT.js";
 import {
   ROOT_CONTEXT,
   context,
   createContextKey,
   init_esm
-} from "./chunk-TARRHLLG.js";
+} from "./chunk-QUGAUQGJ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-6FGBXPWM.js → chunk-XQK4XXTN.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getErrorStatus
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-E2BHWIDT.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -20,45 +20,6 @@ function isStructuredError(error) {
   return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
 }
 __name(isStructuredError, "isStructuredError");
-function isProQuotaExceededError(error) {
-  const checkMessage = /* @__PURE__ */ __name((message) => message.includes("Quota exceeded for quota metric 'Gemini") && message.includes("Pro Requests'"), "checkMessage");
-  if (typeof error === "string") {
-    return checkMessage(error);
-  }
-  if (isStructuredError(error)) {
-    return checkMessage(error.message);
-  }
-  if (isApiError(error)) {
-    return checkMessage(error.error.message);
-  }
-  if (error && typeof error === "object" && "response" in error) {
-    const gaxiosError = error;
-    if (gaxiosError.response && gaxiosError.response.data) {
-      if (typeof gaxiosError.response.data === "string") {
-        return checkMessage(gaxiosError.response.data);
-      }
-      if (typeof gaxiosError.response.data === "object" && gaxiosError.response.data !== null && "error" in gaxiosError.response.data) {
-        const errorData = gaxiosError.response.data;
-        return checkMessage(errorData.error?.message || "");
-      }
-    }
-  }
-  return false;
-}
-__name(isProQuotaExceededError, "isProQuotaExceededError");
-function isGenericQuotaExceededError(error) {
-  if (typeof error === "string") {
-    return error.includes("Quota exceeded for quota metric");
-  }
-  if (isStructuredError(error)) {
-    return error.message.includes("Quota exceeded for quota metric");
-  }
-  if (isApiError(error)) {
-    return error.error.message.includes("Quota exceeded for quota metric");
-  }
-  return false;
-}
-__name(isGenericQuotaExceededError, "isGenericQuotaExceededError");
 function isQwenQuotaExceededError(error) {
   if (typeof error !== "object" || error === null) {
     return false;
@@ -67,9 +28,40 @@ function isQwenQuotaExceededError(error) {
   return status === 429 && code === "insufficient_quota" && typeof message === "string" && message.toLowerCase().includes("free allocated quota exceeded");
 }
 __name(isQwenQuotaExceededError, "isQwenQuotaExceededError");
+var QUOTA_EXHAUSTED_PREFIX = "Quota exhausted: ";
+function getQuotaMessage(error) {
+  let message = null;
+  if (typeof error === "string") message = error;
+  else if (isStructuredError(error)) message = error.message;
+  else if (isApiError(error)) message = error.error.message;
+  if (message === null) return null;
+  const start = message.indexOf("{");
+  if (start !== -1) {
+    try {
+      const parsed = JSON.parse(message.substring(start));
+      if (isApiError(parsed)) return parsed.error.message;
+    } catch {
+    }
+  }
+  return message;
+}
+__name(getQuotaMessage, "getQuotaMessage");
+function isQuotaExhaustedError(error) {
+  const message = getQuotaMessage(error);
+  if (!message) return false;
+  const lower = message.toLowerCase();
+  return lower.includes("quota") && (lower.includes("exhausted") || lower.includes("exceeded")) && (lower.includes("will reset") || lower.includes("reset at"));
+}
+__name(isQuotaExhaustedError, "isQuotaExhaustedError");
+function formatQuotaExhaustedMessage(error) {
+  const raw = getQuotaMessage(error) ?? "";
+  if (raw.startsWith(QUOTA_EXHAUSTED_PREFIX)) return raw;
+  const stripped = raw.replace(/^\d{3}\s+/, "").trim() || "quota has been exhausted";
+  return `${QUOTA_EXHAUSTED_PREFIX}${stripped}
 
-// packages/core/src/utils/rateLimit.ts
-init_esbuild_shims();
+Please retry after the reset time, or switch to another API key / auth method.`;
+}
+__name(formatQuotaExhaustedMessage, "formatQuotaExhaustedMessage");
 
 // packages/core/src/utils/retryPolicy.ts
 init_esbuild_shims();
@@ -149,6 +141,7 @@ function hasResponseHeaders(error) {
 __name(hasResponseHeaders, "hasResponseHeaders");
 
 // packages/core/src/utils/rateLimit.ts
+init_esbuild_shims();
 var RATE_LIMIT_ERROR_CODES = /* @__PURE__ */ new Set([429, 503, 1302, 1305]);
 function isRateLimitError(error, extraCodes) {
   const code = getErrorCode(error);
@@ -272,9 +265,10 @@ __name(getRawErrorMessage, "getRawErrorMessage");
 export {
   isApiError,
   isStructuredError,
-  isProQuotaExceededError,
-  isGenericQuotaExceededError,
   isQwenQuotaExceededError,
+  QUOTA_EXHAUSTED_PREFIX,
+  isQuotaExhaustedError,
+  formatQuotaExhaustedMessage,
   getRetryDelayMs,
   getRetryAfterDelayMs,
   isRateLimitError,

package/chunks/{chunk-A6UO2C7C.js → chunk-XUGZYLDH.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   MissingCliEntryError
-} from "./chunk-KU5XMLDK.js";
+} from "./chunk-GURGAJTX.js";
 import {
   redactLogCredentials
 } from "./chunk-M5GB774H.js";
@@ -125,6 +125,144 @@ function callHook(hook, value) {
 }
 __name(callHook, "callHook");
 
+// packages/acp-bridge/src/process-registry.ts
+init_esbuild_shims();
+var TERM_GRACE_MS = 5e3;
+var EXIT_DEADLINE_MS = 1e4;
+var ProcessRegistry = class {
+  static {
+    __name(this, "ProcessRegistry");
+  }
+  reservations = /* @__PURE__ */ new Set();
+  children = /* @__PURE__ */ new Set();
+  draining = false;
+  shutdownPromise;
+  reserve() {
+    if (this.draining) {
+      throw new Error("ACP process registry is draining");
+    }
+    const token = Symbol("acp-child");
+    this.reservations.add(token);
+    let settled = false;
+    return {
+      attach: /* @__PURE__ */ __name((child) => {
+        if (settled || !this.reservations.delete(token)) {
+          throw new Error("ACP process reservation is no longer active");
+        }
+        settled = true;
+        const tracked = new TrackedChild(child, () => {
+          this.children.delete(tracked);
+        });
+        this.children.add(tracked);
+        if (this.draining) void tracked.terminate().catch(() => {
+        });
+        return tracked;
+      }, "attach"),
+      cancel: /* @__PURE__ */ __name(() => {
+        if (settled) return;
+        settled = true;
+        this.reservations.delete(token);
+      }, "cancel")
+    };
+  }
+  shutdown() {
+    if (this.shutdownPromise) return this.shutdownPromise;
+    this.draining = true;
+    this.shutdownPromise = Promise.allSettled(
+      [...this.children].map((child) => child.terminate())
+    ).then((results) => {
+      const failures = results.flatMap(
+        (result) => result.status === "rejected" ? [result.reason] : []
+      );
+      if (failures.length > 0) {
+        throw new AggregateError(failures, "ACP child process shutdown failed");
+      }
+    });
+    return this.shutdownPromise;
+  }
+  killAllSync() {
+    this.draining = true;
+    for (const child of this.children) child.killSync();
+  }
+  get activeProcessCount() {
+    return this.children.size;
+  }
+};
+var TrackedChild = class {
+  constructor(child, onExit) {
+    this.child = child;
+    this.onExit = onExit;
+    this.exited = new Promise((resolve) => {
+      const finish = /* @__PURE__ */ __name((info) => {
+        if (this.exitedSettled) return;
+        this.exitedSettled = true;
+        this.onExit();
+        resolve(info);
+      }, "finish");
+      child.once("exit", (exitCode, signalCode) => {
+        finish({ exitCode, signalCode });
+      });
+      child.once("spawn", () => {
+        this.spawnConfirmed = true;
+      });
+      child.once("error", () => {
+        if (!this.spawnConfirmed) finish(void 0);
+      });
+    });
+  }
+  static {
+    __name(this, "TrackedChild");
+  }
+  exited;
+  exitedSettled = false;
+  spawnConfirmed = false;
+  terminatePromise;
+  terminate() {
+    this.terminatePromise ??= this.terminateOnce();
+    return this.terminatePromise;
+  }
+  killSync() {
+    if (this.exitedSettled) return;
+    try {
+      this.child.kill("SIGKILL");
+    } catch {
+    }
+  }
+  async terminateOnce() {
+    if (this.exitedSettled) return;
+    try {
+      this.child.kill("SIGTERM");
+    } catch {
+      if (this.exitedSettled) return;
+    }
+    let hardKillTimer;
+    let deadlineTimer;
+    const deadline = new Promise((_, reject) => {
+      hardKillTimer = setTimeout(() => this.killSync(), TERM_GRACE_MS);
+      hardKillTimer.unref();
+      deadlineTimer = setTimeout(() => {
+        reject(
+          new Error(
+            `ACP child pid=${this.child.pid ?? "unknown"} did not exit within ${EXIT_DEADLINE_MS}ms`
+          )
+        );
+      }, EXIT_DEADLINE_MS);
+      deadlineTimer.unref();
+    });
+    try {
+      const exitInfo = await Promise.race([this.exited, deadline]);
+      if (exitInfo && (exitInfo.exitCode !== 0 || exitInfo.signalCode !== null)) {
+        throw new Error(
+          `ACP child pid=${this.child.pid ?? "unknown"} exited uncleanly during shutdown (code=${exitInfo.exitCode ?? "none"}, signal=${exitInfo.signalCode ?? "none"})`
+        );
+      }
+    } finally {
+      if (hardKillTimer) clearTimeout(hardKillTimer);
+      if (deadlineTimer) clearTimeout(deadlineTimer);
+    }
+  }
+};
+
 // packages/acp-bridge/src/spawnChannel.ts
 var cachedMemoryArgs;
 function getAcpMemoryArgs() {
@@ -178,6 +316,7 @@ function createStderrForwarder(opts) {
 }
 __name(createStderrForwarder, "createStderrForwarder");
 function createSpawnChannelFactory(options = {}) {
+  const processRegistry = options.processRegistry ?? new ProcessRegistry();
   return async (workspaceCwd, childEnvOverrides) => {
     const sourceEnv = options.sourceEnv ?? process.env;
     const cliEntry = sourceEnv["QWEN_CLI_ENTRY"] || process.argv[1];
@@ -194,21 +333,29 @@ function createSpawnChannelFactory(options = {}) {
     const execArgs = process.execArgv.filter(
       (a) => !/^--inspect(-brk)?($|=)/.test(a)
     );
-    const child = spawn(
-      process.execPath,
-      [
-        ...execArgs,
-        ...memoryArgs,
-        cliEntry,
-        "--acp",
-        ...options.extraArgs ?? []
-      ],
-      {
-        cwd: workspaceCwd,
-        stdio: ["pipe", "pipe", "pipe"],
-        env: childEnv
-      }
-    );
+    const reservation = processRegistry.reserve();
+    let child;
+    try {
+      child = spawn(
+        process.execPath,
+        [
+          ...execArgs,
+          ...memoryArgs,
+          cliEntry,
+          "--acp",
+          ...options.extraArgs ?? []
+        ],
+        {
+          cwd: workspaceCwd,
+          stdio: ["pipe", "pipe", "pipe"],
+          env: childEnv
+        }
+      );
+    } catch (error) {
+      reservation.cancel();
+      throw error;
+    }
+    const trackedChild = reservation.attach(child);
     if (child.stderr) {
       const prefix = `[serve pid=${child.pid} cwd=${workspaceCwd}] `;
       const forwarder = createStderrForwarder({
@@ -221,21 +368,8 @@ function createSpawnChannelFactory(options = {}) {
       child.stderr.on("error", () => {
       });
     }
-    const exited = new Promise((resolve) => {
-      let resolved = false;
-      const finish = /* @__PURE__ */ __name((info) => {
-        if (resolved) return;
-        resolved = true;
-        resolve(info);
-      }, "finish");
-      child.once(
-        "exit",
-        (code, signal) => finish({ exitCode: code, signalCode: signal })
-      );
-      child.once("error", () => finish(void 0));
-    });
     if (!child.stdin || !child.stdout) {
-      child.kill("SIGKILL");
+      trackedChild.killSync();
       throw new Error(
         "Spawned ACP child has no stdin/stdout \u2014 cannot establish NDJSON channel."
       );
@@ -245,22 +379,14 @@ function createSpawnChannelFactory(options = {}) {
     const stream = ndJsonStream(writable, readable, options.pipeHooks);
     return {
       stream,
-      kill: /* @__PURE__ */ __name(() => killChild(child), "kill"),
-      killSync: /* @__PURE__ */ __name(() => {
-        if (child.exitCode === null && child.signalCode === null) {
-          try {
-            child.kill("SIGKILL");
-          } catch {
-          }
-        }
-      }, "killSync"),
-      exited
+      kill: /* @__PURE__ */ __name(() => trackedChild.terminate(), "kill"),
+      killSync: /* @__PURE__ */ __name(() => trackedChild.killSync(), "killSync"),
+      exited: trackedChild.exited
     };
   };
 }
 __name(createSpawnChannelFactory, "createSpawnChannelFactory");
 var defaultSpawnChannelFactory = createSpawnChannelFactory();
-var KILL_HARD_DEADLINE_MS = 1e4;
 var SCRUBBED_CHILD_ENV_KEYS = /* @__PURE__ */ new Set([
   "QWEN_SERVER_TOKEN",
   "QWEN_CODE_SIMPLE"
@@ -283,46 +409,6 @@ function scrubChildEnv(source, scrubbed, overrides) {
   return childEnv;
 }
 __name(scrubChildEnv, "scrubChildEnv");
-function killChild(child) {
-  return new Promise((resolve) => {
-    if (child.exitCode !== null || child.signalCode !== null) {
-      resolve();
-      return;
-    }
-    let resolved = false;
-    const finish = /* @__PURE__ */ __name(() => {
-      if (resolved) return;
-      resolved = true;
-      child.removeListener("exit", finish);
-      resolve();
-    }, "finish");
-    child.once("exit", finish);
-    try {
-      child.kill("SIGTERM");
-    } catch {
-      finish();
-      return;
-    }
-    setTimeout(() => {
-      if (!resolved && child.exitCode === null && child.signalCode === null) {
-        try {
-          child.kill("SIGKILL");
-        } catch {
-        }
-      }
-    }, 5e3).unref();
-    setTimeout(() => {
-      if (!resolved) {
-        process.stderr.write(
-          `qwen serve: killChild hard deadline (${KILL_HARD_DEADLINE_MS}ms) reached; child pid=${child.pid} still alive (uninterruptible sleep?) \u2014 abandoning. Operator should check for zombie qwen --acp processes holding workspace resources.
-`
-        );
-        finish();
-      }
-    }, KILL_HARD_DEADLINE_MS).unref();
-  });
-}
-__name(killChild, "killChild");
 
 export {
   ndJsonStream,

package/chunks/{chunk-LZEMEFKY.js → chunk-YANIWTRZ.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   parseRule
-} from "./chunk-DM4Q4JJH.js";
+} from "./chunk-54YCNSK5.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-IPUUTYMV.js → chunk-YDLJGZHL.js}

@@ -122,7 +122,7 @@ function wrapToVisualLines(text, width) {
     let currentLine = "";
     let currentWidth = 0;
     for (const char of logicalLine) {
-      const charWidth = getCachedStringWidth(char);
+      const charWidth = Math.max(getCachedStringWidth(char), 1);
       if (currentWidth + charWidth > width && currentWidth > 0) {
         visualLines.push(currentLine);
         currentLine = "";

package/chunks/{chunk-HIJQF5B5.js → chunk-YGE3IXJP.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   CHANNEL_STARTUP_PROFILE_VERSION
-} from "./chunk-3SJ43L4W.js";
+} from "./chunk-CPZAH673.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-BJX6ZSUK.js → chunk-YUFIEIWC.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   escapeAnsiCtrlCodes
-} from "./chunk-IPUUTYMV.js";
+} from "./chunk-YDLJGZHL.js";
 import {
   createDebugLogger
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-E2BHWIDT.js";
 import {
   wrapper_default
 } from "./chunk-TYAMGABM.js";