deepspace 0.9.2 → 0.9.3

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # deepspace
 
+## 0.9.3
+
+### Patch Changes
+
+- Prevent workspace cleanup from deleting unpublished or concurrently advanced commits.
+
 ## 0.9.2
 
 ### Patch Changes

package/dist/cli.js

@@ -10305,6 +10305,36 @@ function inOwnLinkedWorktree(appDir, id) {
     return false;
   }
 }
+function inspectWorkspaceCleanup(appDir, id) {
+  const branch = workspaceBranchName(id);
+  const branchOid = resolveCommit(appDir, `refs/heads/${branch}`);
+  const worktrees = listWorktrees(appDir);
+  const checkoutIndex = worktrees.findIndex((worktree) => worktree.branch === branch);
+  if (checkoutIndex < 0) {
+    return {
+      branch,
+      branchOid,
+      checkout: { kind: "none", dir: null },
+      willDeleteBranch: branchOid !== null
+    };
+  }
+  const dir = worktrees[checkoutIndex].path;
+  if (checkoutIndex === 0) {
+    return {
+      branch,
+      branchOid,
+      checkout: { kind: "primary", dir },
+      willDeleteBranch: branchOid !== null
+    };
+  }
+  const managed = isManagedWorkspaceWorktree(dir, id);
+  return {
+    branch,
+    branchOid,
+    checkout: { kind: managed ? "managed-linked" : "external-linked", dir },
+    willDeleteBranch: branchOid !== null && managed
+  };
+}
 function cleanupJson(outcome) {
   return {
     worktreeRemoved: outcome.worktreeRemoved,
@@ -10314,11 +10344,27 @@ function cleanupJson(outcome) {
     ...outcome.error ? { error: outcome.error } : {}
   };
 }
-function deleteWsBranch(cwd, branch, out) {
-  const del3 = runGit(cwd, ["branch", "-D", branch], { allowFail: true });
-  if (del3.status === 0) out.branchDeleted = branch;
-  else
-    out.error ??= `git branch -D ${branch} failed: ${del3.stderr.toString("utf-8").trim() || "unknown git error"}`;
+function deleteWsBranch(cwd, branch, expectedOid, out) {
+  const ref = `refs/heads/${branch}`;
+  const currentOid = resolveCommit(cwd, ref);
+  if (!currentOid) return;
+  const approvedOid = expectedOid ?? currentOid;
+  if (currentOid !== approvedOid) {
+    out.error ??= `branch ${branch} advanced from ${approvedOid.slice(0, 10)} to ${currentOid.slice(0, 10)} during cleanup; retained the branch`;
+    return;
+  }
+  const del3 = runGit(cwd, ["update-ref", "-d", ref, approvedOid], { allowFail: true });
+  if (del3.status === 0) {
+    out.branchDeleted = branch;
+    runGit(cwd, ["config", "--remove-section", `branch.${branch}`], { allowFail: true });
+    return;
+  }
+  const afterOid = resolveCommit(cwd, ref);
+  if (afterOid && afterOid !== approvedOid) {
+    out.error ??= `branch ${branch} advanced from ${approvedOid.slice(0, 10)} to ${afterOid.slice(0, 10)} during cleanup; retained the branch`;
+  } else if (afterOid) {
+    out.error ??= `could not delete branch ${branch}: ${del3.stderr.toString("utf-8").trim() || "unknown git error"}`;
+  }
 }
 function switchOffWsBranch(mainDir, trunkBranch) {
   if (trunkBranch) {
@@ -10332,8 +10378,10 @@ function switchOffWsBranch(mainDir, trunkBranch) {
   }
   return runGit(mainDir, ["switch", "--quiet", "--detach"], { allowFail: true }).status === 0;
 }
-function cleanupWorkspaceLocal(appDir, id, trunkBranch) {
-  const branch = workspaceBranchName(id);
+function cleanupWorkspaceLocal(appDir, id, trunkBranch, options = {}) {
+  const inspection = inspectWorkspaceCleanup(appDir, id);
+  const { branch } = inspection;
+  const expectedBranchOid = options.expectedBranchOid ?? inspection.branchOid;
   const out = {
     worktreeRemoved: null,
     worktreeRetained: null,
@@ -10341,6 +10389,10 @@ function cleanupWorkspaceLocal(appDir, id, trunkBranch) {
     worktreeDir: null,
     branch
   };
+  if (options.retainLocal) {
+    out.worktreeRetained = inspection.checkout.dir;
+    return out;
+  }
   try {
     const worktrees = listWorktrees(appDir);
     const mainDir = worktrees[0]?.path ?? repoToplevel(appDir);
@@ -10367,14 +10419,15 @@ function cleanupWorkspaceLocal(appDir, id, trunkBranch) {
         return out;
       }
       out.worktreeRemoved = linked.path;
-      deleteWsBranch(mainDir, branch, out);
+      out.worktreeDir = null;
+      deleteWsBranch(mainDir, branch, expectedBranchOid, out);
       return out;
     }
     if (currentBranch(mainDir) === branch && !switchOffWsBranch(mainDir, trunkBranch)) {
       out.error = `could not switch off ${branch} to delete it`;
       return out;
     }
-    if (resolveCommit(mainDir, `refs/heads/${branch}`)) deleteWsBranch(mainDir, branch, out);
+    deleteWsBranch(mainDir, branch, expectedBranchOid, out);
     return out;
   } catch (err) {
     out.error = err instanceof Error ? err.message : String(err);
@@ -11344,7 +11397,7 @@ var landWorkspaceCommand = defineDeepspaceCommand({
     }
     await api4.landWorkspace(id, { landedOid, intoRef });
     spinner2?.stop(`Landed ${id} into ${intoBranch} at ${landedOid.slice(0, 10)}.`);
-    const cleanup = keepWorktree ? null : cleanupWorkspaceLocal(appDir, id, intoBranch);
+    const cleanup = keepWorktree ? null : cleanupWorkspaceLocal(appDir, id, intoBranch, { expectedBranchOid: landedOid });
     const inOwnWorktree = !cleanup && inOwnLinkedWorktree(appDir, id);
     const retainedWorktree = cleanup?.worktreeRetained ?? (keepWorktree || inOwnWorktree ? appDir : null);
     const data = {
@@ -11381,6 +11434,24 @@ var landWorkspaceCommand = defineDeepspaceCommand({
 
 // src/cli/commands/workspace/drop.ts
 import * as p32 from "@clack/prompts";
+function isWorkspaceTipPublished(appDir, localTip, publishedOids) {
+  return publishedOids.some(
+    (publishedOid) => publishedOid === localTip || isAncestor(appDir, localTip, publishedOid)
+  );
+}
+function workspaceUnsyncedRefusal(args) {
+  const syncArgv = ["deepspace", "workspace", "sync", "--app", args.appId, "--workspace", args.id];
+  const dropArgv = ["deepspace", "workspace", "drop", args.id, "--app", args.appId];
+  const publish2 = args.workspaceDir ? `Publish them first with \`${humanCommand(syncArgv)}\`, then re-run \`${humanCommand(dropArgv)}\`.` : `Recreate a worktree from the branch (\`git worktree add <dir> ${args.branch}\`), publish from there with \`${humanCommand(syncArgv)}\`, then re-run \`${humanCommand(dropArgv)}\`.`;
+  return new Refusal(
+    `${args.id} has committed work that isn't published yet. ${publish2} Alternatively, pass \`--keep-worktree\` to drop the cloud workspace while retaining the local branch/worktree for manual disposal. Nothing was dropped.`,
+    "workspace_unsynced",
+    {
+      ...args.workspaceDir ? { action: { cwd: args.workspaceDir, argv: syncArgv } } : {},
+      extra: { workspaceId: args.id }
+    }
+  );
+}
 var dropWorkspaceCommand = defineDeepspaceCommand({
   meta: { name: "drop", description: "Abandon a workspace (ref retained briefly, then GC)" },
   args: {
@@ -11414,24 +11485,44 @@ var dropWorkspaceCommand = defineDeepspaceCommand({
       }
       return { data: { workspaceId: explicitId, status: view2.workspace.status } };
     }
-    const { appDir, api: api4 } = await resolveTarget2(appArg);
+    const { appDir, appId, api: api4 } = await resolveTarget2(appArg);
     const id = inferWorkspaceId(appDir, explicitId);
-    const ownLinkedWorktree = inOwnLinkedWorktree(appDir, id);
-    const cleanupOwnsCheckout = !ownLinkedWorktree || isManagedWorkspaceWorktree(appDir, id);
-    if (!keepWorktree && cleanupOwnsCheckout && !isWorkTreeClean(appDir)) {
-      const dropArgv = ["deepspace", "workspace", "drop", ...explicitId ? [explicitId] : []];
+    const inspection = inspectWorkspaceCleanup(appDir, id);
+    let approvedBranchOid;
+    if (!keepWorktree && inspection.willDeleteBranch && inspection.branchOid) {
+      const { view: before } = await api4.getWorkspace(id);
+      const publishedOids = [
+        before.tipOid,
+        before.workspace.landedOid,
+        before.workspace.baseOid
+      ].filter((oid) => oid !== null);
+      if (!isWorkspaceTipPublished(appDir, inspection.branchOid, publishedOids)) {
+        throw workspaceUnsyncedRefusal({
+          appId,
+          id,
+          branch: inspection.branch,
+          workspaceDir: inspection.checkout.dir
+        });
+      }
+      approvedBranchOid = inspection.branchOid;
+    }
+    const cleanupDir = inspection.willDeleteBranch ? inspection.checkout.dir : null;
+    if (!keepWorktree && cleanupDir && !isWorkTreeClean(cleanupDir)) {
+      const dropArgv = ["deepspace", "workspace", "drop", id, "--app", appId];
       const dropNext = humanCommand(dropArgv);
       throw new Refusal(
-        `The worktree has uncommitted changes and cleanup would remove it. Commit them to the workspace branch and re-run \`${dropNext}\`, or pass \`--keep-worktree\` to drop while keeping the worktree. Nothing was dropped.`,
+        `The workspace checkout has uncommitted changes and cleanup would remove it or switch it off ${inspection.branch}. Commit them and re-run \`${dropNext}\`, or pass \`--keep-worktree\` to drop while retaining the checkout. Nothing was dropped.`,
         "dirty_worktree",
         { extra: { workspaceId: id } }
       );
     }
     const { view } = await api4.dropWorkspace(id);
     spinner2?.message(`Cleaning up ${id} locally\u2026`);
-    const cleanup = keepWorktree ? null : cleanupWorkspaceLocal(appDir, id, null);
-    const inOwnWorktree = !cleanup && ownLinkedWorktree;
-    const retainedWorktree = cleanup?.worktreeRetained ?? (keepWorktree || inOwnWorktree ? appDir : null);
+    const cleanup = keepWorktree ? null : cleanupWorkspaceLocal(appDir, id, null, {
+      expectedBranchOid: approvedBranchOid,
+      retainLocal: !inspection.willDeleteBranch
+    });
+    const retainedWorktree = cleanup?.worktreeRetained ?? (keepWorktree ? inspection.checkout.dir : null);
     const data = {
       workspaceId: id,
       status: view.workspace.status,