diff --git a/apps/desktop/src/renderer/hooks/host-service/useDestroyWorkspace/useDestroyWorkspace.ts b/apps/desktop/src/renderer/hooks/host-service/useDestroyWorkspace/useDestroyWorkspace.ts index 745fdeb215a..c9eac9bce10 100644 --- a/apps/desktop/src/renderer/hooks/host-service/useDestroyWorkspace/useDestroyWorkspace.ts +++ b/apps/desktop/src/renderer/hooks/host-service/useDestroyWorkspace/useDestroyWorkspace.ts @@ -22,6 +22,9 @@ export interface DestroyWorkspaceInput { /** Consent to abandon the teardown script — only the teardown-failed * retry sets this. */ skipTeardown?: boolean; + /** Only for this machine's host: the relay gives up on a request after + * about a minute, and a long dirty check can outlast that. */ + longPreflight?: boolean; } export interface DestroyWorkspaceSuccess { @@ -84,6 +87,7 @@ export async function destroyWorkspaceAtHost( deleteBranch: input.deleteBranch ?? false, force: input.force ?? false, skipTeardown: input.skipTeardown ?? false, + longPreflight: input.longPreflight ?? false, }); } catch (error) { throw normalizeDestroyWorkspaceError(error); @@ -163,10 +167,10 @@ export function useDestroyWorkspace(workspaceId: string): UseDestroyWorkspace { } return destroyWorkspaceAtHost( { workspaceId, hostUrl, hostStatus }, - input, + { ...input, longPreflight: hostUrl === activeHostUrl }, ); }, - [hostUrl, hostStatus, isSandbox, utils, workspaceId], + [activeHostUrl, hostUrl, hostStatus, isSandbox, utils, workspaceId], ); const inspect = useCallback(async (): Promise => { diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/components/DashboardSidebarBulkDeleteDialog/hooks/useBulkWorkspaceDelete/useBulkWorkspaceDelete.ts b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/components/DashboardSidebarBulkDeleteDialog/hooks/useBulkWorkspaceDelete/useBulkWorkspaceDelete.ts index b7b992eb169..28229219d49 100644 --- a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/components/DashboardSidebarBulkDeleteDialog/hooks/useBulkWorkspaceDelete/useBulkWorkspaceDelete.ts +++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/components/DashboardSidebarBulkDeleteDialog/hooks/useBulkWorkspaceDelete/useBulkWorkspaceDelete.ts @@ -19,6 +19,7 @@ import type { DashboardSidebarWorkspace } from "renderer/routes/_authenticated/_ import { useDeletingWorkspacesStore } from "renderer/routes/_authenticated/_dashboard/stores/deletingWorkspacesStore"; import { useDashboardSidebarState } from "renderer/routes/_authenticated/hooks/useDashboardSidebarState"; import { useHostWorkspaces } from "renderer/routes/_authenticated/providers/HostWorkspacesProvider"; +import { useLocalHostService } from "renderer/routes/_authenticated/providers/LocalHostServiceProvider"; import { type BulkWorkspaceInspectionState, buildBulkWorkspaceInspectionSummary, @@ -75,6 +76,7 @@ export function useBulkWorkspaceDelete({ }: UseBulkWorkspaceDeleteOptions) { const { t } = useLingui(); const { cache: hostWorkspacesCache } = useHostWorkspaces(); + const { activeHostUrl } = useLocalHostService(); const { navigateAwayFromWorkspace } = useNavigateAwayFromWorkspace(); const { removeWorkspaceFromSidebar } = useDashboardSidebarState(); const { preferences, setDeleteLocalBranch } = useV2UserPreferences(); @@ -217,12 +219,15 @@ export function useBulkWorkspaceDelete({ shouldRetryWithForce: (workspace, error) => error.kind === "conflict" && inspections.get(workspace.id)?.status !== "ready", - destroy: (workspace, force) => - destroyWorkspaceAtHost(targetFor(workspace), { + destroy: (workspace, force) => { + const target = targetFor(workspace); + return destroyWorkspaceAtHost(target, { deleteBranch: preferences.deleteLocalBranch, force, skipTeardown, - }), + longPreflight: target.hostUrl === activeHostUrl, + }); + }, onSettled: () => { completedCount += 1; if (completedCount < total) { @@ -323,6 +328,7 @@ export function useBulkWorkspaceDelete({ } }, [ + activeHostUrl, hostWorkspacesCache, inspections, navigateAwayFromWorkspace, diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/components/DashboardSidebarDeleteDialog/hooks/useDestroyDialogState/useDestroyDialogState.ts b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/components/DashboardSidebarDeleteDialog/hooks/useDestroyDialogState/useDestroyDialogState.ts index cdaea015a61..84038a586a4 100644 --- a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/components/DashboardSidebarDeleteDialog/hooks/useDestroyDialogState/useDestroyDialogState.ts +++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/components/DashboardSidebarDeleteDialog/hooks/useDestroyDialogState/useDestroyDialogState.ts @@ -13,6 +13,7 @@ import { useV2UserPreferences } from "renderer/hooks/useV2UserPreferences/useV2U import { useNavigateAwayFromWorkspace } from "renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/hooks/useNavigateAwayFromWorkspace"; import { useDeletingWorkspacesStore } from "renderer/routes/_authenticated/_dashboard/stores/deletingWorkspacesStore"; import { useHostWorkspaces } from "renderer/routes/_authenticated/providers/HostWorkspacesProvider"; +import { canSilentlyForceRetry } from "../../utils/canSilentlyForceRetry"; interface UseDestroyDialogStateOptions { workspaceId: string; @@ -110,6 +111,7 @@ export function useDestroyDialogState({ }) => { if (inFlight.current) return; inFlight.current = true; + const inspectFinished = inspectState.status === "ready"; setError(null); onOpenChange(false); @@ -139,7 +141,7 @@ export function useDestroyDialogState({ // retry. Do NOT extend this to `in-progress` (that's a // different CONFLICT cause; retrying just races the same // guard). - if (e.kind === "conflict" && !force) { + if (canSilentlyForceRetry(e, { force, inspectFinished })) { result = await destroy({ deleteBranch, force: true, skipTeardown }); } else { throw firstErr; @@ -155,7 +157,7 @@ export function useDestroyDialogState({ onDeleted?.(); } catch (err) { const e = err as DestroyWorkspaceError; - if (e.kind === "teardown-failed") { + if (e.kind === "teardown-failed" || e.kind === "conflict") { setError(e); onOpenChange(true); } else if (e.kind === "in-progress") { @@ -179,6 +181,7 @@ export function useDestroyDialogState({ [ destroy, deleteBranch, + inspectState.status, workspaceName, workspaceId, onOpenChange, @@ -193,7 +196,7 @@ export function useDestroyDialogState({ return { deleteBranch, setDeleteBranch, - hasChanges: preview?.hasChanges ?? false, + hasChanges: preview?.hasChanges === true || error?.kind === "conflict", hasUnpushedCommits: preview?.hasUnpushedCommits ?? false, sharesProjectCheckout: preview?.canDelete === true && preview.sharesProjectCheckout === true, diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/components/DashboardSidebarDeleteDialog/utils/canSilentlyForceRetry.test.ts b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/components/DashboardSidebarDeleteDialog/utils/canSilentlyForceRetry.test.ts new file mode 100644 index 00000000000..e44f5eba17a --- /dev/null +++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/components/DashboardSidebarDeleteDialog/utils/canSilentlyForceRetry.test.ts @@ -0,0 +1,27 @@ +import { describe, expect, test } from "bun:test"; +import { canSilentlyForceRetry } from "./canSilentlyForceRetry"; + +const conflict = { kind: "conflict", message: "dirty" } as const; + +describe("canSilentlyForceRetry", () => { + test("retries a conflict after the dialog finished checking the worktree", () => { + expect( + canSilentlyForceRetry(conflict, { force: false, inspectFinished: true }), + ).toBe(true); + }); + + test("does not retry a conflict when the check never finished", () => { + expect( + canSilentlyForceRetry(conflict, { force: false, inspectFinished: false }), + ).toBe(false); + }); + + test("does not retry other failures", () => { + expect( + canSilentlyForceRetry( + { kind: "in-progress", message: "busy" }, + { force: false, inspectFinished: true }, + ), + ).toBe(false); + }); +}); diff --git a/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/components/DashboardSidebarDeleteDialog/utils/canSilentlyForceRetry.ts b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/components/DashboardSidebarDeleteDialog/utils/canSilentlyForceRetry.ts new file mode 100644 index 00000000000..de982be0822 --- /dev/null +++ b/apps/desktop/src/renderer/routes/_authenticated/_dashboard/components/DashboardSidebar/components/DashboardSidebarDeleteDialog/utils/canSilentlyForceRetry.ts @@ -0,0 +1,9 @@ +import type { DestroyWorkspaceError } from "renderer/hooks/host-service/useDestroyWorkspace"; + +/** A dirty worktree the dialog never checked has had no warning shown. */ +export function canSilentlyForceRetry( + error: DestroyWorkspaceError, + { force, inspectFinished }: { force: boolean; inspectFinished: boolean }, +): boolean { + return error.kind === "conflict" && !force && inspectFinished; +} diff --git a/packages/host-service/src/projects/project-deletion.test.ts b/packages/host-service/src/projects/project-deletion.test.ts index 936acc4c872..ff8208fbcd1 100644 --- a/packages/host-service/src/projects/project-deletion.test.ts +++ b/packages/host-service/src/projects/project-deletion.test.ts @@ -242,7 +242,7 @@ describe("interrupted-delete reconciler", () => { test("never deletes uncommitted files", async () => { const { ctx, addWorkspace, workspace } = setup(); const dirty = strand(addWorkspace, "dirty"); - cleanupGitOps.readWorktreeState = async () => + cleanupGitOps.readWorktreeStateUnattended = async () => ({ hasChanges: true }) as never; await runArchivedWorkspaceReconcile(ctx); expect(existsSync(dirty)).toBe(true); @@ -252,7 +252,7 @@ describe("interrupted-delete reconciler", () => { test("finishes a clean interrupted delete", async () => { const { ctx, addWorkspace, workspace } = setup(); const stranded = strand(addWorkspace, "stranded"); - cleanupGitOps.readWorktreeState = async () => + cleanupGitOps.readWorktreeStateUnattended = async () => ({ hasChanges: false }) as never; await runArchivedWorkspaceReconcile(ctx); expect(existsSync(stranded)).toBe(false); @@ -269,7 +269,7 @@ describe("interrupted-delete reconciler", () => { archivedAt: Date.now() + 1_000, archiveReason: "deleted", }); - cleanupGitOps.readWorktreeState = async () => + cleanupGitOps.readWorktreeStateUnattended = async () => ({ hasChanges: false }) as never; await runArchivedWorkspaceReconcile(ctx); expect(gitCalls).toEqual([]); @@ -333,6 +333,22 @@ describe("delete permanently", () => { expect(existsSync(repoPath)).toBe(true); }); + test("a worktree whose removal fails does not stop the others", async () => { + const { ctx, addWorkspace, project } = setup(); + const stuck = addWorkspace("stuck"); + const other = addWorkspace("other"); + const removeAndRecord = cleanupGitOps.removeWorktree; + cleanupGitOps.removeWorktree = async (input) => { + if (input.worktreePath === stuck) throw new Error("timed out"); + return removeAndRecord(input); + }; + await softDeleteProject(ctx, PROJECT_ID); + expect(await purgeDeletedProject(ctx, PROJECT_ID)).toBe(true); + expect(project()).toBeUndefined(); + expect(existsSync(stuck)).toBe(true); + expect(existsSync(other)).toBe(false); + }); + test("refuses a project that was never deleted", async () => { const { ctx, addWorkspace, gitCalls, project } = setup(); addWorkspace("live"); diff --git a/packages/host-service/src/projects/project-deletion.ts b/packages/host-service/src/projects/project-deletion.ts index 78f8b86d4a2..bd3457b6656 100644 --- a/packages/host-service/src/projects/project-deletion.ts +++ b/packages/host-service/src/projects/project-deletion.ts @@ -243,22 +243,32 @@ async function purgeProject( if (worktrees.length > 0) { try { const gitEnv = await cleanupGitOps.resolveGitEnv(ctx, project.repoPath); - for (const row of worktrees) { - const { stillRegistered, removeError } = - await cleanupGitOps.removeWorktree({ - repoPath: project.repoPath, - worktreePath: row.worktreePath, - gitEnv, - force: false, - }); - if (stillRegistered) { - console.warn("[project-deletion] left worktree on disk", { - projectId: project.id, - worktreePath: row.worktreePath, - removeError, - }); - } - } + await Promise.all( + worktrees.map(async (row) => { + try { + const { stillRegistered, removeError } = + await cleanupGitOps.removeWorktree({ + repoPath: project.repoPath, + worktreePath: row.worktreePath, + gitEnv, + force: false, + }); + if (stillRegistered) { + console.warn("[project-deletion] left worktree on disk", { + projectId: project.id, + worktreePath: row.worktreePath, + removeError, + }); + } + } catch (err) { + console.warn("[project-deletion] left worktree on disk", { + projectId: project.id, + worktreePath: row.worktreePath, + err, + }); + } + }), + ); } catch (err) { console.warn("[project-deletion] left worktrees on disk", { projectId: project.id, diff --git a/packages/host-service/src/runtime/archived-workspace-reconcile.ts b/packages/host-service/src/runtime/archived-workspace-reconcile.ts index e8855bf40b8..2d44754072d 100644 --- a/packages/host-service/src/runtime/archived-workspace-reconcile.ts +++ b/packages/host-service/src/runtime/archived-workspace-reconcile.ts @@ -72,6 +72,7 @@ export async function runArchivedWorkspaceReconcile( // uncommitted files block the delete and un-archive the row. force: false, teardownMode: "best-effort", + longPreflight: true, }); resumed++; } catch (err) { diff --git a/packages/host-service/src/trpc/router/workspace-cleanup/git-ops.ts b/packages/host-service/src/trpc/router/workspace-cleanup/git-ops.ts index 7fcee653888..832743e2c49 100644 --- a/packages/host-service/src/trpc/router/workspace-cleanup/git-ops.ts +++ b/packages/host-service/src/trpc/router/workspace-cleanup/git-ops.ts @@ -33,6 +33,36 @@ export function isIndeterminateGitTaskFailure(err: unknown): boolean { return err instanceof WorkerTaskError && err.name === "WorkerTaskError"; } +/** The delete dialog waits on this read. */ +export const INSPECT_WORKTREE_STATE_TIMEOUT_MS = 15_000; + +/** Runs after the row is archived, so nobody waits on it. */ +export const DESTROY_WORKTREE_STATE_TIMEOUT_MS = 10 * 60_000; + +/** A timeout kills git mid-delete, so this only stops a hung removal. */ +export const WORKTREE_REMOVE_TIMEOUT_MS = 30 * 60_000; + +/** Long delete tasks must not take every shared worker slot from status and diff reads. */ +export const MAX_CONCURRENT_LONG_DELETE_TASKS = 2; + +let activeLongDeleteTasks = 0; +const queuedLongDeleteTasks: Array<() => void> = []; + +async function withLongDeleteTaskSlot(run: () => Promise): Promise { + if (activeLongDeleteTasks < MAX_CONCURRENT_LONG_DELETE_TASKS) { + activeLongDeleteTasks++; + } else { + await new Promise((resolve) => queuedLongDeleteTasks.push(resolve)); + } + try { + return await run(); + } finally { + const next = queuedLongDeleteTasks.shift(); + if (next) next(); + else activeLongDeleteTasks--; + } +} + export const cleanupGitOps = { /** Same failure surface as `ctx.git(repoPath)` — a throw here maps to the * saga's "failed to open project repo" handling. */ @@ -49,12 +79,21 @@ export const cleanupGitOps = { gitEnv: GitTaskEnv; ignoreInitialCommit?: boolean; }, - signal?: AbortSignal, + options: { timeoutMs: number; signal?: AbortSignal }, ): Promise<{ hasChanges: boolean; hasUnpushedCommits: boolean }> { - return getHostWorkerPool().run(gitWorktreeStateTask, input, { - timeoutMs: 15_000, - signal, - }); + return getHostWorkerPool().run(gitWorktreeStateTask, input, options); + }, + + /** For a caller that does not wait on the answer (no dialog, no relay). */ + readWorktreeStateUnattended(input: { + worktreePath: string; + gitEnv: GitTaskEnv; + }): Promise<{ hasChanges: boolean; hasUnpushedCommits: boolean }> { + return withLongDeleteTaskSlot(() => + getHostWorkerPool().run(gitWorktreeStateTask, input, { + timeoutMs: DESTROY_WORKTREE_STATE_TIMEOUT_MS, + }), + ); }, removeWorktree(input: { @@ -63,12 +102,11 @@ export const cleanupGitOps = { gitEnv: GitTaskEnv; force?: boolean; }): Promise<{ stillRegistered: boolean; removeError?: string }> { - // Generous timeout: removal recursively deletes the worktree - // directory, which can take a while for large trees (node_modules - // etc.). - return getHostWorkerPool().run(gitWorktreeRemoveTask, input, { - timeoutMs: 120_000, - }); + return withLongDeleteTaskSlot(() => + getHostWorkerPool().run(gitWorktreeRemoveTask, input, { + timeoutMs: WORKTREE_REMOVE_TIMEOUT_MS, + }), + ); }, deleteLocalBranch(input: { diff --git a/packages/host-service/src/trpc/router/workspace-cleanup/workspace-cleanup.ts b/packages/host-service/src/trpc/router/workspace-cleanup/workspace-cleanup.ts index 9030a78f89f..7f6e7033cdc 100644 --- a/packages/host-service/src/trpc/router/workspace-cleanup/workspace-cleanup.ts +++ b/packages/host-service/src/trpc/router/workspace-cleanup/workspace-cleanup.ts @@ -16,6 +16,7 @@ import { import { disposeSessionsByWorkspaceId } from "../../../terminal/terminal"; import type { HostServiceContext } from "../../../types"; import type { GitTaskEnv } from "../../../workers/tasks/git"; +import { WorkerTaskAbortedError } from "../../../workers/WorkerTaskRunner"; import { archiveLocalWorkspace, trackWorkspaceDeleted, @@ -30,7 +31,11 @@ import { protectedProcedure, router } from "../../index"; import { getHostWorktreeBaseDir } from "../settings/worktree-location"; import { isInsideSessionsRoot } from "../workspace-creation/shared/session-paths"; import { isInsideProjectWorktreesRoot } from "../workspace-creation/shared/worktree-paths"; -import { cleanupGitOps, isIndeterminateGitTaskFailure } from "./git-ops"; +import { + cleanupGitOps, + INSPECT_WORKTREE_STATE_TIMEOUT_MS, + isIndeterminateGitTaskFailure, +} from "./git-ops"; import { isLocalCheckoutWorkspace } from "./is-local-checkout-workspace"; import { removeDirectoryTree } from "./remove-directory-tree"; @@ -86,6 +91,12 @@ export interface DestroyWorkspaceInput { * - "skip": don't run — the interactive force-retry contract. */ teardownMode: "blocking" | "best-effort" | "skip"; + /** + * The caller does not wait on a relay or show an unchecked dialog, so the + * dirty check may take minutes. Released desktops silently force-retry any + * CONFLICT, so without this the check keeps the dialog's budget. + */ + longPreflight?: boolean; } /** @@ -121,6 +132,7 @@ export const workspaceCleanupRouter = router({ * - hasChanges/Unpushed → render as warnings; user can still confirm. * - git failures (missing worktree, broken repo) → return as canDelete * with no warnings; the destroy saga handles those states best-effort. + * - timeout / pool failure → throw: the state is unknown, not clean. * * The git reads run in the host worker pool (gitWorktreeStateTask) so a * slow status on a large worktree can't block the event loop. @@ -155,7 +167,7 @@ export const workspaceCleanupRouter = router({ gitEnv, ignoreInitialCommit: local.type === "session", }, - signal, + { timeoutMs: INSPECT_WORKTREE_STATE_TIMEOUT_MS, signal }, ); return { canDelete: true, @@ -164,7 +176,16 @@ export const workspaceCleanupRouter = router({ hasUnpushedCommits: state.hasUnpushedCommits, sharesProjectCheckout: false, }; - } catch { + } catch (err) { + if (err instanceof WorkerTaskAbortedError && err.kind === "cancelled") { + throw new TRPCError({ code: "CLIENT_CLOSED_REQUEST", cause: err }); + } + if (isIndeterminateGitTaskFailure(err)) { + throw new TRPCError({ + code: "INTERNAL_SERVER_ERROR", + message: `Couldn't verify worktree state at ${local.worktreePath}: ${err instanceof Error ? err.message : String(err)}`, + }); + } return { canDelete: true, reason: null, @@ -232,6 +253,7 @@ export const workspaceCleanupRouter = router({ // anyway" must still run teardown, otherwise editing any // tracked file silently disables the user's cleanup script. skipTeardown: z.boolean().default(false), + longPreflight: z.boolean().default(false), }), ) .mutation(async ({ ctx, input }) => @@ -240,6 +262,7 @@ export const workspaceCleanupRouter = router({ deleteBranch: input.deleteBranch, force: input.force, teardownMode: input.skipTeardown ? "skip" : "blocking", + longPreflight: input.longPreflight, }), ), }); @@ -317,10 +340,15 @@ async function runDestroy( ctx, local.worktreePath, ); - const state = await cleanupGitOps.readWorktreeState({ - worktreePath: local.worktreePath, - gitEnv, - }); + const state = input.longPreflight + ? await cleanupGitOps.readWorktreeStateUnattended({ + worktreePath: local.worktreePath, + gitEnv, + }) + : await cleanupGitOps.readWorktreeState( + { worktreePath: local.worktreePath, gitEnv }, + { timeoutMs: INSPECT_WORKTREE_STATE_TIMEOUT_MS }, + ); if (state.hasChanges) { throw new TRPCError({ code: "CONFLICT", @@ -411,7 +439,14 @@ async function runDestroy( if (marked && local) trackWorkspaceDeleted(ctx, local); return result; } catch (err) { - if (marked) unarchiveLocalWorkspace(ctx, input.workspaceId); + if (marked) { + console.warn("[workspace-cleanup] delete failed; restoring workspace", { + workspaceId: input.workspaceId, + code: err instanceof TRPCError ? err.code : undefined, + error: err instanceof Error ? err.message : String(err), + }); + unarchiveLocalWorkspace(ctx, input.workspaceId); + } throw err; } } diff --git a/packages/host-service/src/workers/tasks/git-worktree-state.test.ts b/packages/host-service/src/workers/tasks/git-worktree-state.test.ts new file mode 100644 index 00000000000..9012a1c90fb --- /dev/null +++ b/packages/host-service/src/workers/tasks/git-worktree-state.test.ts @@ -0,0 +1,52 @@ +import { afterEach, beforeEach, describe, expect, test } from "bun:test"; +import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { simpleGit } from "simple-git"; +import { gitWorktreeStateTask } from "./git.ts"; + +const gitEnv = { + GIT_CONFIG_GLOBAL: "/dev/null", + GIT_CONFIG_NOSYSTEM: "1", +}; + +describe("gitWorktreeStateTask", () => { + let repoPath: string; + + beforeEach(async () => { + repoPath = mkdtempSync(join(tmpdir(), "worktree-state-")); + const git = simpleGit(repoPath); + await git.init(); + await git.raw(["config", "user.email", "test@example.com"]); + await git.raw(["config", "user.name", "test"]); + await git.raw(["config", "commit.gpgsign", "false"]); + writeFileSync(join(repoPath, ".gitignore"), "node_modules/\n"); + writeFileSync(join(repoPath, "tracked.txt"), "committed\n"); + await git.add([".gitignore", "tracked.txt"]); + await git.commit("initial"); + }); + + afterEach(() => { + rmSync(repoPath, { recursive: true, force: true }); + }); + + const readState = () => + gitWorktreeStateTask.handler({ worktreePath: repoPath, gitEnv }); + + test("ignored files do not make the worktree dirty", async () => { + mkdirSync(join(repoPath, "node_modules", "pkg"), { recursive: true }); + writeFileSync(join(repoPath, "node_modules", "pkg", "index.js"), "x"); + expect((await readState()).hasChanges).toBe(false); + }); + + test("a file deep inside an untracked directory makes the worktree dirty", async () => { + mkdirSync(join(repoPath, "generated", "a", "b"), { recursive: true }); + writeFileSync(join(repoPath, "generated", "a", "b", "out.js"), "x"); + expect((await readState()).hasChanges).toBe(true); + }); + + test("a modified tracked file makes the worktree dirty", async () => { + writeFileSync(join(repoPath, "tracked.txt"), "edited\n"); + expect((await readState()).hasChanges).toBe(true); + }); +}); diff --git a/packages/host-service/src/workers/tasks/git.ts b/packages/host-service/src/workers/tasks/git.ts index 36b21758a22..ab704d11dbc 100644 --- a/packages/host-service/src/workers/tasks/git.ts +++ b/packages/host-service/src/workers/tasks/git.ts @@ -328,7 +328,12 @@ export const gitWorktreeStateTask = defineWorkerTask< type: "git/worktreeState", handler: async ({ worktreePath, gitEnv, ignoreInitialCommit }) => { const git = createUserSimpleGit(worktreePath, { env: gitEnv }); - const status = await git.status(); + // Not `git.status()`: its `-u` lists every file in untracked directories. + const status = await git.raw([ + "status", + "--porcelain", + "--untracked-files=normal", + ]); let hasUnpushedCommits = false; try { const result = await git.raw([ @@ -344,7 +349,7 @@ export const gitWorktreeStateTask = defineWorkerTask< } catch { // Leave false — `rev-list` failure isn't a signal we can act on. } - return { hasChanges: !status.isClean(), hasUnpushedCommits }; + return { hasChanges: status.trim() !== "", hasUnpushedCommits }; }, }); diff --git a/packages/host-service/test/workspace-cleanup.test.ts b/packages/host-service/test/workspace-cleanup.test.ts index f6b8f99bc26..f82671b0a9d 100644 --- a/packages/host-service/test/workspace-cleanup.test.ts +++ b/packages/host-service/test/workspace-cleanup.test.ts @@ -14,7 +14,10 @@ import { import { tmpdir } from "node:os"; import { join } from "node:path"; import { workspaceRouter } from "../src/trpc/router/workspace"; -import { cleanupGitOps } from "../src/trpc/router/workspace-cleanup/git-ops"; +import { + cleanupGitOps, + MAX_CONCURRENT_LONG_DELETE_TASKS, +} from "../src/trpc/router/workspace-cleanup/git-ops"; import { isLocalCheckoutWorkspace } from "../src/trpc/router/workspace-cleanup/is-local-checkout-workspace"; import { __testDestroysInFlight, @@ -22,7 +25,11 @@ import { workspaceCleanupRouter, } from "../src/trpc/router/workspace-cleanup/workspace-cleanup"; import type { HostServiceContext } from "../src/types"; -import { WorkerTaskError } from "../src/workers/WorkerTaskRunner"; +import { getHostWorkerPool } from "../src/workers/host-worker-pool"; +import { + WorkerTaskAbortedError, + WorkerTaskError, +} from "../src/workers/WorkerTaskRunner"; type WorkspaceRow = { id: string; @@ -68,6 +75,12 @@ interface ContextSpec { let gitOpsSpec: ContextSpec = {}; const realGitOps = { ...cleanupGitOps }; + +function readSpecWorktreeState(): Promise | WorktreeState { + const state = gitOpsSpec.worktreeState; + if (typeof state === "function") return state(); + return state ?? { hasChanges: false, hasUnpushedCommits: false }; +} const realTeardownOps = { ...cleanupTeardownOps }; afterAll(() => { Object.assign(cleanupGitOps, realGitOps); @@ -79,11 +92,8 @@ Object.assign(cleanupGitOps, { if (gitOpsSpec.resolveGitEnvThrows) throw new Error("git env boom"); return {}; }, - readWorktreeState: async () => { - const state = gitOpsSpec.worktreeState; - if (typeof state === "function") return state(); - return state ?? { hasChanges: false, hasUnpushedCommits: false }; - }, + readWorktreeState: async () => readSpecWorktreeState(), + readWorktreeStateUnattended: async () => readSpecWorktreeState(), removeWorktree: async () => gitOpsSpec.removeWorktree ? gitOpsSpec.removeWorktree() @@ -336,6 +346,36 @@ describe("workspaceCleanup.inspect", () => { }); }); + test("a timed-out worktree-state read fails instead of reporting a clean worktree", async () => { + const ctx = makeCtx({ + ...wsAndProject, + worktreeState: () => + Promise.reject( + new WorkerTaskError( + '[host-worker] Task "git/worktreeState" timed out after 15000ms', + ), + ), + }); + const caller = workspaceCleanupRouter.createCaller(ctx); + await expect(caller.inspect({ workspaceId: "ws-1" })).rejects.toThrow( + /Couldn't verify worktree state/, + ); + }); + + test("a cancelled worktree-state read reports the closed request, not a server error", async () => { + const ctx = makeCtx({ + ...wsAndProject, + worktreeState: () => + Promise.reject(new WorkerTaskAbortedError("cancelled")), + }); + const caller = workspaceCleanupRouter.createCaller(ctx); + const error = await caller + .inspect({ workspaceId: "ws-1" }) + .then(() => null) + .catch((err: { code?: string }) => err); + expect(error?.code).toBe("CLIENT_CLOSED_REQUEST"); + }); + test("swallows git env-resolution failures and returns canDelete: true with no warnings", async () => { const ctx = makeCtx({ ...wsAndProject, @@ -1043,6 +1083,113 @@ describe("workspaceCleanup.destroy cleanup ordering", () => { ).rejects.toThrow(/Couldn't verify worktree state/); }); + async function destroyWithSlowStatus(longPreflight: boolean) { + // A `git status` that needs 5 min, as on a large worktree on a cold or + // busy disk: the pool rejects any shorter budget. + const pool = getHostWorkerPool(); + const realRun = pool.run; + const patched = { ...cleanupGitOps }; + pool.run = (async (_def, _input, options) => { + const timeoutMs = options?.timeoutMs ?? 0; + if (timeoutMs < 5 * 60_000) { + throw new WorkerTaskError( + `[host-worker] Task "git/worktreeState" timed out after ${timeoutMs}ms`, + ); + } + return { hasChanges: false, hasUnpushedCommits: false }; + }) as typeof pool.run; + cleanupGitOps.readWorktreeState = realGitOps.readWorktreeState; + cleanupGitOps.readWorktreeStateUnattended = + realGitOps.readWorktreeStateUnattended; + const worktree = mkdtempSync(join(tmpdir(), "workspace-delete-")); + const repo = mkdtempSync(join(tmpdir(), "workspace-delete-repo-")); + try { + const ctx = makeCtx({ + workspace: { + id: "ws-1", + projectId: "p-1", + worktreePath: worktree, + branch: "feature", + }, + project: { id: "p-1", repoPath: repo }, + }); + const outcome = await workspaceCleanupRouter + .createCaller(ctx) + .destroy({ + workspaceId: "ws-1", + deleteBranch: false, + force: false, + longPreflight, + }) + .then( + (result) => ({ result, error: null }), + (error: Error) => ({ result: null, error }), + ); + return { + ...outcome, + broadcasts: ctx.__mocks.broadcastWorkspaceChanged.mock.calls.length, + }; + } finally { + pool.run = realRun; + Object.assign(cleanupGitOps, patched); + rmSync(worktree, { recursive: true, force: true }); + rmSync(repo, { recursive: true, force: true }); + } + } + + test("a long preflight that needs minutes deletes instead of restoring the row", async () => { + const { result, broadcasts } = await destroyWithSlowStatus(true); + + expect(result?.success).toBe(true); + // One broadcast is the archive; an un-archive would add a second. + expect(broadcasts).toBe(1); + }); + + test("without longPreflight the preflight keeps the dialog's budget and fails closed", async () => { + const { error, broadcasts } = await destroyWithSlowStatus(false); + + expect(error?.message).toMatch(/Couldn't verify worktree state/); + expect(broadcasts).toBe(2); + }); + + test("long delete tasks beyond the limit wait for a slot instead of taking another worker", async () => { + const pool = getHostWorkerPool(); + const realRun = pool.run; + const finishers: Array<() => void> = []; + pool.run = (() => + new Promise((resolve) => + finishers.push(() => resolve({ stillRegistered: false })), + )) as typeof pool.run; + const flush = () => new Promise((resolve) => setTimeout(resolve, 0)); + try { + const removals = [ + ...[1, 2].map((n) => + realGitOps.removeWorktree({ + repoPath: "/repo", + worktreePath: `/wt-${n}`, + gitEnv: {}, + }), + ), + realGitOps.readWorktreeStateUnattended({ + worktreePath: "/wt-3", + gitEnv: {}, + }), + ]; + await flush(); + expect(finishers).toHaveLength(MAX_CONCURRENT_LONG_DELETE_TASKS); + + finishers[0]?.(); + await flush(); + expect(finishers).toHaveLength(3); + + for (const finish of finishers.slice(1)) finish(); + await Promise.all(removals); + } finally { + for (const finish of finishers) finish(); + pool.run = realRun; + } + }); + test("preflight git failure (missing worktree) still proceeds idempotently", async () => { const ctx = makeCtx({ workspace: {