@mmmbuto/qwen-code-termux 0.16.1-termux → 0.18.0-termux

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

@@ -692,6 +692,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}"]

package/chunks/{chunk-NCTLV2NB.js → chunk-KQJMQJPI.js}

@@ -5,7 +5,7 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-XEGHDASV.js";
+} from "./chunk-D3RHSPAS.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-5FBA5XC2.js → chunk-KRIHGKNA.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   ToolNames
-} from "./chunk-XEGHDASV.js";
+} from "./chunk-D3RHSPAS.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/chunk-LD2XBG6Z.js

@@ -0,0 +1,102 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/agents/team/identity.ts
+init_esbuild_shims();
+import { AsyncLocalStorage } from "node:async_hooks";
+var teammateIdentityStore = new AsyncLocalStorage();
+function getTeammateContext() {
+  return teammateIdentityStore.getStore();
+}
+__name(getTeammateContext, "getTeammateContext");
+function isInProcessTeammate() {
+  return teammateIdentityStore.getStore() !== void 0;
+}
+__name(isInProcessTeammate, "isInProcessTeammate");
+function getAgentName() {
+  return teammateIdentityStore.getStore()?.agentName;
+}
+__name(getAgentName, "getAgentName");
+function getTeamName() {
+  return teammateIdentityStore.getStore()?.teamName;
+}
+__name(getTeamName, "getTeamName");
+function resolveActiveTeamName(fallback) {
+  return getTeamName() ?? fallback;
+}
+__name(resolveActiveTeamName, "resolveActiveTeamName");
+var isTeammate = isInProcessTeammate;
+function isTeamLead() {
+  return teammateIdentityStore.getStore()?.isTeamLead ?? false;
+}
+__name(isTeamLead, "isTeamLead");
+function getTeammateColor() {
+  return teammateIdentityStore.getStore()?.color;
+}
+__name(getTeammateColor, "getTeammateColor");
+function runWithTeammateIdentity(identity, fn) {
+  return teammateIdentityStore.run(identity, fn);
+}
+__name(runWithTeammateIdentity, "runWithTeammateIdentity");
+
+// packages/core/src/agents/team/types.ts
+init_esbuild_shims();
+var MAX_TEAMMATES = 10;
+var LEADER_NAME = "leader";
+var TEAMS_DIR = "teams";
+var TASKS_DIR = "tasks";
+var TEAM_CONFIG_FILENAME = "config.json";
+var INBOXES_DIR = "inboxes";
+var TEAMMATE_COLORS = [
+  "#FF6B6B",
+  // red
+  "#4ECDC4",
+  // teal
+  "#45B7D1",
+  // blue
+  "#FFA07A",
+  // salmon
+  "#98D8C8",
+  // mint
+  "#DDA0DD",
+  // plum
+  "#F0E68C",
+  // khaki
+  "#87CEEB",
+  // sky blue
+  "#FFB347",
+  // orange
+  "#B0E0E6"
+  // powder blue
+];
+
+export {
+  teammateIdentityStore,
+  getTeammateContext,
+  isInProcessTeammate,
+  getAgentName,
+  getTeamName,
+  resolveActiveTeamName,
+  isTeammate,
+  isTeamLead,
+  getTeammateColor,
+  runWithTeammateIdentity,
+  MAX_TEAMMATES,
+  LEADER_NAME,
+  TEAMS_DIR,
+  TASKS_DIR,
+  TEAM_CONFIG_FILENAME,
+  INBOXES_DIR,
+  TEAMMATE_COLORS
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-MAY32HXD.js → chunk-M6VTDSVR.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-XP27SJMH.js";
+} from "./chunk-HR7SV7AY.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -474,6 +474,8 @@ var PATTERNS = [
   // -------------------
   // MiniMax
   // -------------------
+  [/^minimax-m3/i, LIMITS["1m"]],
+  // MiniMax-M3: 1,000,000
   [/^minimax-m2\.5/i, LIMITS["192k"]],
   // MiniMax-M2.5: 196,608
   [/^minimax-/i, LIMITS["200k"]],

package/chunks/chunk-MRO43B25.js

@@ -0,0 +1,30 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/utils/housekeeping/lastInteractionAt.ts
+init_esbuild_shims();
+var lastInteractionAt = Date.now();
+function noteInteraction() {
+  lastInteractionAt = Date.now();
+}
+__name(noteInteraction, "noteInteraction");
+function msSinceLastInteraction() {
+  return Date.now() - lastInteractionAt;
+}
+__name(msSinceLastInteraction, "msSinceLastInteraction");
+
+export {
+  noteInteraction,
+  msSinceLastInteraction
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-N4WOREMD.js → chunk-NVFMZBX2.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-OFEVLU4C.js";
 import {
   SchemaValidator
-} from "./chunk-XEGHDASV.js";
+} from "./chunk-D3RHSPAS.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -15,6 +15,7 @@ import {
 
 // packages/core/src/utils/sideQuery.ts
 init_esbuild_shims();
+import { readFile } from "node:fs/promises";
 function buildDefaultPromptId(purpose) {
   return purpose ? `side-query:${purpose}` : "side-query";
 }
@@ -31,6 +32,41 @@ function applyThinkingDefault(callerConfig) {
   };
 }
 __name(applyThinkingDefault, "applyThinkingDefault");
+async function getOutputLanguageInstruction(config) {
+  const outputLanguageFilePath = config.getOutputLanguageFilePath?.();
+  if (!outputLanguageFilePath) return void 0;
+  try {
+    const preference = (await readFile(outputLanguageFilePath, "utf8")).trim();
+    if (!preference) return void 0;
+    return [
+      "Follow the user-visible output language preference below for this side query.",
+      preference
+    ].join("\n\n");
+  } catch {
+    return void 0;
+  }
+}
+__name(getOutputLanguageInstruction, "getOutputLanguageInstruction");
+function appendSystemInstruction(systemInstruction, outputLanguageInstruction) {
+  if (!outputLanguageInstruction) return systemInstruction;
+  if (systemInstruction === void 0) return outputLanguageInstruction;
+  if (typeof systemInstruction === "string") {
+    return `${systemInstruction}
+
+${outputLanguageInstruction}`;
+  }
+  if (Array.isArray(systemInstruction)) {
+    return [...systemInstruction, { text: outputLanguageInstruction }];
+  }
+  if (typeof systemInstruction === "object" && "parts" in systemInstruction && Array.isArray(systemInstruction.parts)) {
+    return {
+      ...systemInstruction,
+      parts: [...systemInstruction.parts, { text: outputLanguageInstruction }]
+    };
+  }
+  return [systemInstruction, { text: outputLanguageInstruction }];
+}
+__name(appendSystemInstruction, "appendSystemInstruction");
 function isJsonOptions(options) {
   return options.schema !== void 0 && options.schema !== null;
 }
@@ -39,13 +75,17 @@ async function runSideQuery(config, options) {
   const model = resolveDefaultModel(config, options.model);
   const promptId = options.promptId ?? buildDefaultPromptId(options.purpose);
   const requestConfig = applyThinkingDefault(options.config);
+  const systemInstruction = appendSystemInstruction(
+    options.systemInstruction,
+    await getOutputLanguageInstruction(config)
+  );
   if (isJsonOptions(options)) {
     const response = await config.getBaseLlmClient().generateJson({
       contents: options.contents,
       schema: options.schema,
       abortSignal: options.abortSignal,
       model,
-      systemInstruction: options.systemInstruction,
+      systemInstruction,
       promptId,
       config: requestConfig,
       ...options.maxAttempts !== void 0 && {
@@ -65,7 +105,7 @@ async function runSideQuery(config, options) {
   const result = await config.getBaseLlmClient().generateText({
     contents: options.contents,
     model,
-    systemInstruction: options.systemInstruction,
+    systemInstruction,
     abortSignal: options.abortSignal,
     promptId,
     config: requestConfig,

package/chunks/chunk-OHEGWO4L.js

@@ -0,0 +1,264 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  createDebugLogger
+} from "./chunk-HR7SV7AY.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/tools/skill-utils.ts
+init_esbuild_shims();
+
+// packages/core/src/utils/xml.ts
+init_esbuild_shims();
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+__name(escapeXml, "escapeXml");
+var XML_TAG_CANDIDATE_RE = /<[^<>]*>/g;
+function isXmlWhitespace(char) {
+  return char !== void 0 && /\s/.test(char);
+}
+__name(isXmlWhitespace, "isXmlWhitespace");
+function isSystemReminderTagIgnorable(char) {
+  const codePoint = char.codePointAt(0);
+  if (codePoint === void 0) return false;
+  return codePoint === 173 || codePoint === 1564 || codePoint === 12644 || codePoint === 65279 || codePoint === 65440 || codePoint >= 0 && codePoint <= 31 || codePoint >= 127 && codePoint <= 159 || codePoint >= 4447 && codePoint <= 4448 || codePoint >= 6068 && codePoint <= 6069 || codePoint >= 6155 && codePoint <= 6159 || codePoint >= 8203 && codePoint <= 8207 || codePoint >= 8234 && codePoint <= 8238 || codePoint >= 8288 && codePoint <= 8303 || codePoint >= 65024 && codePoint <= 65039 || codePoint >= 65520 && codePoint <= 65528 || codePoint >= 113824 && codePoint <= 113827 || codePoint >= 119155 && codePoint <= 119162 || codePoint >= 917504 && codePoint <= 921599;
+}
+__name(isSystemReminderTagIgnorable, "isSystemReminderTagIgnorable");
+function normalizeSystemReminderCandidateTag(tag) {
+  let normalized = "";
+  for (const char of tag) {
+    if (!isSystemReminderTagIgnorable(char)) {
+      normalized += char;
+    }
+  }
+  return normalized.toLowerCase();
+}
+__name(normalizeSystemReminderCandidateTag, "normalizeSystemReminderCandidateTag");
+function getSystemReminderTagKind(tag) {
+  const normalized = normalizeSystemReminderCandidateTag(tag);
+  const len = normalized.length;
+  if (len < 2 || normalized[0] !== "<" || normalized[len - 1] !== ">") {
+    return void 0;
+  }
+  let i = 1;
+  while (i < len && isXmlWhitespace(normalized[i])) i++;
+  let closing = false;
+  if (normalized[i] === "/") {
+    closing = true;
+    i++;
+  }
+  while (i < len && isXmlWhitespace(normalized[i])) i++;
+  const TAG_NAME = "system-reminder";
+  if (normalized.slice(i, i + TAG_NAME.length) !== TAG_NAME) {
+    return void 0;
+  }
+  i += TAG_NAME.length;
+  if (i < len - 1 && isXmlWhitespace(normalized[i])) {
+    while (i < len && isXmlWhitespace(normalized[i])) i++;
+    while (i < len && normalized[i] !== ">") i++;
+  }
+  while (i < len && isXmlWhitespace(normalized[i])) i++;
+  if (normalized[i] === "/") i++;
+  while (i < len && isXmlWhitespace(normalized[i])) i++;
+  if (i !== len - 1 || normalized[i] !== ">") {
+    return void 0;
+  }
+  return closing ? "closing" : "other";
+}
+__name(getSystemReminderTagKind, "getSystemReminderTagKind");
+function escapeSystemReminderTag(tag) {
+  const tagKind = getSystemReminderTagKind(tag);
+  if (tagKind === "closing") {
+    return "<\\/system-reminder>";
+  }
+  if (tagKind === "other") {
+    return escapeXml(tag);
+  }
+  return tag;
+}
+__name(escapeSystemReminderTag, "escapeSystemReminderTag");
+function escapeSystemReminderTags(text) {
+  return text.replace(XML_TAG_CANDIDATE_RE, escapeSystemReminderTag);
+}
+__name(escapeSystemReminderTags, "escapeSystemReminderTags");
+
+// packages/core/src/tools/skill-utils.ts
+function buildSkillLlmContent(baseDir, body) {
+  return `Base directory for this skill: ${baseDir}
+Important: ALWAYS resolve absolute paths from this base directory when working with skills.
+
+${body}
+`;
+}
+__name(buildSkillLlmContent, "buildSkillLlmContent");
+async function collectAvailableSkillEntries(skillManager, config) {
+  const allSkills = await skillManager.listSkills();
+  const disabledNames = config.getDisabledSkillNames();
+  const isDisabled = /* @__PURE__ */ __name((name) => disabledNames.has(name.toLowerCase()), "isDisabled");
+  const availableSkills = allSkills.filter(
+    (s) => !s.disableModelInvocation && skillManager.isSkillActive(s) && !isDisabled(s.name)
+  );
+  const pendingConditionalSkillNames = new Set(
+    allSkills.filter(
+      (s) => !s.disableModelInvocation && s.paths && s.paths.length > 0 && !skillManager.isSkillActive(s) && !isDisabled(s.name)
+    ).map((s) => s.name)
+  );
+  const provider = config.getModelInvocableCommandsProvider();
+  const allCommands = provider ? provider() : [];
+  const fileBasedSkillNames = new Set(
+    allSkills.filter((s) => !s.disableModelInvocation && !isDisabled(s.name)).map((s) => s.name)
+  );
+  const modelInvocableCommands = allCommands.filter(
+    (cmd) => !fileBasedSkillNames.has(cmd.name)
+  );
+  const entries = [
+    ...availableSkills.map((s) => ({
+      name: s.name,
+      description: s.description,
+      whenToUse: s.whenToUse,
+      level: s.level
+    })),
+    ...modelInvocableCommands.map((c) => ({
+      name: c.name,
+      description: c.description
+    }))
+  ];
+  return {
+    availableSkills,
+    pendingConditionalSkillNames,
+    modelInvocableCommands,
+    entries
+  };
+}
+__name(collectAvailableSkillEntries, "collectAvailableSkillEntries");
+function compareSkillEntries(a, b) {
+  const aGroup = a.level !== void 0 ? 0 : 1;
+  const bGroup = b.level !== void 0 ? 0 : 1;
+  if (aGroup !== bGroup) return aGroup - bGroup;
+  return a.name.localeCompare(b.name);
+}
+__name(compareSkillEntries, "compareSkillEntries");
+function renderAvailableSkillsBlock(entries) {
+  return [...entries].sort(compareSkillEntries).map((entry) => {
+    if (entry.level !== void 0) {
+      const descText = `${escapeXml(entry.description)}${entry.whenToUse ? ` \u2014 ${escapeXml(entry.whenToUse)}` : ""} (${entry.level})`;
+      return `<skill>
+<name>
+${escapeXml(entry.name)}
+</name>
+<description>
+${descText}
+</description>
+<location>
+${entry.level}
+</location>
+</skill>`;
+    }
+    return `<skill>
+<name>
+${escapeXml(entry.name)}
+</name>
+<description>
+${escapeXml(entry.description)}
+</description>
+</skill>`;
+  }).join("\n");
+}
+__name(renderAvailableSkillsBlock, "renderAvailableSkillsBlock");
+function applySkillAllowedTools(permissionManager, allowedTools) {
+  if (!permissionManager || !allowedTools?.length) {
+    return;
+  }
+  for (const rule of allowedTools) {
+    permissionManager.addSessionAllowRule(rule);
+  }
+}
+__name(applySkillAllowedTools, "applySkillAllowedTools");
+
+// packages/core/src/hooks/registerSkillHooks.ts
+init_esbuild_shims();
+var debugLogger = createDebugLogger("SKILL_HOOKS");
+function registerSkillHooks(sessionHooksManager, sessionId, skill) {
+  if (!skill.hooks) {
+    debugLogger.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 */) {
+          debugLogger.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++;
+        debugLogger.debug(
+          `Registered hook for ${eventName} with matcher '${matcherPattern}' from skill '${skill.name}'`
+        );
+      }
+    }
+  }
+  if (registeredCount > 0) {
+    debugLogger.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 {
+  escapeXml,
+  escapeSystemReminderTags,
+  buildSkillLlmContent,
+  collectAvailableSkillEntries,
+  renderAvailableSkillsBlock,
+  applySkillAllowedTools,
+  registerSkillHooks
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */