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

package/chunks/{chunk-JUGRPQAB.js → chunk-B4ZF2KSI.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-JXAZUMDW.js";
+} from "./chunk-HA2UEYZP.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/chunk-BJ5HQ23U.js

@@ -0,0 +1,178 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  Mutex
+} from "./chunk-OMX7CUOE.js";
+import {
+  atomicWriteJSON
+} from "./chunk-LXYWINWF.js";
+import {
+  Storage,
+  createDebugLogger,
+  getProjectHash
+} from "./chunk-HA2UEYZP.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/services/cronTasksFile.ts
+init_esbuild_shims();
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+var debugLogger = createDebugLogger("CRON_TASKS_FILE");
+var TASKS_FILENAME = "scheduled_tasks.json";
+var CRON_TASKS_DISPLAY_PATH = `~/.qwen/tmp/<project-hash>/${TASKS_FILENAME}`;
+var UPDATE_LOCK_RETRY_MS = 15;
+var UPDATE_LOCK_STALE_MS = 2e3;
+var UPDATE_LOCK_TIMEOUT_MS = 3e3;
+var updateStaleSeq = 0;
+var updateMutexes = /* @__PURE__ */ new Map();
+function getUpdateMutex(filePath) {
+  let mutex = updateMutexes.get(filePath);
+  if (!mutex) {
+    mutex = new Mutex();
+    updateMutexes.set(filePath, mutex);
+  }
+  return mutex;
+}
+__name(getUpdateMutex, "getUpdateMutex");
+function getCronFilePath(projectRoot) {
+  return path.join(
+    Storage.getGlobalTempDir(),
+    getProjectHash(projectRoot),
+    TASKS_FILENAME
+  );
+}
+__name(getCronFilePath, "getCronFilePath");
+async function readCronTasks(projectRoot) {
+  const filePath = getCronFilePath(projectRoot);
+  let raw;
+  try {
+    raw = await fs.readFile(filePath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error(
+      `Malformed JSON in ${filePath} \u2014 fix or delete the file; refusing to treat it as an empty schedule.`
+    );
+  }
+  if (!Array.isArray(parsed)) {
+    throw new Error(
+      `Expected a JSON array in ${filePath} \u2014 fix or delete the file; refusing to treat it as an empty schedule.`
+    );
+  }
+  const valid = parsed.filter(isValidTask);
+  if (valid.length !== parsed.length) {
+    debugLogger.warn(
+      `Dropped ${parsed.length - valid.length} invalid task entr${parsed.length - valid.length === 1 ? "y" : "ies"} from ${filePath}; a later write will persist without ${parsed.length - valid.length === 1 ? "it" : "them"}.`
+    );
+  }
+  return valid;
+}
+__name(readCronTasks, "readCronTasks");
+async function writeCronTasks(projectRoot, tasks) {
+  const filePath = getCronFilePath(projectRoot);
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await atomicWriteJSON(filePath, tasks, { noFollow: true });
+}
+__name(writeCronTasks, "writeCronTasks");
+async function acquireUpdateLock(filePath) {
+  const lockPath = `${filePath}.lock`;
+  await fs.mkdir(path.dirname(lockPath), { recursive: true });
+  const deadline = Date.now() + UPDATE_LOCK_TIMEOUT_MS;
+  for (; ; ) {
+    if (Date.now() > deadline) {
+      throw new Error(
+        `Timed out waiting for scheduled-tasks lock (${lockPath})`
+      );
+    }
+    try {
+      await fs.writeFile(lockPath, String(process.pid), { flag: "wx" });
+      return async () => {
+        await fs.unlink(lockPath).catch(() => {
+        });
+      };
+    } catch (err) {
+      if (err.code !== "EEXIST") throw err;
+    }
+    try {
+      const stat2 = await fs.stat(lockPath);
+      if (Date.now() - stat2.mtimeMs > UPDATE_LOCK_STALE_MS) {
+        const stalePath = `${lockPath}.stale.${process.pid}.${updateStaleSeq++}`;
+        try {
+          await fs.rename(lockPath, stalePath);
+        } catch {
+          continue;
+        }
+        const moved = await fs.stat(stalePath).catch(() => null);
+        if (moved && Date.now() - moved.mtimeMs <= UPDATE_LOCK_STALE_MS) {
+          await fs.link(stalePath, lockPath).catch(() => {
+          });
+        }
+        await fs.unlink(stalePath).catch(() => {
+        });
+        continue;
+      }
+    } catch {
+      continue;
+    }
+    await new Promise((resolve) => setTimeout(resolve, UPDATE_LOCK_RETRY_MS));
+  }
+}
+__name(acquireUpdateLock, "acquireUpdateLock");
+async function updateCronTasks(projectRoot, mutate) {
+  const filePath = getCronFilePath(projectRoot);
+  return getUpdateMutex(filePath).runExclusive(async () => {
+    const release = await acquireUpdateLock(filePath);
+    try {
+      const tasks = await readCronTasks(projectRoot);
+      const next = mutate(tasks);
+      if (next !== tasks) {
+        await writeCronTasks(projectRoot, next);
+      }
+    } finally {
+      await release();
+    }
+  });
+}
+__name(updateCronTasks, "updateCronTasks");
+async function addCronTask(projectRoot, task) {
+  await updateCronTasks(projectRoot, (tasks) => [...tasks, task]);
+}
+__name(addCronTask, "addCronTask");
+async function removeCronTasks(projectRoot, ids) {
+  const idSet = new Set(ids);
+  const current = await readCronTasks(projectRoot);
+  if (!current.some((t) => idSet.has(t.id))) return 0;
+  let removed = 0;
+  await updateCronTasks(projectRoot, (tasks) => {
+    const remaining = tasks.filter((t) => !idSet.has(t.id));
+    removed = tasks.length - remaining.length;
+    return removed === 0 ? tasks : remaining;
+  });
+  return removed;
+}
+__name(removeCronTasks, "removeCronTasks");
+function isValidTask(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const obj = value;
+  return typeof obj["id"] === "string" && typeof obj["cron"] === "string" && typeof obj["prompt"] === "string" && typeof obj["recurring"] === "boolean" && typeof obj["createdAt"] === "number" && (obj["lastFiredAt"] === null || typeof obj["lastFiredAt"] === "number");
+}
+__name(isValidTask, "isValidTask");
+
+export {
+  CRON_TASKS_DISPLAY_PATH,
+  getCronFilePath,
+  readCronTasks,
+  updateCronTasks,
+  addCronTask,
+  removeCronTasks
+};

package/chunks/{chunk-ICOI4E4S.js → chunk-CPVI5J2L.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-JXAZUMDW.js";
+} from "./chunk-HA2UEYZP.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -10,6 +10,9 @@ 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) {
@@ -85,6 +88,99 @@ function escapeSystemReminderTags(text) {
 }
 __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");
@@ -147,32 +243,14 @@ function prepareHookConfig(hook, skillRoot) {
 }
 __name(prepareHookConfig, "prepareHookConfig");
 
-// packages/core/src/tools/skill-utils.ts
-init_esbuild_shims();
-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");
-function applySkillAllowedTools(permissionManager, allowedTools) {
-  if (!permissionManager || !allowedTools?.length) {
-    return;
-  }
-  for (const rule of allowedTools) {
-    permissionManager.addSessionAllowRule(rule);
-  }
-}
-__name(applySkillAllowedTools, "applySkillAllowedTools");
-
 export {
   escapeXml,
   escapeSystemReminderTags,
-  registerSkillHooks,
   buildSkillLlmContent,
-  applySkillAllowedTools
+  collectAvailableSkillEntries,
+  renderAvailableSkillsBlock,
+  applySkillAllowedTools,
+  registerSkillHooks
 };
 /**
  * @license

package/chunks/{chunk-GX7VH5JQ.js → chunk-FIQECJTQ.js}

@@ -3,7 +3,7 @@
 import {
   getErrorMessage,
   isNodeError
-} from "./chunk-JXAZUMDW.js";
+} from "./chunk-HA2UEYZP.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";