@qwen-code/qwen-code 0.22.2 → 0.22.3-nightly.20260831.3a0c4c6108

package/chunks/{chunk-XDFHY4R3.js → chunk-RGEV5AUD.js}

@@ -1,48 +1,58 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  parseChannelDelivery
-} from "./chunk-4CMJKUND.js";
+  buildScheduledTaskRunPrompt,
+  parseChannelDelivery,
+  scheduledTaskRunSessionName,
+  scheduledTaskRunSourceId
+} from "./chunk-PNIGAVY6.js";
 import {
   parseCallerSuppliedSessionId
 } from "./chunk-ZEZKIS2K.js";
 import {
   isInternalWorkspaceRuntime
 } from "./chunk-NYWWQ437.js";
+import {
+  SCHEDULED_TASK_RUN_SOURCE_TYPE
+} from "./chunk-RLSPPTWH.js";
 import {
   SessionNotFoundError
-} from "./chunk-ERFDKH32.js";
+} from "./chunk-YPISTYEI.js";
 import {
   canonicalizeWorkspace
 } from "./chunk-6PLDPT2C.js";
 import {
   isChannelDeliveryError
 } from "./chunk-RKFGE7JH.js";
+import {
+  isWithinRoot
+} from "./chunk-MR3PXB6E.js";
 import {
   SessionService,
   stripTerminalControlSequences
-} from "./chunk-TGWAQ5RB.js";
+} from "./chunk-ZBDYI7VM.js";
 import {
   MAX_JOBS,
   nextDurableFireMs
-} from "./chunk-EKSCLBBF.js";
+} from "./chunk-SMJYTKTB.js";
 import {
   nextFireTime,
   parseCron
 } from "./chunk-IRH27ZC2.js";
 import {
+  annotateCronRunSession,
   appendCronRun,
   generateCronTaskId,
   readCronTasks,
   taskHasLegacyCondition,
   updateCronTasks
-} from "./chunk-D5LUXLUH.js";
+} from "./chunk-UJ4DUYIH.js";
 import {
   Storage
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import {
   writeStderrLine
-} from "./chunk-KGJGEEVR.js";
+} from "./chunk-7FA2II6K.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -292,8 +302,7 @@ function resolveContainedCwd(req, workspaceCwd) {
   try {
     const resolved = fs.realpathSync(path.resolve(rawCwd));
     const root = fs.realpathSync(workspaceCwd);
-    const rel = path.relative(root, resolved);
-    if (!rel.startsWith("..") && !path.isAbsolute(rel)) {
+    if (isWithinRoot(resolved, root)) {
       return resolved;
     }
   } catch {
@@ -312,8 +321,7 @@ function resolveContainedCwdOrFail(req, workspaceCwd) {
   try {
     const resolved = fs.realpathSync(path.resolve(rawCwd));
     const root = fs.realpathSync(workspaceCwd);
-    const rel = path.relative(root, resolved);
-    if (!rel.startsWith("..") && !path.isAbsolute(rel)) {
+    if (isWithinRoot(resolved, root)) {
       return resolved;
     }
   } catch {
@@ -337,7 +345,7 @@ function scheduledTaskSessionName(label) {
     if (boundary >= 55296 && boundary <= 56319) cut -= 1;
     short = `${cleaned.slice(0, cut)}\u2026`;
   }
-  return `\u23F0 ${short}`;
+  return short;
 }
 __name(scheduledTaskSessionName, "scheduledTaskSessionName");
 var ExistingSessionScheduledTaskCreateError = class extends Error {
@@ -512,6 +520,7 @@ async function createScheduledTaskWithExistingSession(target, input, options) {
     enabled: input.enabled !== false,
     sessionId: input.sessionId,
     sessionOwnedByTask: false,
+    sessionMode: input.sessionMode === "per_run" ? "per_run" : "persistent",
     ...input.delivery !== void 0 ? { delivery: input.delivery } : {},
     ...input.name !== void 0 ? { name: input.name } : {}
   };
@@ -583,6 +592,25 @@ async function rollbackCronMutation(target, before, after, route) {
   });
 }
 __name(rollbackCronMutation, "rollbackCronMutation");
+async function restoreConsumedOneShot(target, before, id, route) {
+  const index = before?.findIndex((t) => t.id === id) ?? -1;
+  const original = index === -1 ? void 0 : before[index];
+  if (!original) return;
+  await runWithScheduledTaskTarget(
+    target,
+    () => updateCronTasks(target.workspaceCwd, (tasks) => {
+      if (tasks.some((t) => t.id === id)) return tasks;
+      const restored = [...tasks];
+      restored.splice(Math.min(index, restored.length), 0, original);
+      return restored;
+    })
+  ).catch((error) => {
+    writeStderrLine(
+      `qwen serve: ${route} failed to restore the consumed one-shot task: ${error instanceof Error ? error.message : String(error)}`
+    );
+  });
+}
+__name(restoreConsumedOneShot, "restoreConsumedOneShot");
 async function teardownBoundSession(target, sessionId) {
   if (target.cleanupSession) {
     await target.cleanupSession(sessionId).catch(() => {
@@ -597,6 +625,79 @@ async function teardownBoundSession(target, sessionId) {
   }
 }
 __name(teardownBoundSession, "teardownBoundSession");
+async function dispatchTaskToFreshSession(target, task) {
+  const { bridge } = target;
+  const sendPrompt = bridge?.sendPrompt?.bind(bridge);
+  if (!bridge || !sendPrompt || !task.sessionId) {
+    throw new Error("Fresh-session dispatch is unavailable for this task");
+  }
+  const triggeredAt = task.lastFiredAt ?? Date.now();
+  const child = await runWithScheduledTaskTarget(
+    target,
+    () => bridge.spawnOrAttach({
+      workspaceCwd: target.workspaceCwd,
+      sessionScope: "thread",
+      parentSessionId: task.sessionId,
+      sourceType: SCHEDULED_TASK_RUN_SOURCE_TYPE,
+      sourceId: scheduledTaskRunSourceId(task.id)
+    })
+  );
+  try {
+    bridge.updateSessionMetadata(child.sessionId, {
+      displayName: scheduledTaskRunSessionName(
+        task.name ?? task.prompt,
+        triggeredAt
+      )
+    });
+  } catch {
+  }
+  try {
+    let markPromptAdmitted;
+    const promptAdmitted = new Promise((resolve) => {
+      markPromptAdmitted = resolve;
+    });
+    const turn = sendPrompt(
+      child.sessionId,
+      {
+        sessionId: child.sessionId,
+        prompt: [
+          {
+            type: "text",
+            text: buildScheduledTaskRunPrompt({
+              id: task.id,
+              name: task.name,
+              cron: task.cron,
+              prompt: task.prompt,
+              triggeredAt,
+              trigger: "manual"
+            })
+          }
+        ]
+      },
+      void 0,
+      {
+        onPromptAdmitted: markPromptAdmitted
+      }
+    );
+    await Promise.race([
+      promptAdmitted,
+      turn.then(
+        () => void 0,
+        (error) => Promise.reject(error)
+      )
+    ]);
+    void turn.catch((error) => {
+      writeStderrLine(
+        `qwen serve: scheduled-task session ${child.sessionId} prompt failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    });
+  } catch (error) {
+    await teardownBoundSession(target, child.sessionId);
+    throw error;
+  }
+  return child.sessionId;
+}
+__name(dispatchTaskToFreshSession, "dispatchTaskToFreshSession");
 async function runWithScheduledTaskTarget(target, fn) {
   const result = target.runtimeBaseDir === void 0 ? fn() : Storage.runWithResolvedRuntimeBaseDir(target.runtimeBaseDir, fn);
   return await result;
@@ -638,6 +739,7 @@ function toView(task) {
     // The task's bound session (its run-history transcript), or null for an
     // unbound tool-created/legacy task.
     sessionId: typeof task.sessionId === "string" && task.sessionId.length > 0 ? task.sessionId : null,
+    sessionMode: task.sessionMode === "per_run" ? "per_run" : "persistent",
     // Absent runs (tool-created / never-fired) normalizes to [] so the client
     // never special-cases undefined.
     runs: Array.isArray(task.runs) ? task.runs : [],
@@ -782,6 +884,14 @@ function registerScheduledTaskCrudRoutes(app, deps) {
         });
         return;
       }
+      const sessionMode = body["sessionMode"] === void 0 ? "persistent" : body["sessionMode"];
+      if (sessionMode !== "persistent" && sessionMode !== "per_run") {
+        res.status(400).json({
+          error: '`sessionMode` must be "persistent" or "per_run"',
+          code: "invalid_session_mode"
+        });
+        return;
+      }
       const parsedSessionId = parseCallerSuppliedSessionId(body["sessionId"]);
       if (parsedSessionId.kind === "invalid") {
         res.status(400).json({
@@ -801,6 +911,13 @@ function registerScheduledTaskCrudRoutes(app, deps) {
           return;
         }
       }
+      if (sessionMode === "per_run" && delivery !== void 0) {
+        res.status(400).json({
+          error: "Per-run sessions do not support channel delivery",
+          code: "session_mode_delivery_unsupported"
+        });
+        return;
+      }
       const removedField = findRemovedTaskField(body);
       if (removedField) {
         res.status(400).json(removedFieldError(removedField));
@@ -809,6 +926,13 @@ function registerScheduledTaskCrudRoutes(app, deps) {
       const recurring = body["recurring"] !== false;
       const enabled = body["enabled"] !== false;
       const taskId = generateCronTaskId();
+      if (sessionMode === "per_run" && (!bridge || !bridge.sendPrompt)) {
+        res.status(409).json({
+          error: "Fresh-session dispatch is not available for this workspace",
+          code: "session_mode_unavailable"
+        });
+        return;
+      }
       if (providedSessionId !== void 0) {
         try {
           const task2 = await createScheduledTaskWithExistingSession(
@@ -819,6 +943,7 @@ function registerScheduledTaskCrudRoutes(app, deps) {
               prompt,
               recurring,
               enabled,
+              sessionMode,
               ...delivery !== void 0 ? { delivery } : {},
               ...nameResult.value !== void 0 ? { name: nameResult.value } : {}
             },
@@ -923,6 +1048,7 @@ function registerScheduledTaskCrudRoutes(app, deps) {
         // minute the task was created — same guard cronScheduler.create uses.
         lastFiredAt: now - now % 6e4,
         enabled,
+        sessionMode,
         ...delivery !== void 0 ? { delivery } : {},
         ...boundSessionId !== void 0 ? {
           sessionId: boundSessionId
@@ -1080,6 +1206,16 @@ function registerScheduledTaskCrudRoutes(app, deps) {
         }
         patch.enabled = body["enabled"];
       }
+      if ("sessionMode" in body) {
+        if (body["sessionMode"] !== "persistent" && body["sessionMode"] !== "per_run") {
+          res.status(400).json({
+            error: '`sessionMode` must be "persistent" or "per_run"',
+            code: "invalid_session_mode"
+          });
+          return;
+        }
+        patch.sessionMode = body["sessionMode"];
+      }
       if ("delivery" in body) {
         if (body["delivery"] === null) {
           clearDelivery = true;
@@ -1104,6 +1240,9 @@ function registerScheduledTaskCrudRoutes(app, deps) {
       let updated;
       let blockedByArchive = false;
       let blockedLegacy = false;
+      let blockedSessionModeDelivery = false;
+      let blockedSessionModeUnavailable = false;
+      let blockedSessionModeUnbound = false;
       let rollbackBefore;
       let rollbackAfter;
       try {
@@ -1116,6 +1255,15 @@ function registerScheduledTaskCrudRoutes(app, deps) {
               if (idx === -1) return tasks;
               found = true;
               const current = tasks[idx];
+              const convertingToPerRun = patch.sessionMode === "per_run" && current.sessionMode !== "per_run";
+              if (convertingToPerRun && (!bridge || !bridge.sendPrompt)) {
+                blockedSessionModeUnavailable = true;
+                return tasks;
+              }
+              if (convertingToPerRun && !current.sessionId) {
+                blockedSessionModeUnbound = true;
+                return tasks;
+              }
               if (patch.enabled === true && taskHasLegacyCondition(current)) {
                 blockedLegacy = true;
                 return tasks;
@@ -1127,6 +1275,10 @@ function registerScheduledTaskCrudRoutes(app, deps) {
               const next = { ...current, ...patch };
               if (clearName) delete next.name;
               if (clearDelivery) delete next.delivery;
+              if (next.sessionMode === "per_run" && next.delivery) {
+                blockedSessionModeDelivery = true;
+                return tasks;
+              }
               const justReEnabled = current.enabled === false && patch.enabled === true;
               const cronChanged = patch.cron !== void 0 && canonicalCron(patch.cron) !== canonicalCron(current.cron);
               const becameRecurring = patch.recurring === true && current.recurring !== true;
@@ -1189,6 +1341,27 @@ function registerScheduledTaskCrudRoutes(app, deps) {
         });
         return;
       }
+      if (blockedSessionModeUnavailable) {
+        res.status(409).json({
+          error: "Fresh-session dispatch is not available for this workspace",
+          code: "session_mode_unavailable"
+        });
+        return;
+      }
+      if (blockedSessionModeUnbound) {
+        res.status(409).json({
+          error: "This task is not bound to a session yet, so it cannot run in a new session every run. Try again once it has run or been opened at least once.",
+          code: "session_mode_requires_bound_session"
+        });
+        return;
+      }
+      if (blockedSessionModeDelivery) {
+        res.status(409).json({
+          error: "Per-run sessions do not support channel delivery",
+          code: "session_mode_delivery_unsupported"
+        });
+        return;
+      }
       if (!found || !updated) {
         res.status(404).json({ error: "Task not found", code: "task_not_found" });
         return;
@@ -1350,7 +1523,7 @@ function registerScheduledTaskCrudRoutes(app, deps) {
                 runs: appendCronRun(current.runs, {
                   at: now,
                   kind: "manual",
-                  ...current.sessionId ? { sessionId: current.sessionId } : {}
+                  ...current.sessionMode !== "per_run" && current.sessionId ? { sessionId: current.sessionId } : {}
                 })
               };
               updated = next;
@@ -1406,6 +1579,61 @@ function registerScheduledTaskCrudRoutes(app, deps) {
         res.status(404).json({ error: "Task not found", code: "task_not_found" });
         return;
       }
+      if (updated.sessionMode === "per_run") {
+        const persistOutcome = /* @__PURE__ */ __name(async (outcome) => {
+          if (!updated.recurring) return;
+          await runWithScheduledTaskTarget(
+            target,
+            () => updateCronTasks(
+              workspaceCwd,
+              (tasks) => tasks.map(
+                (task) => task.id === id ? annotateCronRunSession(task, now, outcome) : task
+              ),
+              { assertCanCommit: target.assertGenerationOpen }
+            )
+          );
+        }, "persistOutcome");
+        let childSessionId;
+        try {
+          childSessionId = await dispatchTaskToFreshSession(target, updated);
+        } catch (error) {
+          updated = annotateCronRunSession(updated, now, {
+            dispatchFailed: true
+          });
+          if (updated.recurring) {
+            await persistOutcome({ dispatchFailed: true }).catch(
+              (persistError) => {
+                writeStderrLine(
+                  `qwen serve: POST ${base}/${id}/run could not record the failed dispatch: ${persistError instanceof Error ? persistError.message : String(persistError)}`
+                );
+              }
+            );
+          } else {
+            await restoreConsumedOneShot(
+              target,
+              rollbackBefore,
+              id,
+              `POST ${base}/${id}/run fresh-session dispatch`
+            );
+          }
+          writeStderrLine(
+            `qwen serve: POST ${base}/${id}/run could not create a fresh session: ${error instanceof Error ? error.message : String(error)}`
+          );
+          res.status(500).json({
+            error: "Failed to create a fresh session for the scheduled task",
+            code: "scheduled_task_session_dispatch_failed"
+          });
+          return;
+        }
+        updated = annotateCronRunSession(updated, now, {
+          sessionId: childSessionId
+        });
+        await persistOutcome({ sessionId: childSessionId }).catch((error) => {
+          writeStderrLine(
+            `qwen serve: POST ${base}/${id}/run could not attribute fresh session ${childSessionId}: ${error instanceof Error ? error.message : String(error)}`
+          );
+        });
+      }
       if (!updated.recurring && updated.sessionId) {
         channelDeliveryAuthorizations?.revokeScheduledTask(
           workspaceCwd,

package/chunks/{chunk-M6FOJXW3.js → chunk-RKW36UWC.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-UHQFIS7N.js";
+} from "./chunk-EAHOJF6V.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";