@qwen-code/qwen-code 0.18.0-preview.2 → 0.18.1-nightly.20260616.a68b2e1e7

package/chunks/chunk-SFRV6BGY.js

@@ -0,0 +1,243 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getInboxesDir,
+  require_proper_lockfile
+} from "./chunk-WPTCDQN6.js";
+import {
+  Mutex
+} from "./chunk-OMX7CUOE.js";
+import {
+  atomicWriteJSON
+} from "./chunk-LXYWINWF.js";
+import {
+  createDebugLogger,
+  isNodeError
+} from "./chunk-HA2UEYZP.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/agents/team/leaderPermissionBridge.ts
+init_esbuild_shims();
+var leaderCallbacks = null;
+function registerLeader(callbacks) {
+  leaderCallbacks = callbacks;
+}
+__name(registerLeader, "registerLeader");
+function getLeader() {
+  return leaderCallbacks;
+}
+__name(getLeader, "getLeader");
+function unregisterLeader() {
+  leaderCallbacks = null;
+}
+__name(unregisterLeader, "unregisterLeader");
+function forwardApproval(teammateName, teammateColor, details) {
+  if (!leaderCallbacks) {
+    return false;
+  }
+  leaderCallbacks.enqueueApproval({
+    teammateName,
+    teammateColor,
+    details
+  });
+  return true;
+}
+__name(forwardApproval, "forwardApproval");
+function wrapConfirmWithBadge(original, teammateName, respond, _teammateColor) {
+  return {
+    ...original,
+    title: `[${teammateName}] ${original.title}`,
+    onConfirm: /* @__PURE__ */ __name(async (outcome, payload) => {
+      await respond(outcome, payload);
+    }, "onConfirm")
+  };
+}
+__name(wrapConfirmWithBadge, "wrapConfirmWithBadge");
+
+// packages/core/src/agents/team/mailbox.ts
+init_esbuild_shims();
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+var debug = createDebugLogger("AGENTS_TEAM_MAILBOX");
+var LOCK_OPTIONS = {
+  retries: {
+    retries: 10,
+    minTimeout: 5,
+    maxTimeout: 100,
+    factor: 2,
+    // Jitter the backoff so cross-process contenders don't retry in
+    // lockstep (thundering herd) and starve each other out of the
+    // retry budget.
+    randomize: true
+  },
+  stale: 5e3,
+  // Stale locks from crashed processes are expected in multi-agent
+  // scenarios; log at debug level for traceability without noise.
+  onCompromised: /* @__PURE__ */ __name((err) => {
+    debug.debug("mailbox lock compromised:", err?.message ?? err);
+  }, "onCompromised")
+};
+var inboxLocks = /* @__PURE__ */ new Map();
+function getInboxLock(inboxPath) {
+  let lock = inboxLocks.get(inboxPath);
+  if (!lock) {
+    lock = new Mutex();
+    inboxLocks.set(inboxPath, lock);
+  }
+  return lock;
+}
+__name(getInboxLock, "getInboxLock");
+function disposeInboxLocks(teamName) {
+  const dir = getInboxesDir(teamName);
+  let evicted = 0;
+  for (const key of inboxLocks.keys()) {
+    if (path.dirname(key) === dir) {
+      inboxLocks.delete(key);
+      evicted++;
+    }
+  }
+  return evicted;
+}
+__name(disposeInboxLocks, "disposeInboxLocks");
+async function withInboxLock(inboxPath, fn) {
+  return getInboxLock(inboxPath).runExclusive(async () => {
+    const release = await import_proper_lockfile.default.lock(inboxPath, LOCK_OPTIONS);
+    try {
+      return await fn();
+    } finally {
+      await release();
+    }
+  });
+}
+__name(withInboxLock, "withInboxLock");
+function getInboxPath(teamName, agentName) {
+  return path.join(getInboxesDir(teamName), `${agentName}.json`);
+}
+__name(getInboxPath, "getInboxPath");
+async function readInbox(teamName, agentName) {
+  const inboxPath = getInboxPath(teamName, agentName);
+  try {
+    const raw = await fs.readFile(inboxPath, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") return [];
+    throw err;
+  }
+}
+__name(readInbox, "readInbox");
+var READ_RETENTION_MS = 5 * 60 * 1e3;
+async function writeMessage(teamName, toAgentName, message) {
+  const inboxPath = getInboxPath(teamName, toAgentName);
+  await ensureInboxFile(inboxPath);
+  await withInboxLock(inboxPath, async () => {
+    const messages = await readInboxRaw(inboxPath);
+    const cutoff = Date.now() - READ_RETENTION_MS;
+    const compacted = messages.filter((m) => {
+      if (!m.read) return true;
+      const ts = Date.parse(m.timestamp);
+      return Number.isNaN(ts) || ts >= cutoff;
+    });
+    compacted.push(message);
+    await atomicWriteJSON(inboxPath, compacted);
+  });
+}
+__name(writeMessage, "writeMessage");
+async function consumeUnread(teamName, agentName, type) {
+  const inboxPath = getInboxPath(teamName, agentName);
+  await ensureInboxFile(inboxPath);
+  return withInboxLock(inboxPath, async () => {
+    const messages = await readInboxRaw(inboxPath);
+    const predicate = /* @__PURE__ */ __name((m) => !m.read && (type === void 0 || m.type === type), "predicate");
+    const matching = messages.filter(predicate);
+    if (matching.length === 0) return [];
+    const updated = messages.map(
+      (m) => predicate(m) ? { ...m, read: true } : m
+    );
+    await atomicWriteJSON(inboxPath, updated);
+    return matching;
+  });
+}
+__name(consumeUnread, "consumeUnread");
+async function clearInbox(teamName, agentName) {
+  const inboxPath = getInboxPath(teamName, agentName);
+  try {
+    await fs.unlink(inboxPath);
+  } catch (err) {
+    if (!isNodeError(err) || err.code !== "ENOENT") throw err;
+  }
+}
+__name(clearInbox, "clearInbox");
+async function clearAllInboxes(teamName) {
+  const dir = getInboxesDir(teamName);
+  await fs.rm(dir, { recursive: true, force: true });
+  disposeInboxLocks(teamName);
+}
+__name(clearAllInboxes, "clearAllInboxes");
+async function sendStructuredMessage(teamName, toAgentName, opts) {
+  await writeMessage(teamName, toAgentName, {
+    from: opts.from,
+    text: opts.text,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    read: false,
+    type: opts.type,
+    color: opts.color,
+    summary: opts.summary
+  });
+}
+__name(sendStructuredMessage, "sendStructuredMessage");
+async function ensureInboxFile(inboxPath) {
+  await fs.mkdir(path.dirname(inboxPath), { recursive: true });
+  try {
+    await fs.writeFile(inboxPath, "[]\n", { flag: "wx" });
+  } catch (err) {
+    if (!isNodeError(err) || err.code !== "EEXIST") throw err;
+  }
+}
+__name(ensureInboxFile, "ensureInboxFile");
+async function readInboxRaw(inboxPath) {
+  try {
+    const raw = await fs.readFile(inboxPath, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    if (isNodeError(err) && err.code === "ENOENT") return [];
+    const errMsg = err instanceof Error ? err.message : String(err);
+    debug.warn(`Quarantining corrupt inbox at ${inboxPath}: ${errMsg}`);
+    try {
+      await fs.rename(inboxPath, `${inboxPath}.corrupt-${Date.now()}`);
+    } catch (renameErr) {
+      const renameMsg = renameErr instanceof Error ? renameErr.message : String(renameErr);
+      debug.warn(`Failed to quarantine ${inboxPath}: ${renameMsg}`);
+      throw err instanceof Error ? err : new Error(`Failed to read inbox at ${inboxPath}: ${errMsg}`);
+    }
+    return [];
+  }
+}
+__name(readInboxRaw, "readInboxRaw");
+
+export {
+  registerLeader,
+  getLeader,
+  unregisterLeader,
+  forwardApproval,
+  wrapConfirmWithBadge,
+  disposeInboxLocks,
+  getInboxPath,
+  readInbox,
+  writeMessage,
+  consumeUnread,
+  clearInbox,
+  clearAllInboxes,
+  sendStructuredMessage
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-NW5QBUYO.js → chunk-TSBXGR73.js}

@@ -2,24 +2,24 @@
 "use strict";
 import {
   t
-} from "./chunk-7YKXFA3D.js";
+} from "./chunk-UOB6KPGG.js";
 import {
   computeThresholds,
   getCoreSystemPrompt
-} from "./chunk-QCG6KPNM.js";
+} from "./chunk-H4ZDM3N6.js";
 import {
   buildSkillLlmContent
-} from "./chunk-ICOI4E4S.js";
+} from "./chunk-CPVI5J2L.js";
 import {
   DiscoveredMCPTool,
   uiTelemetryService
-} from "./chunk-ZK4AMNIU.js";
+} from "./chunk-A3OEZT2F.js";
 import {
   ToolNames
-} from "./chunk-2ZTWI7KH.js";
+} from "./chunk-6WPY6ES3.js";
 import {
   DEFAULT_TOKEN_LIMIT
-} from "./chunk-Y7R6H6FT.js";
+} from "./chunk-LYSND7KR.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -752,7 +752,7 @@ function fmtTokens(tokens) {
 }
 __name(fmtTokens, "fmtTokens");
 function fmtCategoryRow(label, tokens, contextWindowSize, indent = "  ") {
-  const percentage = (tokens / contextWindowSize * 100).toFixed(1);
+  const percentage = contextWindowSize > 0 ? (tokens / contextWindowSize * 100).toFixed(1) : "0.0";
   const right = `${fmtTokens(tokens)} tokens (${percentage}%)`;
   const leftPart = `${indent}${label}`;
   const totalWidth = 56;
@@ -899,7 +899,8 @@ var contextCommand = {
   kind: "built-in" /* BUILT_IN */,
   supportedModes: ["interactive", "non_interactive", "acp"],
   action: /* @__PURE__ */ __name(async (context, args) => {
-    const showDetails = args?.trim().toLowerCase() === "detail" || args?.trim().toLowerCase() === "-d";
+    const normalizedArgs = args?.trim().toLowerCase();
+    const showDetails = normalizedArgs === "detail" || normalizedArgs === "-d";
     const executionMode = context.executionMode ?? "interactive";
     const { config } = context.services;
     if (!config) {
@@ -923,13 +924,12 @@ var contextCommand = {
     if (executionMode === "interactive") {
       context.ui.addItem(contextUsageItem, Date.now());
       return;
-    } else {
-      return {
-        type: "message",
-        messageType: "info",
-        content: formatContextUsageText(contextUsageItem)
-      };
     }
+    return {
+      type: "message",
+      messageType: "info",
+      content: formatContextUsageText(contextUsageItem)
+    };
   }, "action"),
   subCommands: [
     {

package/chunks/{chunk-7YKXFA3D.js → chunk-UOB6KPGG.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   resolveBundleDir
-} from "./chunk-QCG6KPNM.js";
+} from "./chunk-H4ZDM3N6.js";
 import {
   Storage
-} from "./chunk-JXAZUMDW.js";
+} from "./chunk-HA2UEYZP.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -169,15 +169,15 @@ init_esbuild_shims();
 
 // import("./locales/**/*.js") in packages/cli/src/i18n/index.ts
 var globImport_locales_js = __glob({
-  "./locales/ca.js": () => import("./ca-BARBRL6N.js"),
-  "./locales/de.js": () => import("./de-YGKK2BC4.js"),
-  "./locales/en.js": () => import("./en-HSQQNQUB.js"),
-  "./locales/fr.js": () => import("./fr-JXBKPJKQ.js"),
-  "./locales/ja.js": () => import("./ja-TGPZSP2B.js"),
-  "./locales/pt.js": () => import("./pt-TIBG6BIO.js"),
-  "./locales/ru.js": () => import("./ru-JBCHCK4L.js"),
-  "./locales/zh-TW.js": () => import("./zh-TW-G3HFHVVT.js"),
-  "./locales/zh.js": () => import("./zh-VCLWO26Y.js")
+  "./locales/ca.js": () => import("./ca-RK4QPLIX.js"),
+  "./locales/de.js": () => import("./de-FGPM4KW5.js"),
+  "./locales/en.js": () => import("./en-VP6XPGEC.js"),
+  "./locales/fr.js": () => import("./fr-ATYBVCLT.js"),
+  "./locales/ja.js": () => import("./ja-W2QEA2OI.js"),
+  "./locales/pt.js": () => import("./pt-ZKEWJFBW.js"),
+  "./locales/ru.js": () => import("./ru-VEKTPJ74.js"),
+  "./locales/zh-TW.js": () => import("./zh-TW-6YFNCKTA.js"),
+  "./locales/zh.js": () => import("./zh-OIXDDQHB.js")
 });
 
 // packages/cli/src/i18n/index.ts

package/chunks/{chunk-USE2VQ5P.js → chunk-VU6A2OBJ.js}

@@ -380,6 +380,15 @@ var SessionRouter = class {
         return `${channelName}:${senderId}:${chatId}`;
     }
   }
+  /**
+   * Sender-scoped key prefix for by-sender (no chatId) scans. The trailing
+   * ':' delimiter ensures a sender id matches as a whole segment — without it
+   * sender "bob" would also match another sender "bobby"
+   * (key `${channelName}:bobby:${chatId}`).
+   */
+  senderPrefix(channelName, senderId) {
+    return `${channelName}:${senderId}:`;
+  }
   async resolve(channelName, senderId, chatId, threadId, cwd) {
     const key = this.routingKey(channelName, senderId, chatId, threadId);
     const existing = this.toSession.get(key);
@@ -398,11 +407,12 @@ var SessionRouter = class {
     return this.toTarget.get(sessionId);
   }
   hasSession(channelName, senderId, chatId) {
-    const key = chatId ? this.routingKey(channelName, senderId, chatId) : `${channelName}:${senderId}`;
-    if (chatId)
-      return this.toSession.has(key);
+    if (chatId) {
+      return this.toSession.has(this.routingKey(channelName, senderId, chatId));
+    }
+    const prefix = this.senderPrefix(channelName, senderId);
     for (const k of this.toSession.keys()) {
-      if (k.startsWith(`${channelName}:${senderId}`))
+      if (k.startsWith(prefix))
         return true;
     }
     return false;
@@ -418,7 +428,7 @@ var SessionRouter = class {
       if (sessionId)
         removedIds.push(sessionId);
     } else {
-      const prefix = `${channelName}:${senderId}`;
+      const prefix = this.senderPrefix(channelName, senderId);
       for (const k of [...this.toSession.keys()]) {
         if (k.startsWith(prefix)) {
           const sessionId = this.deleteByKey(k);
@@ -692,6 +702,27 @@ var ChannelBase = class {
       }
     }
     const sessionId = await this.router.resolve(this.name, envelope.senderId, envelope.chatId, envelope.threadId, this.config.cwd);
+    if (envelope.text.startsWith("!")) {
+      const cmd = envelope.text.slice(1).trim();
+      const bridgeShellCommand = this.bridge["shellCommand"];
+      if (cmd && typeof bridgeShellCommand === "function") {
+        try {
+          const result2 = await bridgeShellCommand(sessionId, cmd);
+          const longestRun = Math.max(0, ...Array.from((result2.output || "").matchAll(/`+/g), (m) => m[0].length));
+          const fence = "`".repeat(Math.max(3, longestRun + 1));
+          const output = result2.output ? `${fence}
+${result2.output}
+${fence}` : "(no output)";
+          const exitLine = result2.exitCode !== null && result2.exitCode !== 0 ? `
+Exit code: ${result2.exitCode}` : "";
+          await this.sendMessage(envelope.chatId, `$ ${cmd}
+${output}${exitLine}`);
+        } catch (error) {
+          await this.sendMessage(envelope.chatId, `Shell command failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        return;
+      }
+    }
     let promptText = envelope.text;
     if (envelope.referencedText) {
       promptText = `[Replying to: "${envelope.referencedText}"]
@@ -856,7 +887,11 @@ var AcpBridge = class extends EventEmitter {
   }
   async start() {
     const { cliEntryPath, cwd } = this.options;
-    const args = [cliEntryPath, "--acp"];
+    const args = [
+      ...process.execArgv.filter((a) => !/^--inspect(-brk)?($|=)/.test(a)),
+      cliEntryPath,
+      "--acp"
+    ];
     if (this.options.model) {
       args.push("--model", this.options.model);
     }

package/chunks/{chunk-PAEBHDIO.js → chunk-VXHYMZXW.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-OFEVLU4C.js";
 import {
   SchemaValidator
-} from "./chunk-2ZTWI7KH.js";
+} from "./chunk-6WPY6ES3.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";