@qwen-code/qwen-code 0.23.1-preview.2 → 0.23.2-nightly.20260909.2e212144d3

package/chunks/{chunk-WLZRMF3C.js → chunk-7KZVXJ4U.js}

@@ -23,10 +23,11 @@ import {
   SessionConflictError,
   SessionNotArchivedError,
   SessionNotFoundError
-} from "./chunk-F47DITLZ.js";
+} from "./chunk-FAWTMDX7.js";
 import {
-  readWorktreeSession
-} from "./chunk-E4VX6LXB.js";
+  readWorktreeSession,
+  readWorktreeSessionStrict
+} from "./chunk-YZTGGCEE.js";
 import {
   SESSION_PR_LIST_LIMIT,
   SESSION_PR_URL_MAX_LENGTH,
@@ -40,7 +41,12 @@ import {
   gitEnv,
   readSessionPrs,
   toSessionPrInfo
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-BDAVT6K2.js";
+import {
+  GitWorktreeService,
+  WORKTREE_SESSION_FILE,
+  readWorktreeSessionMarkerStrict
+} from "./chunk-HIXUUCGY.js";
 import {
   updateCronTasks
 } from "./chunk-F53KKZUD.js";
@@ -1322,6 +1328,7 @@ __name(createWorkspaceRuntimeSessionService, "createWorkspaceRuntimeSessionServi
 
 // packages/cli/src/serve/server/session-archive.ts
 init_esbuild_shims();
+import fs2 from "node:fs";
 
 // packages/cli/src/serve/scheduled-task-session-lifecycle.ts
 init_esbuild_shims();
@@ -1394,6 +1401,296 @@ async function removeTasksForSessions(projectRoot, sessionIds, options = {}) {
 }
 __name(removeTasksForSessions, "removeTasksForSessions");
 
+// packages/cli/src/serve/server/worktree-orphan-cleanup.ts
+init_esbuild_shims();
+import fs from "node:fs";
+import * as fsp from "node:fs/promises";
+import path2 from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+// packages/cli/src/serve/server/worktree-ownership-op.ts
+init_esbuild_shims();
+var worktreeOwnershipOpTails = /* @__PURE__ */ new Map();
+async function acquireWorktreeOwnershipOp(worktreeKey) {
+  const previous = worktreeOwnershipOpTails.get(worktreeKey);
+  let releaseGate;
+  const gate = new Promise((resolve) => {
+    releaseGate = resolve;
+  });
+  const tail = (previous ?? Promise.resolve()).then(() => gate);
+  worktreeOwnershipOpTails.set(worktreeKey, tail);
+  if (previous) {
+    await previous;
+  }
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    releaseGate();
+    if (worktreeOwnershipOpTails.get(worktreeKey) === tail) {
+      worktreeOwnershipOpTails.delete(worktreeKey);
+    }
+  };
+}
+__name(acquireWorktreeOwnershipOp, "acquireWorktreeOwnershipOp");
+
+// packages/cli/src/serve/server/worktree-orphan-cleanup.ts
+function canonicalPath(candidate) {
+  try {
+    return fs.realpathSync(candidate);
+  } catch {
+    return candidate;
+  }
+}
+__name(canonicalPath, "canonicalPath");
+var execFileAsync = promisify(execFile);
+var DISPOSABLE_IGNORED_ROOTS = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage"]);
+async function checkoutHasWork(worktreePath) {
+  try {
+    const { stdout } = await execFileAsync(
+      "git",
+      [
+        "status",
+        "--porcelain",
+        "--untracked-files=normal",
+        "--ignored=matching"
+      ],
+      { cwd: worktreePath, env: gitEnv() }
+    );
+    return stdout.split("\n").filter((line) => line.trim().length > 0).some((line) => {
+      const entry = line.slice(3);
+      if (entry === WORKTREE_SESSION_FILE) return false;
+      if (line.startsWith("!!")) {
+        return !DISPOSABLE_IGNORED_ROOTS.has(entry.split("/")[0]);
+      }
+      return true;
+    });
+  } catch {
+    return true;
+  }
+}
+__name(checkoutHasWork, "checkoutHasWork");
+function logWarning(message) {
+  writeStderrLine(`qwen serve: ${message}`);
+}
+__name(logWarning, "logWarning");
+function logWorktreeCleanupPreserve(sessionId, reason) {
+  logWarning(
+    `worktree cleanup preserved checkout action=delete session=${safeLogValue(
+      sessionId
+    )} reason=${safeLogValue(reason)}`
+  );
+}
+__name(logWorktreeCleanupPreserve, "logWorktreeCleanupPreserve");
+async function preclassifyWorktreeCleanup(service, sessionId, runtimeWorkspaceCwd) {
+  let sidecarPath = service.getWorktreeSessionPath(sessionId);
+  let sidecar = await readWorktreeSessionStrict(sidecarPath);
+  if (sidecar.state === "missing") {
+    const archivedPath = service.getWorktreeSessionPathForArchiveState(
+      sessionId,
+      "archived"
+    );
+    if (archivedPath !== sidecarPath) {
+      sidecarPath = archivedPath;
+      sidecar = await readWorktreeSessionStrict(sidecarPath);
+    }
+  }
+  if (sidecar.state === "missing") return void 0;
+  if (sidecar.state === "invalid") {
+    logWorktreeCleanupPreserve(
+      sessionId,
+      `unreadable sidecar (${sidecar.reason})`
+    );
+    return void 0;
+  }
+  const session = sidecar.session;
+  if (session.workspaceCwd === void 0) return void 0;
+  if (session.supersededBy !== void 0) return void 0;
+  if (!path2.isAbsolute(session.workspaceCwd) || !path2.isAbsolute(session.originalCwd)) {
+    logWorktreeCleanupPreserve(
+      sessionId,
+      "sidecar base is not an absolute path"
+    );
+    return void 0;
+  }
+  if (runtimeWorkspaceCwd !== void 0) {
+    if (canonicalPath(session.workspaceCwd) !== canonicalPath(runtimeWorkspaceCwd)) {
+      logWorktreeCleanupPreserve(
+        sessionId,
+        "sidecar belongs to another workspace"
+      );
+      return void 0;
+    }
+    const workspaceRoots = [canonicalPath(runtimeWorkspaceCwd)];
+    try {
+      const repoTop = await new GitWorktreeService(
+        runtimeWorkspaceCwd
+      ).getRepoTopLevel();
+      if (repoTop && canonicalPath(repoTop) !== workspaceRoots[0]) {
+        workspaceRoots.push(canonicalPath(repoTop));
+      }
+    } catch {
+    }
+    if (!workspaceRoots.includes(canonicalPath(session.originalCwd))) {
+      logWorktreeCleanupPreserve(
+        sessionId,
+        "sidecar original cwd is outside the accepted roots"
+      );
+      return void 0;
+    }
+  }
+  return {
+    sessionId,
+    sidecar: session,
+    sidecarPath,
+    lockKey: canonicalPath(session.worktreePath)
+  };
+}
+__name(preclassifyWorktreeCleanup, "preclassifyWorktreeCleanup");
+function acquireWorktreeCleanupLock(plan) {
+  return acquireWorktreeOwnershipOp(plan.lockKey);
+}
+__name(acquireWorktreeCleanupLock, "acquireWorktreeCleanupLock");
+async function worktreeAllowedRoots(workspaceCwd, originalCwd) {
+  const roots = /* @__PURE__ */ new Set();
+  for (const base of [workspaceCwd, originalCwd]) {
+    if (!path2.isAbsolute(base)) continue;
+    roots.add(path2.join(base, ".qwen", "worktrees"));
+    try {
+      const repoTop = await new GitWorktreeService(base).getRepoTopLevel();
+      if (repoTop) {
+        roots.add(path2.join(repoTop, ".qwen", "worktrees"));
+      }
+    } catch {
+    }
+  }
+  return [...roots];
+}
+__name(worktreeAllowedRoots, "worktreeAllowedRoots");
+async function verifyWorktreeCleanupOwnership(plan) {
+  const { sessionId, sidecar } = plan;
+  const locked = await readWorktreeSessionStrict(plan.sidecarPath);
+  if (locked.state !== "valid") {
+    return {
+      ok: false,
+      reason: locked.state === "missing" ? "sidecar disappeared before delete" : `unreadable sidecar (${locked.reason})`
+    };
+  }
+  const current = locked.session;
+  if (current.workspaceCwd === void 0 || current.supersededBy !== void 0 || current.slug !== sidecar.slug || current.worktreePath !== sidecar.worktreePath || current.originalCwd !== sidecar.originalCwd || current.workspaceCwd !== sidecar.workspaceCwd) {
+    return { ok: false, reason: "sidecar changed before delete" };
+  }
+  const marker = await readWorktreeSessionMarkerStrict(plan.lockKey);
+  if (marker.state !== "valid" || marker.sessionId !== sessionId) {
+    return {
+      ok: false,
+      reason: marker.state === "valid" ? "marker names another session" : `marker ${marker.state}`
+    };
+  }
+  const allowedRoots = await worktreeAllowedRoots(
+    current.workspaceCwd,
+    current.originalCwd
+  );
+  const contained = allowedRoots.some((root) => {
+    try {
+      const realRoot = fs.realpathSync(root);
+      return plan.lockKey === realRoot || plan.lockKey.startsWith(realRoot + path2.sep);
+    } catch {
+      return false;
+    }
+  });
+  if (!contained) {
+    return { ok: false, reason: "checkout outside workspace worktree roots" };
+  }
+  const chatsDir = path2.dirname(plan.sidecarPath);
+  const ownFile = path2.basename(plan.sidecarPath);
+  let entries;
+  try {
+    entries = await fsp.readdir(chatsDir);
+  } catch (error) {
+    return {
+      ok: false,
+      reason: `sidecar scan failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  for (const entry of entries) {
+    if (!entry.endsWith(".worktree.json") || entry === ownFile) continue;
+    const other = await readWorktreeSessionStrict(path2.join(chatsDir, entry));
+    if (other.state === "missing") continue;
+    if (other.state === "invalid") {
+      return { ok: false, reason: `unreadable sibling sidecar ${entry}` };
+    }
+    if (canonicalPath(other.session.worktreePath) === plan.lockKey) {
+      if (other.session.supersededBy === sessionId) continue;
+      return { ok: false, reason: `checkout shared with ${entry}` };
+    }
+  }
+  const removalTarget = canonicalPath(
+    new GitWorktreeService(current.originalCwd).getUserWorktreePath(
+      current.slug
+    )
+  );
+  if (removalTarget !== plan.lockKey) {
+    return {
+      ok: false,
+      reason: "slug does not resolve to the verified checkout"
+    };
+  }
+  plan.sidecar = current;
+  return { ok: true };
+}
+__name(verifyWorktreeCleanupOwnership, "verifyWorktreeCleanupOwnership");
+async function checkoutStillPopulated(worktreePath) {
+  try {
+    return (await fsp.readdir(worktreePath)).length > 0;
+  } catch {
+    return false;
+  }
+}
+__name(checkoutStillPopulated, "checkoutStillPopulated");
+async function executeWorktreeCleanup(plan) {
+  const { sessionId, sidecar } = plan;
+  const marker = await readWorktreeSessionMarkerStrict(plan.lockKey);
+  if (marker.state !== "valid" || marker.sessionId !== sessionId) {
+    logWorktreeCleanupPreserve(sessionId, "marker changed after delete");
+    return;
+  }
+  if (await checkoutHasWork(plan.lockKey)) {
+    logWorktreeCleanupPreserve(sessionId, "checkout has uncommitted work");
+    return;
+  }
+  const result = await new GitWorktreeService(
+    sidecar.originalCwd
+  ).removeUserWorktree(sidecar.slug, { deleteBranch: true });
+  if (!result.success) {
+    const errorText = result.error ?? "unknown error";
+    if (await checkoutStillPopulated(plan.lockKey)) {
+      logWorktreeCleanupPreserve(
+        sessionId,
+        `checkout removal failed: ${errorText}`
+      );
+    } else {
+      logWarning(
+        `worktree cleanup removal failed, checkout may be partially deleted action=delete session=${safeLogValue(
+          sessionId
+        )} reason=${safeLogValue(errorText)}`
+      );
+    }
+    return;
+  }
+  if (result.branchPreserved) {
+    logWarning(
+      `worktree cleanup removed checkout but kept branch action=delete session=${safeLogValue(
+        sessionId
+      )} slug=${safeLogValue(sidecar.slug)} branch=${safeLogValue(
+        sidecar.worktreeBranch
+      )} reason=unmerged commits`
+    );
+  }
+}
+__name(executeWorktreeCleanup, "executeWorktreeCleanup");
+
 // packages/cli/src/serve/server/session-archive.ts
 var DaemonDrainingError = class extends Error {
   static {
@@ -1755,6 +2052,7 @@ async function deleteDaemonSessions(params) {
     coordinator,
     coordinatorLockHeld = false,
     assertCanMutate,
+    runtimeWorkspaceCwd,
     onError
   } = params;
   const uniqueSessionIds = [
@@ -1765,6 +2063,49 @@ async function deleteDaemonSessions(params) {
       coordinator.assertNotTransitioning(sessionId);
     }
   }
+  const runWithWorktreeCleanup = /* @__PURE__ */ __name(async (sessionId, mutateSession) => {
+    const activeSidecarPath = service.getWorktreeSessionPath(sessionId);
+    const archivedSidecarPath = service.getWorktreeSessionPathForArchiveState(
+      sessionId,
+      "archived"
+    );
+    if (!fs2.existsSync(activeSidecarPath) && (archivedSidecarPath === activeSidecarPath || !fs2.existsSync(archivedSidecarPath))) {
+      return coordinator.runExclusiveMany([sessionId], mutateSession);
+    }
+    const cleanupPlan = await preclassifyWorktreeCleanup(
+      service,
+      sessionId,
+      runtimeWorkspaceCwd
+    );
+    if (!cleanupPlan) {
+      return coordinator.runExclusiveMany([sessionId], mutateSession);
+    }
+    const releaseCleanupLock = await acquireWorktreeCleanupLock(cleanupPlan);
+    try {
+      const ownership = await verifyWorktreeCleanupOwnership(cleanupPlan);
+      if (!ownership.ok) {
+        logWorktreeCleanupPreserve(sessionId, ownership.reason);
+      }
+      const result = await coordinator.runExclusiveMany(
+        [sessionId],
+        mutateSession
+      );
+      if (ownership.ok && result.kind === "removed") {
+        try {
+          assertCanMutate?.();
+          await executeWorktreeCleanup(cleanupPlan);
+        } catch (error) {
+          logWorktreeCleanupPreserve(
+            sessionId,
+            `cleanup execution failed: ${errorMessage(error)}`
+          );
+        }
+      }
+      return result;
+    } finally {
+      releaseCleanupLock();
+    }
+  }, "runWithWorktreeCleanup");
   const results = await Promise.all(
     uniqueSessionIds.map(async (sessionId) => {
       try {
@@ -1810,7 +2151,7 @@ async function deleteDaemonSessions(params) {
           try {
             await bridge.closeSession(sessionId);
           } catch (error) {
-            if (isSessionNotFoundError(error)) {
+            if (isSessionNotFoundError(error) && error.code !== "session_closing") {
               return await removePersistedSession();
             }
             onError?.({
@@ -1826,7 +2167,7 @@ async function deleteDaemonSessions(params) {
           }
           return await removePersistedSession();
         }, "mutateSession");
-        return await (coordinatorLockHeld ? mutateSession() : coordinator.runExclusiveMany([sessionId], mutateSession));
+        return await (coordinatorLockHeld ? mutateSession() : runWithWorktreeCleanup(sessionId, mutateSession));
       } catch (error) {
         if (error instanceof DaemonDrainingError) {
           throw error;
@@ -2361,12 +2702,12 @@ __name(unarchiveDaemonSessions, "unarchiveDaemonSessions");
 
 // packages/cli/src/serve/server/aone-mrs.ts
 init_esbuild_shims();
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-var execFileAsync = promisify(execFile);
+import { execFile as execFile2 } from "node:child_process";
+import { promisify as promisify2 } from "node:util";
+var execFileAsync2 = promisify2(execFile2);
 var a1AvailabilityVerified = false;
 var defaultA1Exec = /* @__PURE__ */ __name(async (args, options) => {
-  const { stdout } = await execFileAsync("a1", [...args], {
+  const { stdout } = await execFileAsync2("a1", [...args], {
     ...options,
     encoding: "utf8",
     windowsHide: true
@@ -2409,7 +2750,7 @@ async function resolveAoneWorkspaceRepo(workspaceCwd, env) {
   if (!gitRoot) return void 0;
   let origin;
   try {
-    ({ stdout: origin } = await execFileAsync(
+    ({ stdout: origin } = await execFileAsync2(
       "git",
       ["remote", "get-url", "origin"],
       {
@@ -2578,6 +2919,7 @@ export {
   parseSessionPageSizeQuery,
   runWithWorkspaceRuntimeStorage,
   createWorkspaceRuntimeSessionService,
+  acquireWorktreeOwnershipOp,
   DaemonDrainingError,
   SessionArchiveCoordinator,
   deleteDaemonSessions,

package/chunks/{chunk-REDVV5NC.js → chunk-7WCJEY3A.js}

@@ -2,12 +2,12 @@
 "use strict";
 import {
   buildPermissionSettings
-} from "./chunk-75UQFGFE.js";
+} from "./chunk-FN4KHWCL.js";
 import {
   resolveVoiceStreamConfig,
   resolveVoiceTranscriptionConfig,
   transcribeVoiceAudio
-} from "./chunk-Z6DDPSGJ.js";
+} from "./chunk-GNY7B3CA.js";
 import {
   getVoiceSettingsScope,
   isSelectableVoiceModel,
@@ -16,7 +16,7 @@ import {
   readVoiceMode,
   readVoiceModel,
   resolveVoiceTransport
-} from "./chunk-JOV46WGX.js";
+} from "./chunk-NB3NDQQK.js";
 import {
   MCP_RESTART_SERVER_DEADLINE_MS
 } from "./chunk-OCPBI7J5.js";
@@ -47,19 +47,19 @@ import {
   WorkspaceInitPathEscapeError,
   WorkspaceInitRaceError,
   WorkspaceInitSymlinkError
-} from "./chunk-F47DITLZ.js";
+} from "./chunk-FAWTMDX7.js";
 import {
   getPersistScopeForModelSelection,
   loadSettings
-} from "./chunk-RUMSY4ES.js";
+} from "./chunk-Y7YHAY32.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-GEV66YGE.js";
+} from "./chunk-D6AGS266.js";
 import {
   ModelsConfig,
   SkillManager,
   require_yauzl
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-BDAVT6K2.js";
 import {
   Storage,
   createDebugLogger

package/chunks/{chunk-I67KJGM6.js → chunk-A7QZIGRB.js}

@@ -5,15 +5,15 @@ import {
 } from "./chunk-47ECGEJC.js";
 import {
   t
-} from "./chunk-LD53HMPV.js";
+} from "./chunk-CRZBDVP2.js";
 import {
   findProviderByCredentials,
   resolveMetadataKey
-} from "./chunk-TXAEXF2B.js";
+} from "./chunk-PLEBBGHL.js";
 import {
   fetchGitDiff,
   isCompressionFailureStatus
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-BDAVT6K2.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-SHX2HIE7.js → chunk-ATBLEXXV.js}

@@ -14,12 +14,17 @@ import {
 init_esbuild_shims();
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.23.1-preview.2";
+  return "0.23.2-nightly.20260909.2e212144d3";
 }
 __name(getCliVersion, "getCliVersion");
+function formatVersionLabel(version) {
+  return /^\d/.test(version) ? `v${version}` : version;
+}
+__name(formatVersionLabel, "formatVersionLabel");
 
 export {
-  getCliVersion
+  getCliVersion,
+  formatVersionLabel
 };
 /**
  * @license

package/chunks/{chunk-RH344FKI.js → chunk-AUTUFD5X.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   resolvePath
-} from "./chunk-65GHQ4FX.js";
+} from "./chunk-WDVV3LRM.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-AXMWHKXA.js

@@ -0,0 +1,42 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/core/openaiContentGenerator/constants.ts
+init_esbuild_shims();
+var DEFAULT_TIMEOUT = 12e4;
+var DISABLED_REQUEST_TIMEOUT_MS = 2147483647;
+function resolveRequestTimeout(timeout) {
+  if (timeout === void 0 || timeout === null) {
+    return DEFAULT_TIMEOUT;
+  }
+  return timeout <= 0 ? DISABLED_REQUEST_TIMEOUT_MS : timeout;
+}
+__name(resolveRequestTimeout, "resolveRequestTimeout");
+var DEFAULT_STREAM_IDLE_TIMEOUT_MS = 24e4;
+var QWEN_STREAM_IDLE_TIMEOUT_MS_ENV = "QWEN_STREAM_IDLE_TIMEOUT_MS";
+var MAX_STREAM_GUARD_TIMEOUT_MS = 2147483647;
+var DEFAULT_STREAM_MAX_LIFETIME_MS = 9e5;
+var QWEN_STREAM_MAX_LIFETIME_MS_ENV = "QWEN_STREAM_MAX_LIFETIME_MS";
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
+var DEFAULT_DASHSCOPE_BASE_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1";
+var DASHSCOPE_PROXY_BASE_URL = process.env["DASHSCOPE_PROXY_BASE_URL"];
+
+export {
+  resolveRequestTimeout,
+  DEFAULT_STREAM_IDLE_TIMEOUT_MS,
+  QWEN_STREAM_IDLE_TIMEOUT_MS_ENV,
+  MAX_STREAM_GUARD_TIMEOUT_MS,
+  DEFAULT_STREAM_MAX_LIFETIME_MS,
+  QWEN_STREAM_MAX_LIFETIME_MS_ENV,
+  DEFAULT_MAX_RETRIES,
+  DEFAULT_OPENAI_BASE_URL,
+  DEFAULT_DASHSCOPE_BASE_URL,
+  DASHSCOPE_PROXY_BASE_URL
+};

package/chunks/{chunk-WFXD5OZH.js → chunk-AXWTG6R7.js}

@@ -4,9 +4,6 @@ import {
   MAX_WORKSPACE_PATH_LENGTH,
   canonicalizeWorkspace
 } from "./chunk-6PLDPT2C.js";
-import {
-  MAX_DAEMON_WORKSPACES
-} from "./chunk-5HBA2Z7V.js";
 import {
   getGlobalQwenDirLite
 } from "./chunk-IDS7MSUP.js";
@@ -38,7 +35,7 @@ import * as path from "node:path";
 
 // packages/cli/src/serve/workspace-inputs.ts
 init_esbuild_shims();
-var MAX_REGISTERED_WORKSPACES = MAX_DAEMON_WORKSPACES;
+var MAX_REGISTERED_WORKSPACES = 25;
 var DuplicateWorkspaceInputError = class extends Error {
   static {
     __name(this, "DuplicateWorkspaceInputError");
@@ -568,7 +565,7 @@ var WorkspaceRegistrationStore = class {
     return removed;
   }
   async update(mutate) {
-    const { atomicWriteFile } = await import("./deferred-core-runtime-DWOXIU5S.js");
+    const { atomicWriteFile } = await import("./deferred-core-runtime-D2RF35BL.js");
     return withInProcessLock(this.filePath, async () => {
       const lock = await acquireFileLock(this.filePath);
       let committed = false;