@qwen-code/qwen-code 0.23.1-preview.1 → 0.23.1

package/chunks/{chunk-URSCX7S7.js → chunk-ZPL2TZNA.js}

@@ -23,10 +23,11 @@ import {
   SessionConflictError,
   SessionNotArchivedError,
   SessionNotFoundError
-} from "./chunk-F47DITLZ.js";
+} from "./chunk-FAWTMDX7.js";
 import {
-  readWorktreeSession
-} from "./chunk-VUSSAGKI.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-I72PHOKL.js";
+} from "./chunk-PDUMGZ2P.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,