diff --git a/.ai/contexts/project-delete.md b/.ai/contexts/project-delete.md index dd7d37437..111cc78b1 100644 --- a/.ai/contexts/project-delete.md +++ b/.ai/contexts/project-delete.md @@ -1,4 +1,131 @@ -# Project deletion (#474 A4a–A4d) +# Project deletion (#474 A4a–A4d, E) + +## Linked worktree folders (E) + +Preview accepts optional `worktrees: string[]` alongside the unchanged five +boolean writer options. These are exact paths from the main-owned Git inventory, +not arbitrary filesystem targets. Missing means empty; duplicates and more than +128 selections refuse. Every registered checkout has a row with its path, branch, +main/project-directory identity and availability reason. Eligible linked rows +also report inspected dirty/untracked status, sessions and jobs; always-kept +main/project-directory rows read none of those details. Status/activity failures are explicit, never rendered as +clean/idle. The main checkout, the selected project directory and its ancestors +are never removable. Remote selection refuses because no authoritative remote +filesystem/removal port exists. Local discovery uses newline-delimited Git +`worktree list --porcelain`, with the shared parser decoding Git-quoted paths, +compatible with Git 2.24. Inventory failures have a visible dialog reason. +Always-kept main/project-directory rows do not read status, scan activity or hash content. Removable labels +show the ignored-entry count and at most five dirty entries plus the remainder. + +Worktree discovery stays inside the single 20-second preview deadline shared +with metadata planning and the writer scope read; selecting folders never starts +a second preview budget. Unselected discovery receives at most two seconds and +half the remaining planner budget. Selected folders are inspected first, with the remaining planner +budget minus a 500 ms metadata finish margin, both after checkbox changes and on +confirmation rechecks. This reserves time for the writer revision fence and final +deadline check; an exhausted selected inspection returns a refused, "not inspected" +row while metadata planning can still complete. Unselected +folders then retain their bounded share of the remaining time. Git listing, +activity and each status read are deadline-bounded; status traversal and hashing +also check the deadline/signal. Exhausted rows say "not inspected" and cannot be +removed. An unchecked row adds no refusal and the metadata plan still completes. +A selected inspection failure directs the user to the dedicated "Delete worktree" +action in the sidebar. Exhausting the overall planner deadline still fails the +preview, with that same fallback; selecting a folder never extends the deadline. + +Missing session cwd is a folder candidate only when an absolute project path or +the snapshot's local folder-key mapping ties the record to that subtree. Without +such a tie its reason is reported once at dialog level. Unlocated active tabs/PTYs, +scheduled runs (live by definition, even without active or liveness fields), +live or uncertain CLI descriptors, and rows carrying running/unknown liveness +evidence block every selected folder; dormant historical rows without that evidence +only produce the dialog reason. The single conservative rule for unattributed +activity is: live/uncertain sessions and global background-job candidates block +selected folders when their location cannot be resolved or belongs to the selected +subtree, and their reason is reported once at dialog level. A resolvable cwd outside +the selected subtree does not block it. This rule also applies during removal preflight +and the final per-folder guard. The parent metadata runtime retains its own +existing background ownership checks. + +`project-delete-worktrees.js` calls the existing `worktree-delete` readStatus and +removeWorktree functions. Clean removal uses no force; dirty content is hashed +and rechecked. Locked/submodule rows are disabled here and direct users to the +dedicated dialog for its extra confirmations. Directory-link refusal is shared: +remove a node_modules junction with nonrecursive `rmdir` before reopening. E +does not unlink automatically, traverse junctions, delete branches or invoke +cleanupWorktree. Linked histories remain outside the parent's metadata manifest. + +The runtime reads all CLI descriptor writers, indexed session evidence, active +tabs and schedules for each selected/unselected inspection group. Background job +files/list and path resolutions are cached within the preview inventory, shared +with the parent runtime inventory; results are partitioned by folder in memory. +Both located and unattributed descriptor reads consume the process table for +that inventory's abort signal. They share A4's single deadline-bounded fresh +re-read if the early table expires; an expired replacement is not retried. +Missing, stale or mismatched process evidence retains the descriptor reader's +unknown result and cannot establish absence. Removal preflight and every final +per-folder guard start independent process reads for their own signals, so they +never reuse the preview table or the Windows global refresh cache. +Descendant cwd counts as worktree +activity. Live or uncertain sessions disable the row; E does not extend A4 stop +authority to a linked project's sessions. Background records remain refused +under #1090 even when done. Local subtree launch holds cover selected directories +and wait for previously admitted descendant launches; archive reservations include +the selected linked identities as well as the parent. External processes and +filesystem writers are not locked by these holds. + +Only selected removable rows enter the planner fingerprint, retained in the single-use +document-bound token. Renderer boxes are individually unchecked on every open +with no rememberKey. A changed selected row fingerprint requires reopening: +a newer hidden detail panel cannot silently authorize newly dirty bytes. +Unselected physical content is kept. Selecting a directory necessarily removes +all its contents, including ignored files and any schedules/memory/work-files +inside it; category `kept` applies to the parent's data, not files inside selected +linked directories. + +The dialog keeps the explicit `Kept on disk:` project-folder notice alongside +the selected linked-folder removal warning. Kept rows carry no ignored-file +removal warning. Unselected dirty content does not invalidate project consent. + +Execution drains holds, revalidates, stops/verifies parent targets, preflights all +selected rows, then removes sequentially through the shared path with fresh +per-removal activity/status checks. Confirm inventories inspect only selected +folders; each inspection starts process reads only after Git identifies eligible +rows. Preflight and each final check (including a post-failure re-read) own an +AbortController and abort it in finally, so refusal and error exits cancel the +Claude roster and process-table reads. The final metadata preview skips physical inventory. A failed removal +stops the sequence. Only +after removal does it reread writer scope and revalidate parent membership/death, +omitting already-consumed physical selections from this final preview. The +writer's manifest/options remain metadata-only. The operation retains launch +holds until Git settles, even after an early IPC unknown reply. +Renderer follow-up keeps the same operation ID and only reads state. With no +folders selected its ceiling stays 325 seconds. Otherwise it adds the 15-second +preflight and, per selected folder, the 15-second final inspection from +`project-delete-worktrees.js`, the 5-second directory-link scan, the 120-second +Git removal timeout from `main.js`'s `worktreeGit`, and one additional 15-second +inspection after a Git failure. Main and renderer import the inspection, removal, +and `DIRECTORY_SCAN_MS` constants from `public/setting-defaults.js`; two selections +allow 650 seconds. This bounds automatic following, not filesystem completion. + +`worktrees` on operation views records removed/failed/refused/remaining paths. +A refusal before Git removal has no disk effect and does not make the operation +partial. An inventory-wide refusal has no individual path. An attempted +disk effect followed by failure remains partial even when the metadata receipt +proves notStarted. The renderer's persistent notice lists these paths and offers +fresh review, never replay. A metadata commit still publishes only its own exact +invalidation targets. Filesystem and SQLite effects are not an atomic transaction. +Physical progress is process-local: recovered writer receipts explicitly set +worktreeHistoryUnknown; a crash before writer submission leaves no disk receipt. +Fresh Git/disk inspection and user consent establish remaining work. Recovery +never repeats disk removal or treats a metadata receipt as proof of disk success. + +Plain-Node tests cover the production planner, service, activity reader, subtree +gate and shared removal with controlled Git replies and real disposable files. +The composition witness includes the real writer/SQLite fixture. Separate real +Git worktree tests exercise the installed Git version. +Native UI, full process restart, live process death and +filesystem races after the shared last scan remain unverified locally. ## Slow execution and diagnostics (#1103G, #1103H) @@ -63,7 +190,7 @@ the strict backend STOP_UNSUPPORTED behavior remains unchanged. R6: a bounded read-only capabilities preview precedes the dialog. Only session metadata (initial false) and available project settings (initial true) are remembered on acceptance. Disabled remembered choices become unchecked without -a write. Physical categories stay kept. The literal expandable full plan is +a write. E adds separately unremembered physical worktree choices above. The literal expandable full plan is installed only after latest-response/answer matching; failures cannot enable Confirm. Changed membership requires a new dialog/confirmation. @@ -154,7 +281,11 @@ still validate the combined roster; early rejection is handled until consumed. Each new preview/revalidation gets a new signal and an isolated process-table read, bypassing the global cache and another request's in-flight probe. Ownership, schedule and runtime assembly retain -their order for path registration and PTY pinning. No git process is used. +their order for path registration and PTY pinning. Metadata discovery uses no Git +process; E's linked-worktree inventory uses bounded Git reads within that same +preview deadline. The job roster and resolved paths are cached per preview and +shared with E's folder activity checks. These reads use the named discovery bounds +so deadlines and timing diagnostics survive their composition. Remote readers remain bounded but production still supplies no exhaustive port. Outside deletion, the process table reuses a cached result, including a failed @@ -304,8 +435,9 @@ The service, inventory and planner share optional `now/schedule/cancel` clock po allow expiry, deadlines and retention to share one clock. Tokens are 32 random bytes, five-minute, boot/document-bound, with 32 outstanding globally. Preview rechecks document authority after discovery/scope reads before minting. Input -options remain the five booleans; extra fields and physical/worktree choices -refuse. Reply timeout is separate from accepted main-owned work. The operation +options remain the five booleans; E's optional worktrees path array belongs to +preview only and never enters writer options. Other extra fields refuse. +Reply timeout is separate from accepted main-owned work. The operation ID and registry entry precede the first await, and readState cannot fence work still admitting or stopping. Reuse/foreign tokens never submit or stop twice. @@ -342,8 +474,9 @@ deduplicate by operation/revision and reject stale epochs when reusing cached project state; process-local deduplication cannot promise once across restarts. Late async callbacks remain responsible for that identity check as well. Notification/file observation failure preserves a proven -commit with a separate warning. Detailed outcomes are always receipt-derived; -purged receipts stay unknown. `whenIdle()` is an internal drain for tests and +commit with a separate warning. Detailed metadata outcomes are receipt-derived; +E's disk outcomes are retained separately in process memory, and purged receipts +stay unknown. `whenIdle()` is an internal drain for tests and shutdown coordination, not a reason to discard unresolved holds. Once a terminal/noLateCommit result and its bounded notification/file inspection diff --git a/CHANGELOG.md b/CHANGELOG.md index 31b95730b..e2002b416 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -4,6 +4,9 @@ What changes for you in each release of Switchboard. How to write an entry: [doc ## Unreleased +### New +- Choose individual linked worktree folders to remove from disk in the project deletion dialog. Choices start unchecked, the main checkout is always kept, and partial outcomes show what was removed or remains. (#474) + ## v0.0.106 — 2026-11-13 ### New diff --git a/docs/session-browser.md b/docs/session-browser.md index c46bcf63a..37aa170aa 100644 --- a/docs/session-browser.md +++ b/docs/session-browser.md @@ -49,7 +49,7 @@ Buttons on a project header: | Create scheduled task | Opens a Claude session that writes a schedule file — see [Automation](automation.md#creating-a-schedule) | | Project settings | Per-project overrides — see [Settings reference](settings.md#project-settings) | | Archive folder | Opens a dialog that archives the folder's sessions and disables its schedules, each optional, and hides the folder — see [Archive a folder](#archive-a-folder) | -| Delete | Previews removal from Switchboard with separate session metadata and project settings choices. Files and nested worktrees stay on disk — see [Settings reference](settings.md#project-settings). | +| Delete | Previews removal from Switchboard with separate session metadata, project settings and individual linked worktree folder choices. Worktree removal starts unchecked; the main checkout stays — see [Worktree cleanup](worktrees.md#cleaning-up). | | New session (`+`) | The launch menu — see [Launching sessions](launching-sessions.md) | A project on a [remote host](remote-hosts.md) carries a host status dot and a @@ -66,8 +66,14 @@ project from the sidebar without asking. A notice offers **Undo** for about their files. **Unarchive** in Settings → **Archived projects**, or **Add Project** on the same local folder, restores it and resumes scheduling. Unlike **Archive folder**, a new session does not restore it automatically. **Delete Project** -separately removes settings, cache, search entries and schedule registration; -its confirmation names these losses. It deletes no folder or transcript. +offers separate choices for app metadata and project settings, and optionally +removes individually selected linked worktree folders from disk. Each folder's +path, branch, changed files and live sessions are previewed; its checkbox is +never remembered. The project directory, main checkout, unselected worktrees +and external transcripts are kept. Contents inside a selected worktree, including +ignored files, are removed. Busy, uncertain, locked or remote worktrees cannot +be selected here. A partial deletion lists disk outcomes and requires a fresh +preview before retrying; see [Worktree cleanup](worktrees.md#cleaning-up). Sessions run in a git worktree are listed in their repository's project — see [Worktree sessions](worktrees.md). A worktree folder is nested under its diff --git a/docs/worktrees.md b/docs/worktrees.md index 0cad5e9ec..7b59865b9 100644 --- a/docs/worktrees.md +++ b/docs/worktrees.md @@ -59,9 +59,29 @@ it empty (placeholder `auto`) to let the CLI name each worktree. ## Cleaning up -Deleting the parent project from its header or Project Settings keeps nested -worktree histories and directories. The full project-deletion preview lists -those groups as kept; it offers no physical worktree deletion choice. +Deleting the parent project from its header or Project Settings keeps linked +worktree histories and offers a separate checkbox for each registered linked +worktree folder. Each choice starts unchecked every time. The preview names the +full path, branch, dirty/untracked files and sessions. The main checkout and the +selected project directory cannot be removed. Unselected folders and branches +are kept. Selecting a folder removes its contents, including ignored files, +memory, schedules or `.work-files` stored inside it; their contents are not backed up. + +Stop linked-worktree sessions before selecting their folders. Unknown activity +and background job records refuse removal; background jobs remain unsupported +even when reported done. Locked worktrees and submodules require the dedicated +worktree dialog below. Remote disk removal is unavailable. Directory links use +the same guards as the dedicated dialog: remove a `node_modules` junction with +`rmdir ` without recursive deletion, then reopen the preview. + +After the parent project's sessions stop, selected folders are removed one at a +time before the project's app metadata is changed. A changed preview requires +fresh confirmation. A failed removal stops the sequence and lists removed, +failed and remaining paths in a persistent notice. Review disk and Git +registration, then choose **Review remaining deletion** for fresh consent. +There is no rollback or automatic replay. After restarting the app, previous +disk outcomes may be unknown: a new preview inspects the remaining registration +and folders; a metadata receipt alone does not prove disk removal succeeded. When the work is merged or abandoned, remove the worktree from Switchboard or with git. diff --git a/eslint.config.js b/eslint.config.js index c95b02365..05132a074 100644 --- a/eslint.config.js +++ b/eslint.config.js @@ -797,7 +797,8 @@ module.exports = [ { files: ['public/sidebar.js'], - languageOptions: { globals: { PROJECT_DELETE_DIALOG_TIMEOUT_MS: 'readonly', PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS: 'readonly' } }, + languageOptions: { globals: { PROJECT_DELETE_DIALOG_TIMEOUT_MS: 'readonly', PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS: 'readonly', + PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS: 'readonly', PROJECT_DELETE_WORKTREE_REMOVE_TIMEOUT_MS: 'readonly', DIRECTORY_SCAN_MS: 'readonly' } }, }, // CodeMirror setup file uses ESM-style imports/closure that don't lint well diff --git a/main.js b/main.js index bc87f03f8..023b0cbc0 100644 --- a/main.js +++ b/main.js @@ -91,7 +91,8 @@ const { startScheduler, scheduleLaunchRefusal, resolveScheduleSandbox, initialSc const { buildScheduleList } = require('./src/main/schedules/schedule-list'); const { archivePlanForGroups, validArchiveGroups } = require('./archived-projects'); const { encodeProjectPath } = require('./encode-project-path'); -const { SETTING_DEFAULTS, normalizeBrowserSettings } = require('./public/setting-defaults'); +const { SETTING_DEFAULTS, normalizeBrowserSettings, + PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS, PROJECT_DELETE_WORKTREE_REMOVE_TIMEOUT_MS } = require('./public/setting-defaults'); const { isSensitivePath, isSensitivePathAsync, isAllowedMemoryPath: _isAllowedMemoryPath, resolveAllowedMemoryPath: _resolveAllowedMemoryPath, isKnownProjectRoot: _isKnownProjectRoot } = require('./src/main/shared/ipc-path-validator'); const { validatePreLaunchCmd } = require('./src/main/terminals/pre-launch-cmd-guard'); const { normalizePtySize } = require('./src/main/terminals/pty-size'); @@ -1150,8 +1151,11 @@ ipcMain.handle('check-delete-worktree', (_event, worktreePath) => { function worktreeGit(args, consume) { if (consume) return worktreeDelete.streamGit(args, consume, { spawn: spawnChild, env: localGitEnv() }); + let command = 0; + while (args[command] === '-C' || args[command] === '-c') command += 2; + const removing = args[command] === 'worktree' && args[command + 1] === 'remove'; return new Promise((resolve, reject) => { - execFile('git', args, { env: localGitEnv(), timeout: args.includes('remove') ? 120000 : 15000, maxBuffer: 16 * 1024 * 1024 }, (err, stdout, stderr) => { + execFile('git', args, { env: localGitEnv(), timeout: removing ? PROJECT_DELETE_WORKTREE_REMOVE_TIMEOUT_MS : PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS, maxBuffer: 16 * 1024 * 1024 }, (err, stdout, stderr) => { if (err) reject(Object.assign(new Error((stderr || err.message || String(err)).trim()), { code: err.code, killed: err.killed, signal: err.signal })); else resolve(stdout); }); @@ -3836,7 +3840,7 @@ const unsubscribeBgAgents = require('./src/main/bg-agents/bg-agents-ipc').init({ activeSessions, cliSessionState, sessionHasPty, ptyPids, getSetting: key => getSetting(key) }); const { createProjectDeleteMain } = require('./src/main/projects/project-delete-main'); const projectDeleteMain = createProjectDeleteMain({ - writer, ipcMain, activeSessions, cliSessionState, log, homeDir: os.homedir(), + writer, ipcMain, activeSessions, cliSessionState, log, homeDir: os.homedir(), worktreeGit, projectsDir: PROJECTS_DIR, dataDir: path.dirname(DB_PATH), jobsDir: path.join(CLAUDE_DIR, 'jobs'), bg: unsubscribeBgAgents, remote: remoteStopAdapter, runClaude: runClaudeCommand, gate: require('./src/main/shared/project-operation-gate').projectOperationGate, diff --git a/public/setting-defaults.js b/public/setting-defaults.js index 21b37b175..b09e2172f 100644 --- a/public/setting-defaults.js +++ b/public/setting-defaults.js @@ -40,6 +40,9 @@ const SETTING_DEFAULTS = { const PROJECT_DELETE_PREVIEW_TIMEOUT_MS = 20000; const PROJECT_DELETE_DIALOG_TIMEOUT_MS = PROJECT_DELETE_PREVIEW_TIMEOUT_MS + 1000; const PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS = 3 * PROJECT_DELETE_PREVIEW_TIMEOUT_MS + 2 * 10000 + 60000 + 60000 + 70000 + 10000 + 3 * 10000 + 15000; +const PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS = 15000; +const PROJECT_DELETE_WORKTREE_REMOVE_TIMEOUT_MS = 120000; +const DIRECTORY_SCAN_MS = 5000; const BROWSER_MODES = Object.freeze([ Object.freeze({ value: 'off', label: 'Off' }), @@ -63,5 +66,6 @@ function normalizeBrowserSettings(settings, diagnostic = message => console.warn if (typeof module !== 'undefined' && module.exports) { module.exports = { SETTING_DEFAULTS, BROWSER_MODES, normalizeBrowserSettings, - PROJECT_DELETE_PREVIEW_TIMEOUT_MS, PROJECT_DELETE_DIALOG_TIMEOUT_MS, PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS }; + PROJECT_DELETE_PREVIEW_TIMEOUT_MS, PROJECT_DELETE_DIALOG_TIMEOUT_MS, PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS, + PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS, PROJECT_DELETE_WORKTREE_REMOVE_TIMEOUT_MS, DIRECTORY_SCAN_MS }; } diff --git a/public/sidebar.js b/public/sidebar.js index 5e16c10bd..964229857 100644 --- a/public/sidebar.js +++ b/public/sidebar.js @@ -1030,7 +1030,7 @@ function projectDeletionDetails(reply) { const plan = reply.plan; return JSON.stringify({ project: plan.project, counts: plan.counts, categories: plan.categories, groups: plan.groups, members: plan.members, tabs: plan.tabs, stops: plan.stops, jobs: plan.jobs, - schedules: plan.schedules, warnings: plan.warnings, refusals: plan.refusals }, null, 2); + schedules: plan.schedules, worktrees: plan.worktrees, warnings: plan.warnings, refusals: plan.refusals }, null, 2); } function projectDeletionNotice(project, message, action) { @@ -1063,7 +1063,8 @@ async function settleProjectDeletion(project, result, { historical = false } = { setProjectDeletionBusy(project, true); projectDeletionNotice(project, `Deletion is ${result.state === 'unknown' ? 'unresolved' : 'partially completed'}. No deletion will be replayed. Reason: ${result.code || 'UNKNOWN'}.\n` + JSON.stringify({ completed: result.completed, kept: result.kept, failed: result.failed, skipped: result.skipped, - stopped: result.stopped, stoppedHistoryUnknown: result.stoppedHistoryUnknown }, null, 2), + stopped: result.stopped, stoppedHistoryUnknown: result.stoppedHistoryUnknown, + worktrees: result.worktrees, worktreeHistoryUnknown: result.worktreeHistoryUnknown }, null, 2), result.state === 'partial' ? { actionLabel: 'Review remaining deletion', onAction: () => { projectDeletionOperations.delete(key); setProjectDeletionBusy(project, false); const current = cachedAllProjects.find(row => projectDeletionKey(row) === key) || project; @@ -1081,7 +1082,8 @@ async function settleProjectDeletion(project, result, { historical = false } = { const operation = projectDeletionOperations.get(key); projectDeletionNotice(project, (result?.error || result?.code || 'Deletion could not be completed.') + (result?.refresh ? ' Review a fresh preview before confirming again.' : ' Check the project, then retry.') + '\n' + - JSON.stringify({ completed: result?.completed, kept: result?.kept, failed: result?.failed, skipped: result?.skipped, stopped: result?.stopped }, null, 2), + JSON.stringify({ completed: result?.completed, kept: result?.kept, failed: result?.failed, skipped: result?.skipped, stopped: result?.stopped, + worktrees: result?.worktrees, worktreeHistoryUnknown: result?.worktreeHistoryUnknown }, null, 2), operation ? { actionLabel: 'Check deletion state', onAction: () => reconcileProjectDeletions({ operations: [ { operationId: operation.operationId, host: project.remoteAlias ?? project.host ?? null, projectPath: project.projectPath }, ] }) } : { actionLabel: 'Review deletion', onAction: () => confirmAndDeleteProjectFolder(project) }); @@ -1125,24 +1127,40 @@ async function confirmAndDeleteProjectFolder(project, button) { const deadline = Date.now() + PROJECT_DELETE_DIALOG_TIMEOUT_MS; try { await projectDeletionPreviewWait('flushProjectDeletionWrites', () => window.flushProjectDeletionWrites?.(), deadline); + let worktreeChoices = []; const request = options => ({ projectPath: project.projectPath, ...(project.folder ? { folderKey: project.folder } : {}), + worktrees: worktreeChoices.filter((row, i) => options['worktree:' + i]).map(row => row.path), options: { sessions: options.sessions, settings: options.settings, schedules: false, transcripts: false, stopBackgroundJobs: false } }); const capabilities = await projectDeletionCall('previewProjectDelete', request({ sessions: false, settings: false }), { retryRecovery: true, deadline }); if (!capabilities?.plan) { projectDeletionNotice(project, projectDeletionPlanReason(capabilities)); return false; } const categories = capabilities.plan.categories; + worktreeChoices = (capabilities.plan.worktrees || []).map(row => ({ ...row })); const answers = await showChoiceDialog({ title: 'Delete project from Switchboard?', message: [`${project.remoteAlias || 'Local'} — ${capabilities.plan.project.projectPath}`, 'Choose which app data to discard. Retained session metadata is archived.', - 'Kept on disk: project folder, transcripts, schedules, memory, .work-files and nested worktrees. All remote server files are kept.', - 'Kept schedules may reactivate when you add the project again. Retained transcripts may restore their titles.'], + 'Kept on disk: the project folder. Only individually selected linked worktree folders are removed, including their ignored files. All remote server files are kept.', + 'Other transcripts, schedules, memory and .work-files stay on disk. Linked worktree history is kept in Switchboard.', + 'Kept schedules may reactivate when you add the project again. Retained transcripts may restore their titles.', + ...(capabilities.plan.warnings || []).filter(row => row.code === 'WORKTREE_UNAVAILABLE').map(row => 'Worktree inventory unavailable: ' + row.error)], choices: [ { id: 'sessions', label: 'Discard session names, pins and app metadata', checked: false, rememberKey: 'deleteProject.sessions', disabled: categories.sessions?.available !== true, disabledReason: categories.sessions?.reason || 'Session metadata is unavailable' }, { id: 'settings', label: 'Delete project settings', checked: true, rememberKey: 'deleteProject.settings', disabled: categories.settings?.available !== true, disabledReason: categories.settings?.reason || 'Project settings are unavailable' }, + ...worktreeChoices.map((row, i) => { + const sessionLabel = row.sessionsKnown === false ? 'uncertain' : (row.sessions || []).map(session => session.sessionId || session.id).join(', ') || 'none'; + const kept = row.main || row.projectDirectory; + const dirty = row.dirty?.slice(0, 5).join('; ') + (row.dirty?.length > 5 ? `; and ${row.dirty.length - 5} more` : ''); + const status = kept ? '' : ` ${row.statusKnown === false ? 'Status unavailable' : row.dirty?.length ? dirty : 'Clean'}. Sessions: ${sessionLabel}.`; + const ignored = row.removable ? ` ${row.ignoredCount || 0} ignored entries. Ignored files are removed too.` : ''; + return { id: 'worktree:' + i, + label: `${row.main ? 'Main checkout (kept)' : kept ? 'Project directory (kept)' : 'Remove worktree from disk'}: ${row.path} — ${row.branch}.${status}${ignored}`, + checked: false, disabled: row.removable !== true || row.main || row.projectDirectory, + disabledReason: row.reason ? row.reason : 'This worktree cannot be removed.' }; + }), ], onChange: async values => { const reply = await projectDeletionCall('previewProjectDelete', request(values)); @@ -1150,6 +1168,10 @@ async function confirmAndDeleteProjectFolder(project, button) { for (const id of ['sessions', 'settings']) if (values[id] && reply.plan.categories[id]?.available !== true) { throw new Error(reply.plan.categories[id]?.reason || 'This choice is no longer available. Close and reopen Delete.'); } + for (const [i, row] of worktreeChoices.entries()) if (values['worktree:' + i]) { + const fresh = reply.plan.worktrees?.find(item => item.path === row.path); + if (!fresh?.removable || fresh.main || fresh.projectDirectory || fresh.fingerprint !== row.fingerprint) throw new Error(fresh?.reason || 'Worktree changed. Close and reopen Delete.'); + } return reply; }, planDetails: projectDeletionDetails, planUnavailable: projectDeletionPlanReason, planWaitManaged: true, @@ -1162,7 +1184,10 @@ async function confirmAndDeleteProjectFolder(project, button) { setProjectDeletionWritesBlocked(project, true); await window.flushProjectDeletionWrites?.(); let result = await projectDeletionCall('deleteProject', { token: answers.plan.token, fingerprint: answers.plan.plan.fingerprint }); - const stateDeadline = Date.now() + PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS; + const selectedWorktrees = request(answers).worktrees.length; + const worktreeTimeout = selectedWorktrees ? PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS + + selectedWorktrees * (2 * PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS + DIRECTORY_SCAN_MS + PROJECT_DELETE_WORKTREE_REMOVE_TIMEOUT_MS) : 0; + const stateDeadline = Date.now() + PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS + worktreeTimeout; while (result?.operationId && result.code === 'EXECUTION_PENDING') { const operationId = result.operationId; try { diff --git a/src/main/projects/project-delete-main.js b/src/main/projects/project-delete-main.js index 631e1d9c7..42bca4384 100644 --- a/src/main/projects/project-delete-main.js +++ b/src/main/projects/project-delete-main.js @@ -12,6 +12,7 @@ const { registerProjectDeleteIpc } = require('./project-delete-ipc'); const { parseJobState, parseCliList, JOB_ID_RE } = require('../bg-agents/bg-agents-roster'); const { stopPtyWithEvidence, detachPty } = require('../terminals/pty-ops'); const { fail } = require('./project-delete-identity'); +const { createProjectDeleteWorktrees } = require('./project-delete-worktrees'); const { parseFolderKey } = require('../remote/remote-hosts'); const RECOVERY_TIMEOUT_MS = 4096 * 30000 + 65 * 10000 + 32 * 80000; @@ -21,6 +22,17 @@ function createProjectDeleteRuntime(ports) { const io = ports.fs || fs, now = ports.now || Date.now; const schedule = ports.schedule || setTimeout, cancel = ports.cancel || clearTimeout; const scopes = new AsyncLocalStorage(); + const inventories = new WeakMap(); + const inventoryFor = budget => { + const key = budget.signal || budget; + if (!inventories.has(key)) inventories.set(key, { paths: new Map() }); + return inventories.get(key); + }; + const resolvePath = (value, budget) => { + const paths = inventoryFor(budget).paths; + if (!paths.has(value)) paths.set(value, bounded('fs.realpath', () => io.realpath(value), budget)); + return paths.get(value); + }; const captureRuntimeRelease = () => { const scope = scopes.getStore(); return () => { scope?.members.clear(); scope?.pins.clear(); }; @@ -45,13 +57,12 @@ function createProjectDeleteRuntime(ports) { processReads.set(budget.signal, { agents, table }); } } - async function readJobs(project, budget) { - if (project.alias !== null) throw fail('DISCOVERY_UNAVAILABLE', 'Remote background inventory has no exhaustive read port.'); + async function scanJobs(budget) { const early = processReads.get(budget.signal); const agents = early?.agents || bounded('runClaude.agents', () => ports.runClaude(['agents', '--json', '--all'], { cwd: ports.homeDir, timeout: Math.max(1, budget.deadline - now()), signal: budget.signal, maxOutputBytes: 8 * 1048576 }), budget); void agents.catch(() => {}); - const jobs = [], candidates = [], records = new Map(); + const candidates = [], records = new Map(); let directory, count = 0, bytes = 0; try { if ((await bounded('fs.lstat', () => io.lstat(ports.jobsDir), budget)).isSymbolicLink()) throw fail('DISCOVERY_CANDIDATE', 'Linked job directory.'); @@ -91,35 +102,38 @@ function createProjectDeleteRuntime(ports) { if (!Array.isArray(raw) || !listed || listed.length !== raw.length || listed.length + count > Math.min(budget.limit, 20000)) throw fail('DISCOVERY_LIMIT', 'Background list invalid or oversized.'); for (const row of listed.filter(row => row.kind === 'background')) { - if (!row.id || !records.has(row.id)) candidates.push({ id: row.id || row.sessionId, reason: 'Background list has no durable job record.' }); + if (!row.id || !records.has(row.id)) candidates.push({ id: row.id || row.sessionId, cwd: row.cwd, reason: 'Background list has no durable job record.' }); else records.set(row.id, { ...records.get(row.id), cwd: row.cwd || records.get(row.id).cwd }); } - const root = await bounded('fs.realpath', () => io.realpath(project.projectPath), budget); + return { candidates, records }; + } + async function readJobs(project, budget) { + if (project.alias !== null) throw fail('DISCOVERY_UNAVAILABLE', 'Remote background inventory has no exhaustive read port.'); + const inventory = inventoryFor(budget); + inventory.jobs ||= scanJobs(budget); + const scanned = await inventory.jobs; + const globalCandidates = [...scanned.candidates], candidates = [], jobs = []; + const root = await resolvePath(project.projectPath, budget); + const records = scanned.records; for (const [id, row] of records) { - if (!row.cwd || !path.isAbsolute(row.cwd) || !row.sessionId) { candidates.push({ id, reason: 'Background ownership unavailable.' }); continue; } + if (!row.cwd || !path.isAbsolute(row.cwd) || !row.sessionId) { globalCandidates.push({ id, cwd: row.cwd, reason: 'Background ownership unavailable.' }); continue; } let cwd; - try { cwd = row.cwd === project.projectPath ? root : await bounded('fs.realpath', () => io.realpath(row.cwd), budget); } + try { cwd = row.cwd === project.projectPath ? root : await resolvePath(row.cwd, budget); } catch (error) { if (error.code === 'DISCOVERY_TIMEOUT') throw error; - if (error.code !== 'ENOENT') candidates.push({ id, reason: error.message }); + if (error.code !== 'ENOENT') globalCandidates.push({ id, cwd: row.cwd, reason: error.message }); continue; } - if (normalize(cwd) !== normalize(root)) continue; + if (normalize(cwd) !== normalize(root) && !(project.includeDescendants && normalize(cwd).startsWith(normalize(root) + '/'))) continue; jobs.push({ id, jobId: id, alias: null, projectPath: root, runtime: 'claude', verified: true, conversationId: row.sessionId, sessionIds: [row.sessionId], liveness: { state: 'unknown', source: 'job' } }); candidates.push({ id, reason: 'Background deletion awaits worker-incarnation control (#1090).' }); } - return { complete: true, jobs, candidates }; + return { complete: true, jobs, candidates: project.worktreeInventory ? candidates : [...globalCandidates, ...candidates], globalCandidates }; } const sessionsFor = id => [...ports.activeSessions].filter(([key, session]) => [key, session.sessionId, session.realSessionId].includes(id)); - async function readLiveness(row, budget) { - const scope = scopes.getStore(); - if (!scope) throw fail('DISCOVERY_UNAVAILABLE', 'Runtime operation scope unavailable.'); - const { members, pins } = scope; - if (members.size >= 50000 && !members.has(row.id)) throw fail('DISCOVERY_LIMIT', 'Runtime identity limit.'); - members.set(row.id, row); - if (row.alias !== null || row.runtime === 'codex' || row.jobId) return { state: 'unknown' }; + async function readEvidenceOptions(budget) { const early = processReads.get(budget.signal); let processTable = await early?.table; if (processTable?.expiresAt <= now() && now() < budget.deadline) { @@ -127,7 +141,16 @@ function createProjectDeleteRuntime(ports) { () => ports.cliSessionState.readProcessTableSnapshot(budget.deadline, { fresh: true, signal: budget.signal }), budget); processTable = await early.refreshed; } - const evidenceOptions = processTable === undefined ? {} : { processTable }; + return processTable === undefined ? {} : { processTable }; + } + async function readLiveness(row, budget) { + const scope = scopes.getStore(); + if (!scope) throw fail('DISCOVERY_UNAVAILABLE', 'Runtime operation scope unavailable.'); + const { members, pins } = scope; + if (members.size >= 50000 && !members.has(row.id)) throw fail('DISCOVERY_LIMIT', 'Runtime identity limit.'); + members.set(row.id, row); + if (row.alias !== null || row.runtime === 'codex' || row.jobId) return { state: 'unknown' }; + const evidenceOptions = await readEvidenceOptions(budget); const matches = sessionsFor(row.sessionId || row.id); if (matches.length > 1) return { state: 'unknown' }; const previous = pins.get(row.id); @@ -175,7 +198,113 @@ function createProjectDeleteRuntime(ports) { } return { known: true, complete: true, owners }; } - return { startProcessReads, readJobs, readLiveness, readTarget, readConversation, withScope, captureRuntimeRelease, + async function readWorktreeActivity(project, budget) { + if (project.alias !== null) throw fail('DISCOVERY_UNAVAILABLE', 'Remote worktree activity is unavailable.'); + const descriptors = await bounded('cliSessionState.getSidebarDescriptors', () => ports.cliSessionState.getSidebarDescriptors({ allWriters: true }), budget); + const snapshot = budget.snapshot || await ports.readWorktreeSnapshot?.(budget); + if (!Array.isArray(descriptors) || !Array.isArray(snapshot?.sessions) || !(ports.activeSessions instanceof Map)) { + throw fail('DISCOVERY_UNAVAILABLE', 'Worktree session inventory is incomplete.'); + } + const rows = [...ports.activeSessions].map(([id, row]) => ({ ...row, sessionId: row.realSessionId || row.sessionId || id, active: !row.exited })); + rows.push(...descriptors, ...snapshot.sessions); + if (rows.length > budget.limit) throw fail('DISCOVERY_LIMIT', 'Too many worktree sessions to inspect.'); + const runs = await bounded('cliSessionState.getScheduleRunSnapshot', () => ports.cliSessionState.getScheduleRunSnapshot(), budget); + if (!Array.isArray(runs) || runs.length + rows.length > budget.limit) throw fail('DISCOVERY_LIMIT', 'Schedule inventory unavailable or oversized.'); + const evidenceById = new Map(), dialogCandidates = new Map(); + const readEvidence = async id => { + const evidenceOptions = await readEvidenceOptions(budget); + return bounded('cliSessionState.readStatusEvidence', () => ports.cliSessionState.readStatusEvidence(id, budget.deadline, evidenceOptions), budget); + }; + const descriptorRows = new Set(descriptors), scheduledRows = new Set(runs); + let unlocatedActivity = false; + const report = candidate => dialogCandidates.set(JSON.stringify([candidate.id, candidate.reason]), candidate); + const local = row => !(row.host || row.remoteAlias || row.alias || parseFolderKey(row.folder || row.folderKey).alias !== null); + const associatedPaths = row => { + const paths = []; + if (typeof row.projectPath === 'string' && path.isAbsolute(row.projectPath)) paths.push(row.projectPath); + const folder = row.folder || row.folderKey; + if (folder) for (const project of snapshot.projects || []) { + if (project.alias === null && project.folderKeys?.includes(folder)) paths.push(project.projectPath); + } + return paths; + }; + for (const row of [...rows, ...runs]) { + const value = row.cwd; + if (local(row) && (typeof value !== 'string' || !path.isAbsolute(value)) && !associatedPaths(row).length) { + const id = row.sessionId || row.id; + report({ id, reason: 'Session cwd unavailable.' }); + if (row.active || scheduledRows.has(row) || row.liveness && row.liveness.state !== 'stopped') unlocatedActivity = true; + else if (descriptorRows.has(row)) { + if (!id || row.runtime === 'codex') unlocatedActivity = true; + else { + if (!evidenceById.has(id)) evidenceById.set(id, readEvidence(id)); + const evidence = await evidenceById.get(id); + if (!evidence?.known || evidence.live || evidence.ambiguous) unlocatedActivity = true; + } + } + } + } + async function forPath(projectPath) { + const root = normalize(await resolvePath(projectPath, budget)); + const sessions = [], jobs = [], candidates = [], seen = new Set(); + const within = async row => { + if (!local(row)) return false; + const value = row.cwd; + if (typeof value !== 'string' || !path.isAbsolute(value)) { + for (const value of associatedPaths(row)) { + const owner = normalize(await resolvePath(value, budget)); + if (owner === root || owner.startsWith(root + '/')) { + candidates.push({ id: row.sessionId || row.id, reason: 'Session cwd unavailable.' }); break; + } + } + return false; + } + let cwd; + try { cwd = normalize(await resolvePath(value, budget)); } + catch (error) { + if (error.code !== 'ENOENT') candidates.push({ id: row.sessionId, reason: 'Session cwd unreadable.' }); + return false; + } + return cwd === root || cwd.startsWith(root + '/'); + }; + for (const row of rows) { + if (!await within(row)) continue; + const id = row.sessionId || row.id; + if (row.active) { sessions.push({ sessionId: id, cwd: row.cwd || row.projectPath }); continue; } + if (!id || row.runtime === 'codex') { candidates.push({ id, reason: 'Worktree runtime liveness unavailable.' }); continue; } + if (seen.has(id)) continue; + seen.add(id); + if (!evidenceById.has(id)) evidenceById.set(id, readEvidence(id)); + const evidence = await evidenceById.get(id); + if (!evidence?.known || evidence.ambiguous) candidates.push({ id, reason: 'Worktree session liveness uncertain.' }); + else if (evidence.live) sessions.push({ sessionId: id, cwd: row.cwd || row.projectPath }); + } + const roster = await readJobs({ ...project, projectPath, includeDescendants: true, worktreeInventory: true }, budget); + jobs.push(...roster.jobs); candidates.push(...roster.candidates); + let ownershipUncertain = unlocatedActivity + && (budget.selectedWorktrees || budget.worktreePaths || []).some(value => normalize(value) === normalize(projectPath)); + for (const candidate of roster.globalCandidates) { + report(candidate); + if (!(budget.selectedWorktrees || budget.worktreePaths || []).some(value => normalize(value) === normalize(projectPath))) continue; + let owner; + if (typeof candidate.cwd === 'string' && path.isAbsolute(candidate.cwd)) { + try { owner = normalize(await resolvePath(candidate.cwd, budget)); } catch {} + } + if (!owner || owner === root || owner.startsWith(root + '/')) ownershipUncertain = true; + } + if (runs.length + rows.length + jobs.length > budget.limit) throw fail('DISCOVERY_LIMIT', 'Schedule inventory unavailable or oversized.'); + for (const run of runs) if (await within(run)) jobs.push(run); + return { complete: true, sessions, jobs, candidates, ownershipUncertain }; + } + if (!project.worktreePaths) { + const result = await forPath(project.projectPath); + return { ...result, candidates: [...result.candidates, ...dialogCandidates.values()] }; + } + const byPath = Object.create(null); + for (const directory of project.worktreePaths) byPath[directory] = await forPath(directory); + return { byPath, candidates: [...dialogCandidates.values()] }; + } + return { startProcessReads, readJobs, readLiveness, readTarget, readConversation, readWorktreeActivity, withScope, captureRuntimeRelease, getScheduleRunSnapshot: () => ports.cliSessionState.getScheduleRunSnapshot(), bg: ports.bg, remote: ports.remote, detach: attachment => detachPty(attachment.session, attachment.sessionKey), @@ -212,11 +341,14 @@ function createProjectDeleteMain(deps) { catch (error) { delivered.delete(key); throw error; } for (const [old, at] of delivered) if (now() - at >= 86400000) delivered.delete(old); }; - const runtime = createProjectDeleteRuntime({ ...deps, ...clock }); - const inventory = createProjectDeleteInventory({ ...deps, ...runtime, ...clock, writer }); - const planner = createProjectDeletePlanner({ ...inventory, ...clock }); + let inventory; + const runtime = createProjectDeleteRuntime({ ...deps, ...clock, readWorktreeSnapshot: budget => inventory.readSnapshot(budget) }); + inventory = createProjectDeleteInventory({ ...deps, ...runtime, ...clock, writer }); + const worktrees = deps.worktreeGit ? createProjectDeleteWorktrees({ runGit: deps.worktreeGit, + readActivity: runtime.readWorktreeActivity, startProcessReads: runtime.startProcessReads, now }) : null; + const planner = createProjectDeletePlanner({ ...inventory, ...clock, worktrees }); const stop = createProjectDeleteStop({ ...deps, ...runtime, ...clock }); - const service = createProjectDeleteService({ ...clock, writer, inventory, planner, stop, gate: deps.gate, log: deps.log, + const service = createProjectDeleteService({ ...clock, writer, inventory, planner, stop, worktrees, gate: deps.gate, log: deps.log, captureRuntimeRelease: runtime.captureRuntimeRelease, onHoldsInstalled: () => settleHolds?.(!disposed), notifyProjects: notify('notifyProjects'), notifySchedules: notify('notifySchedules') }); diff --git a/src/main/projects/project-delete-plan.js b/src/main/projects/project-delete-plan.js index 63f6a69ad..446dcc638 100644 --- a/src/main/projects/project-delete-plan.js +++ b/src/main/projects/project-delete-plan.js @@ -7,8 +7,10 @@ const { parseFolderKey } = require('../remote/remote-hosts'); const { worktreeParentPath } = require('../../../public/worktree-nesting'); const { OPTION_KEYS, isRecord, text, fail, canonicalPath, identity, stable, digest, compare, membershipRecord } = require('./project-delete-identity'); +const METADATA_FINISH_MARGIN_MS = 500; + function validateRequest(request) { - if (!isRecord(request) || Object.keys(request).some(key => !['projectPath', 'folderKey', 'options'].includes(key)) + if (!isRecord(request) || Object.keys(request).some(key => !['projectPath', 'folderKey', 'options', 'worktrees'].includes(key)) || !text(request.projectPath) || (request.folderKey !== undefined && !text(request.folderKey)) || !isRecord(request.options) || Object.keys(request.options).length !== OPTION_KEYS.length || Object.keys(request.options).some(key => !OPTION_KEYS.includes(key)) @@ -16,6 +18,11 @@ function validateRequest(request) { || request.options.schedules || request.options.transcripts) { throw fail('INVALID_REQUEST', 'Use the five explicit boolean A4 options; physical deletion is unavailable.'); } + if (request.worktrees !== undefined && (!Array.isArray(request.worktrees) || request.worktrees.length > 128 + || request.worktrees.some(value => !text(value) || !path.isAbsolute(value)) + || new Set(request.worktrees).size !== request.worktrees.length)) { + throw fail('INVALID_REQUEST', 'Select each linked worktree by its exact preview path.'); + } } async function resolveProject(request, snapshot, boundKey, memo, each, ordered) { @@ -114,6 +121,33 @@ function createProjectDeletePlanner(deps) { const rawTabs = items(runtime.tabs), rawJobs = items(runtime.jobs), runtimeCandidates = items(runtime.candidates); const refusals = [], warnings = []; const refuse = (code, target, error) => refusals.push({ code, target, error }); + const selectedWorktrees = request.worktrees || []; + let worktrees = []; + try { + if (project.alias !== null && selectedWorktrees.length) throw fail('WORKTREE_UNAVAILABLE', 'Remote worktree removal is unavailable.'); + if (deps.worktrees && project.alias === null && (boundKey === undefined || selectedWorktrees.length)) { + worktrees = items(await deps.worktrees.preview(project, { ...budget, snapshot, selectedWorktrees, + deadline: selectedWorktrees.length ? budget.deadline - METADATA_FINISH_MARGIN_MS + : now() + Math.min(2000, Math.max(0, (budget.deadline - now()) / 2)), + reportCandidate: candidate => { + if (!warnings.some(row => row.code === 'WORKTREE_UNAVAILABLE' && row.target === candidate.id && row.error === candidate.reason)) { + warnings.push({ code: 'WORKTREE_UNAVAILABLE', target: candidate.id, error: candidate.reason }); + } + }, + ...(boundKey === undefined ? {} : { worktreePaths: selectedWorktrees }) })); + } + worktrees = worktrees.map(row => ({ ...row, selected: selectedWorktrees.includes(row.path) })); + for (const target of selectedWorktrees) { + const row = worktrees.find(row => row.path === target); + if (!row?.removable || row.main || canonicalPath(target, null, memo) === project.projectPath) { + refuse('WORKTREE_UNAVAILABLE', target, row?.reason || 'This linked worktree is not removable. Reopen Delete for a fresh preview.'); + } + } + } catch (error) { + if (selectedWorktrees.length) refuse('WORKTREE_UNAVAILABLE', project.projectPath, + `${error.message} Use the dedicated "Delete worktree" action in the sidebar.`); + else warnings.push({ code: 'WORKTREE_UNAVAILABLE', error: error.message }); + } const rowPath = (row, key, code) => { if (row[key] === null) return null; try { return canonicalPath(row[key], row.alias, memo); } @@ -230,7 +264,7 @@ function createProjectDeletePlanner(deps) { schedules: { selected: false, available: false, effect: 'kept' }, transcripts: { selected: false, available: false, effect: 'kept' }, stopBackgroundJobs: { selected: request.options.stopBackgroundJobs, available: true }, - memory: { effect: 'kept' }, workFiles: { effect: 'kept' }, worktrees: { effect: 'kept' }, projectDirectory: { effect: 'kept' }, branches: { effect: 'kept' }, + memory: { effect: 'kept' }, workFiles: { effect: 'kept' }, worktrees: { effect: selectedWorktrees.length ? 'selected' : 'kept' }, projectDirectory: { effect: 'kept' }, branches: { effect: 'kept' }, }; warnings.push({ code: 'RETAINED_TRANSCRIPTS', error: 'Retained transcripts can restore transcript titles on re-add even when app names are discarded.' }); if (schedules.length) warnings.push({ code: 'SCHEDULE_REACTIVATION', error: 'Kept schedule files may reactivate when this project is re-added.' }); @@ -247,11 +281,13 @@ function createProjectDeletePlanner(deps) { } await ordered(refusals); const membershipDigest = digest({ project: { alias: project.alias, projectPath: project.projectPath }, ...membership }); - const fingerprint = digest({ membershipDigest, groups, members, tabs, jobs, schedules, options: request.options, stops, categories, warnings, refusals }); + const fingerprint = digest({ membershipDigest, groups, members, tabs, jobs, schedules, + worktrees: worktrees.filter(row => row.selected && !row.main && !row.projectDirectory), + options: request.options, stops, categories, warnings: warnings.filter(row => row.code !== 'WORKTREE_UNAVAILABLE'), refusals }); const revision = await read('readRevision', () => deps.readRevision(budget)); expired(); if (revision !== snapshot.revision) throw fail('SNAPSHOT_STALE', 'Writer changed during discovery; request a fresh preview.'); - return { ok: true, plan: { project, groups, members, tabs, jobs, stops, schedules, categories, + return { ok: true, plan: { project, groups, members, tabs, jobs, stops, schedules, categories, worktrees, counts: { conversations: new Set(members.map(row => row.conversationId)).size, parts: new Set(members.filter(row => !row.subagentId).map(row => row.partId)).size, subagents: members.filter(row => row.subagentId).length, transcripts: members.length, tabs: tabs.length, @@ -260,17 +296,21 @@ function createProjectDeletePlanner(deps) { }; return await read('planner.collect', collect); } catch (error) { - return { ok: false, code: error.code || 'DISCOVERY_UNAVAILABLE', error: error.message || 'Read-only planning unavailable.', ...discoveryDetails(error) }; + return { ok: false, code: error.code || 'DISCOVERY_UNAVAILABLE', + error: error.code === 'DISCOVERY_TIMEOUT' && input?.worktrees?.length + ? `${error.message} Use the dedicated "Delete worktree" action in the sidebar.` + : error.message || 'Read-only planning unavailable.', ...discoveryDetails(error) }; } finally { controller.abort(); } } - async function revalidate(plan) { + async function revalidate(plan, { withoutWorktrees = false } = {}) { try { const options = Object.fromEntries(OPTION_KEYS.map(key => [key, plan.categories[key].selected])); if (identity(plan.project).key !== plan.project.key) return { same: false, plan: null }; - const reply = await preview({ projectPath: plan.project.projectPath, options }, plan.project.key); + const reply = await preview({ projectPath: plan.project.projectPath, options, + worktrees: withoutWorktrees ? [] : (plan.worktrees || []).filter(row => row.selected).map(row => row.path) }, plan.project.key); return { same: reply.ok && reply.plan.fingerprint === plan.fingerprint && reply.plan.refusals.length === 0, plan: reply.ok ? reply.plan : null }; } catch { diff --git a/src/main/projects/project-delete-worktrees.js b/src/main/projects/project-delete-worktrees.js new file mode 100644 index 000000000..78401b94c --- /dev/null +++ b/src/main/projects/project-delete-worktrees.js @@ -0,0 +1,126 @@ +'use strict'; + +const path = require('node:path'); +const deletion = require('../../../worktree-delete'); +const { PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS } = require('../../../public/setting-defaults'); +const { canonicalPath, fail } = require('./project-delete-identity'); + +function createProjectDeleteWorktrees({ runGit, readActivity, startProcessReads = () => {}, now = Date.now }) { + const check = budget => { + if (budget.signal.aborted || now() >= budget.deadline) throw fail('DISCOVERY_TIMEOUT', 'Worktree not inspected: inventory time budget exhausted. Reopen Delete to retry.'); + }; + async function bounded(read, budget) { + check(budget); + let timer; + try { + const result = await Promise.race([Promise.resolve().then(read), new Promise((_, reject) => { + timer = setTimeout(() => reject(fail('DISCOVERY_TIMEOUT', 'Worktree not inspected: inventory time budget exhausted. Reopen Delete to retry.')), + Math.max(1, budget.deadline - now())); + })]); + check(budget); + return result; + } finally { clearTimeout(timer); } + } + async function preview(project, budget, prepareProcessReads = () => {}) { + if (project.alias !== null) throw fail('WORKTREE_UNAVAILABLE', 'Remote worktree removal is unavailable.'); + check(budget); + if (budget.worktreePaths?.length === 0) return []; + const list = await bounded(() => runGit(['-C', project.projectPath, 'worktree', 'list', '--porcelain']), budget); + check(budget); + const records = deletion.parseWorktreeList(list); + if (records.length > Math.min(128, budget.limit)) { + throw fail('DISCOVERY_LIMIT', 'Worktree registration is invalid or exceeds 128 entries. Review it with Git.'); + } + const rows = [], memo = new Map(), inventory = { records }; + const owner = canonicalPath(project.projectPath, null, memo); + for (const [index, { path: directory, fields }] of records.entries()) { + check(budget); + if (budget.worktreePaths && !budget.worktreePaths.includes(directory)) continue; + if (!path.isAbsolute(directory)) throw fail('WORKTREE_UNAVAILABLE', 'Git returned a relative worktree path.'); + const candidate = canonicalPath(directory, null, memo); + const row = { path: directory, branch: fields.find(field => field.startsWith('branch '))?.slice(7).replace(/^refs\/heads\//, '') || '(detached HEAD)', + main: index === 0, projectDirectory: candidate === owner || owner.startsWith(candidate + '/'), + removable: false, sessions: [], dirty: [], selected: false, statusKnown: false, sessionsKnown: false }; + if (row.main || row.projectDirectory) { + row.reason = 'The main checkout and the selected project directory are always kept.'; + } + rows.push(row); + } + const eligible = rows.filter(row => !row.main && !row.projectDirectory); + const selected = eligible.filter(row => budget.selectedWorktrees?.includes(row.path)); + async function inspect(group, inspectionBudget) { + let activities, activityError; + if (group.length) { + try { + prepareProcessReads(project, inspectionBudget); + activities = await bounded(() => readActivity({ ...project, worktreePaths: group.map(row => row.path) }, inspectionBudget), inspectionBudget); + for (const candidate of activities.candidates || []) budget.reportCandidate?.(candidate); + } + catch (error) { activityError = error; } + } + for (const row of group) { + try { + if (activityError) throw activityError; + const status = await bounded(() => deletion.readStatus(row.path, project.projectPath, runGit, undefined, inventory, + { ...inspectionBudget, now }), inspectionBudget); + check(inspectionBudget); + const activity = activities.byPath ? activities.byPath[row.path] : activities; + check(inspectionBudget); + Object.assign(row, status, { statusKnown: true, sessions: activity.sessions || [], jobs: activity.jobs || [], + sessionsKnown: activity.complete === true && !activity.candidates?.length }); + if (activity.ownershipUncertain) row.reason = 'Removal blocked by unattributed activity. Review the dialog-level inventory reasons.'; + else if (activity.complete !== true || !Array.isArray(activity.sessions) || !Array.isArray(activity.jobs) + || !Array.isArray(activity.candidates) || activity.candidates.length) row.reason = 'Worktree activity is uncertain. Check its sessions and Agents, then reopen Delete.'; + else if (activity.jobs.length) row.reason = 'Background jobs prevent worktree removal (#1090). Check the Agents view.'; + else if (activity.sessions.length) row.reason = 'Stop the sessions in this worktree first, then reopen Delete.'; + else if (status.locked || status.submodules?.length) row.reason = 'Locked worktrees and submodules require the dedicated Delete worktree dialog.'; + else row.removable = true; + } catch (error) { + row.reason = error.message + (selected.includes(row) ? ' Use the dedicated "Delete worktree" action in the sidebar.' : ''); + } + } + } + await inspect(selected, budget); + await inspect(eligible.filter(row => !selected.includes(row)), selected.length + ? { ...budget, deadline: now() + Math.min(2000, Math.max(0, (budget.deadline - now()) / 2)) } : budget); + return rows; + } + async function remove(project, selected, record) { + const controller = new AbortController(); + const budget = { signal: controller.signal, deadline: now() + PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS, limit: 20000 }; + try { + const current = await preview(project, { ...budget, worktreePaths: selected.map(row => row.path), selectedWorktrees: selected.map(row => row.path) }, startProcessReads); + for (const row of selected) { + const fresh = current.find(item => item.path === row.path); + if (!fresh?.removable || fresh.main || fresh.projectDirectory || fresh.fingerprint !== row.fingerprint) { + record({ path: row.path, state: 'refused', error: fresh?.reason || 'Worktree changed. Review a fresh preview before confirming again.' }); + return false; + } + } + } catch (error) { + record({ state: 'refused', error: error.message }); return false; + } finally { controller.abort(); } + for (const row of selected) { + let result, attempted = false; + try { + result = await deletion.removeWorktree(row.path, project.projectPath, row, async () => { + const removalController = new AbortController(); + const removalBudget = { ...budget, signal: removalController.signal, deadline: now() + PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS, + worktreePaths: [row.path], selectedWorktrees: [row.path] }; + try { + const current = await preview(project, removalBudget, startProcessReads); + const fresh = current.find(item => item.path === row.path); + if (!fresh?.removable || fresh.main || fresh.projectDirectory) throw fail('WORKTREE_UNAVAILABLE', fresh?.reason || 'Worktree registration changed.'); + return fresh; + } finally { removalController.abort(); } + }, async args => { attempted = true; return runGit(args); }); + } catch (error) { result = { ok: false, error: error.message }; } + record({ path: row.path, state: result.ok ? 'removed' : attempted ? 'failed' : 'refused', error: result.error }); + if (!result.ok) return false; + } + return true; + } + return { preview, remove }; +} + +module.exports = { createProjectDeleteWorktrees }; diff --git a/src/main/projects/project-delete.js b/src/main/projects/project-delete.js index 79b917ba8..bf987114f 100644 --- a/src/main/projects/project-delete.js +++ b/src/main/projects/project-delete.js @@ -4,7 +4,7 @@ const { randomUUID, randomBytes } = require('node:crypto'); const { PROJECT_DELETE_PREVIEW_TIMEOUT_MS } = require('../../../public/setting-defaults'); const { createDiscoveryBounds, discoveryDetails } = require('./project-delete-deadline'); const { operationId } = require('./project-delete-progress'); -const { membershipDigest, stable, isRecord, text, fail, OPTION_KEYS } = require('./project-delete-identity'); +const { membershipDigest, stable, isRecord, text, fail, OPTION_KEYS, identity } = require('./project-delete-identity'); function createProjectDeleteService(deps) { const { writer, planner, inventory, stop, gate, now = Date.now, schedule = setTimeout, cancel = clearTimeout } = deps; @@ -43,18 +43,27 @@ function createProjectDeleteService(deps) { function view(op) { return { ...failure(op.running ? 'EXECUTION_PENDING' : 'UNKNOWN'), operationId: op.id, state: 'unknown', ...op.result, host: op.project.alias, projectPath: op.project.projectPath, + worktrees: structuredClone(op.worktreeResults || []), ...(op.historyUnknown ? { worktreeHistoryUnknown: true } : {}), stopped: structuredClone(op.stopped), ...(op.historyUnknown ? { stoppedHistoryUnknown: true } : {}) }; } function acquire(op) { op.launch = gate.hold(op.project.projectPath, op.project.alias); - try { op.archive = writer.reserveProjectDeletion([op.project]); } - catch (error) { op.launch.release(); op.launch = null; throw error; } - op.admission = Promise.all([op.launch.ready, op.archive.ready]); + op.worktreeHolds = []; + try { + const linked = (op.plan?.worktrees || []).filter(row => row.selected); + for (const row of linked) op.worktreeHolds.push(gate.holdTree(row.path, op.project.alias)); + op.archive = writer.reserveProjectDeletion([op.project, ...linked.map(row => identity({ alias: op.project.alias, projectPath: row.path }))]); + } catch (error) { + for (const hold of op.worktreeHolds) hold.release(); + op.launch.release(); op.launch = null; throw error; + } + op.admission = Promise.all([op.launch.ready, op.archive.ready, ...op.worktreeHolds.map(hold => hold.ready)]); } async function release(op) { if (op.released) return; await op.admission; op.archive?.release(); op.launch?.release(); + for (const hold of op.worktreeHolds || []) hold.release(); op.releaseRuntime?.(); op.releaseRuntime = null; op.released = true; op.finished = op.historicalFinished ?? now(); if (projects.get(op.project.key) === op) projects.delete(op.project.key); @@ -141,12 +150,13 @@ function createProjectDeleteService(deps) { async function acceptState(op, state) { const committed = state.state === 'committed' && state.receiptAvailable === true && state.terminal === true && state.invalidation; const known = state.receiptAvailable === true && state.terminal === true && ['partial', 'notStarted'].includes(state.state); - op.result = { ...failure(state.code || 'RECEIPT_UNRESOLVED'), operationId: op.id, state: committed ? 'committed' : known ? state.state : 'unknown', - ok: !!committed, partial: known && state.state === 'partial', retryable: false, + const partial = known && (state.state === 'partial' || op.worktreeResults?.some(row => ['removed', 'failed'].includes(row.state))); + op.result = { ...failure(state.code || 'RECEIPT_UNRESOLVED'), operationId: op.id, state: committed ? 'committed' : partial ? 'partial' : known ? state.state : 'unknown', + ok: !!committed, partial: !!partial, retryable: false, completed: state.completed || [], kept: state.kept || [], failed: state.failed || [], skipped: state.remaining || [], observations: { projectHidden: state.projectHidden, settingsPresent: state.settingsPresent, metadata: state.metadata, readRevision: state.readRevision }, ...(committed ? { code: undefined, invalidation: structuredClone(state.invalidation) } : {}), - ...(known ? { code: state.state === 'partial' ? 'PARTIAL' : 'NOT_STARTED', refresh: true } : {}) }; + ...(known ? { code: partial ? 'PARTIAL' : 'NOT_STARTED', refresh: true } : {}) }; if (state.terminal || state.noLateCommit) await release(op); if (committed) { for (const name of ['notifyProjects', 'notifySchedules']) { @@ -217,8 +227,17 @@ function createProjectDeleteService(deps) { if (!after.plan) throw fail('REVALIDATION_UNAVAILABLE', after.error || 'Post-stop inventory read unavailable.'); let manifestInventory = acceptedInventory(op, after.plan); if (!manifestInventory || !(await stop.verify(prepared)).ok) throw fail('PREVIEW_CHANGED', 'Post-stop ownership changed.'); + const selected = (op.plan.worktrees || []).filter(row => row.selected); + if (selected.length) { + if (!deps.worktrees) throw fail('WORKTREE_UNAVAILABLE', 'Worktree deletion is unavailable.'); + const removed = await deps.worktrees.remove(op.project, selected, result => { + op.worktreeResults = op.worktreeResults.filter(row => row.path !== result.path); + op.worktreeResults.push(result); + }); + if (!removed) throw fail('WORKTREE_FAILED', 'Worktree removal did not complete. Inspect the listed folders and Git registration; review a fresh preview before trying again.'); + } const fresh = await bounded(() => writer.readProjectDeletionScope({ project: op.project })); - const final = await planner.revalidate(op.plan); + const final = await planner.revalidate(op.plan, { withoutWorktrees: selected.length > 0 }); if (!final.plan) throw fail('REVALIDATION_UNAVAILABLE', final.error || 'Final inventory read unavailable.'); manifestInventory = acceptedInventory(op, final.plan); if (!manifestInventory || fresh.projectEpoch !== op.epoch || String(fresh.writerRevision) !== final.plan.revision @@ -229,7 +248,8 @@ function createProjectDeleteService(deps) { try { return await acceptState(op, await bounded(() => writer.completeProjectDeletion(manifest), 60000)); } catch { op.result ||= failure('RECEIPT_UNRESOLVED'); return await reconcile(op); } } catch (error) { - op.result = { ...failure(error.code || 'DELETE_UNAVAILABLE'), error: error.message, state: 'notStarted', refresh: true }; + const partial = op.worktreeResults?.some(row => ['removed', 'failed'].includes(row.state)); + op.result = { ...failure(error.code || 'DELETE_UNAVAILABLE'), error: error.message, state: partial ? 'partial' : 'notStarted', partial: !!partial, refresh: true }; return view(op); } finally { op.running = false; @@ -252,6 +272,7 @@ function createProjectDeleteService(deps) { catch (error) { return Promise.resolve(failure(error.code || 'DELETION_ID')); } const op = { id, project: token.plan.project, epoch: token.epoch, plan: token.plan, options: token.options, stopped: [], authorities: new Set([sender]), notified: new Set(), running: true, + worktreeResults: (token.plan.worktrees || []).filter(row => row.selected).map(row => ({ path: row.path, state: 'remaining' })), releaseRuntime: deps.captureRuntimeRelease?.() }; operations.set(op.id, op); projects.set(op.project.key, op); try { acquire(op); } diff --git a/src/main/shared/project-operation-gate.js b/src/main/shared/project-operation-gate.js index 090f24b7e..ff01d46ba 100644 --- a/src/main/shared/project-operation-gate.js +++ b/src/main/shared/project-operation-gate.js @@ -6,6 +6,7 @@ const PROJECT_OPERATION_ERROR = 'A project operation is in progress. Wait for it function createProjectOperationGate() { const entries = new Map(); + const trees = new Map(); const keyFor = (project, alias) => { const remote = typeof alias === 'string' && alias.length > 0; const normalized = remote ? path.posix.normalize(project || '/').replace(/\/$/, '') || '/' : normalizeProjectPath(path.resolve(project || '.')); @@ -20,9 +21,14 @@ function createProjectOperationGate() { for (const resolve of entry.drained.splice(0)) resolve(); if (!entry.held) entries.delete(key); }; + const contains = (root, key) => { + const [host, directory] = JSON.parse(root), [candidateHost, candidate] = JSON.parse(key); + return host === candidateHost && (directory === candidate || candidate.startsWith(directory.replace(/\/$/, '') + '/')); + }; + const treeBlocked = key => [...trees.keys()].some(root => contains(root, key)); const tryAdmitAll = (projects, alias = null) => { const keys = [...new Set(projects.filter(project => project != null && project !== '').map(project => keyFor(project, alias)))]; - if (keys.some(key => entries.get(key)?.held)) return null; + if (keys.some(key => entries.get(key)?.held || treeBlocked(key))) return null; const admitted = keys.map(key => [key, entryFor(key)]); for (const [, entry] of admitted) entry.active++; let released = false; @@ -40,10 +46,20 @@ function createProjectOperationGate() { return tryAdmitAll([project], alias); }, tryAdmitAll, + holdTree(project, alias = null) { + const key = keyFor(project, alias); + if ([...trees.keys()].some(root => contains(root, key) || contains(key, root)) + || [...entries].some(([candidate, entry]) => entry.held && contains(key, candidate))) throw new Error(PROJECT_OPERATION_ERROR); + const pending = [...entries].filter(([candidate, entry]) => entry.active && contains(key, candidate)); + const marker = {}; + trees.set(key, marker); + return { ready: Promise.all(pending.map(([, entry]) => new Promise(resolve => entry.drained.push(resolve)))), + release() { if (trees.get(key) === marker) trees.delete(key); } }; + }, hold(project, alias = null) { const key = keyFor(project, alias); const entry = entryFor(key); - if (entry.held) throw new Error(PROJECT_OPERATION_ERROR); + if (entry.held || treeBlocked(key)) throw new Error(PROJECT_OPERATION_ERROR); entry.held = true; const ready = entry.active ? new Promise(resolve => { entry.drained.push(resolve); }) : Promise.resolve(); let released = false; diff --git a/test/dom-project-delete.test.js b/test/dom-project-delete.test.js index cf40100f5..45f64519d 100644 --- a/test/dom-project-delete.test.js +++ b/test/dom-project-delete.test.js @@ -9,6 +9,74 @@ const fs = require('node:fs'); const path = require('node:path'); const vm = require('node:vm'); +test('E unavailable worktree inventory has a visible reason outside JSON details', async t => { + const h = setup(t, { warnings: [{ code: 'WORKTREE_UNAVAILABLE', error: 'Git inventory unavailable' }] }); + const pending = h.start(); await flush(); + const dialog = h.document.querySelector('.choice-dialog').cloneNode(true); + dialog.querySelectorAll('details').forEach(node => node.remove()); + assert.match(dialog.textContent, /Git inventory unavailable/); + h.cancel(); await pending; +}); + +test('E kept labels omit removal warnings and removable labels bound dirty entries and count ignored files', async t => { + const h = setup(t, { worktrees: [ + { path: 'C:/repo', main: true, removable: false, dirty: [], sessions: [] }, + { path: 'C:/linked', removable: true, dirty: Array.from({ length: 8 }, (_, i) => '?? file-' + i), ignoredCount: 3, sessions: [] }, + ] }); + const pending = h.start(); await flush(); + const kept = h.document.querySelector('[data-choice-id="worktree:0"]').closest('label').textContent; + const linked = h.document.querySelector('[data-choice-id="worktree:1"]').closest('label').textContent; + assert.doesNotMatch(kept, /Ignored files are removed/); + assert.match(linked, /3 ignored/); + assert.match(linked, /and 3 more/); + assert.doesNotMatch(linked, /file-5/); + h.cancel(); await pending; +}); + +test('E worktree choices are individually previewed, never remembered, and main remains disabled', async t => { + const rows = [ + { path: 'C:/repo', branch: 'main', main: true, removable: false, reason: 'Main checkout is kept', sessions: [], dirty: [] }, + { path: 'C:/linked', branch: 'topic', main: false, removable: true, sessions: [], dirty: ['?? draft.txt'] }, + ]; + const h = setup(t, { worktrees: rows }); + h.w.localStorage.setItem('deleteProject.worktree:1', '1'); + let pending = h.start(); await flush(); + let box = h.document.querySelector('[data-choice-id="worktree:1"]'); + assert.ok(box, 'every linked worktree needs its own checkbox'); + assert.equal(box.checked, false); + assert.equal(h.document.querySelector('[data-choice-id="worktree:0"]').disabled, true); + assert.match(h.document.querySelector('.choice-dialog').textContent, /C:\/linked.*topic/s); + assert.match(h.document.querySelector('.choice-dialog').textContent, /draft\.txt/); + box.click(); await flush(); + assert.deepEqual(Array.from(h.calls.preview.at(-1).worktrees), ['C:/linked']); + h.confirm().click(); await pending; + pending = h.start(); await flush(); + box = h.document.querySelector('[data-choice-id="worktree:1"]'); + assert.equal(box.checked, false, 'accepted destructive worktree choices must reset on every open'); + h.cancel(); await pending; +}); + +test('E partial disk removal notice preserves per-path outcomes and recovery action', async t => { + const h = setup(t); + await h.w.settleProjectDeletion(h.p, { state: 'partial', operationId: 'disk', + worktrees: [{ path: 'C:/removed', state: 'removed' }, { path: 'C:/failed', state: 'failed', error: 'Inspect registration' }] }); + const notice = h.document.querySelector('.app-notice'); + assert.match(notice.textContent, /C:\/removed/, 'partial notice must show disk outcomes'); + assert.match(notice.textContent, /Inspect registration/); + assert.equal(notice.querySelector('.app-notice-action').textContent, 'Review remaining deletion'); +}); + +test('E changed dirty bytes after the visible row require reopening rather than silent new consent', async t => { + const row = { path: 'C:/linked', branch: 'topic', removable: true, fingerprint: 'shown', dirty: [], sessions: [] }; + const h = setup(t, { worktrees: [row] }); + const pending = h.start(); await flush(); + row.fingerprint = 'new-bytes'; row.dirty = ['?? unseen.txt']; + h.document.querySelector('[data-choice-id="worktree:0"]').click(); await flush(); + assert.equal(h.confirm().disabled, true, 'changed worktree preview must require reopening'); + assert.match(h.document.querySelector('.choice-dialog').textContent, /reopen/i); + h.cancel(); await pending; +}); + test('selected preview keeps its own watchdog and shows the failed port with an in-dialog retry', async t => { const h = setup(t), original = h.w.api.previewProjectDelete, timers = new Map(); let id = 0, time = 0, finish, calls = 0; @@ -37,8 +105,12 @@ test('selected preview keeps its own watchdog and shows the failed port with an h.cancel(); await pending; }); -for (const settles of [true, false]) test(`pending execute follows beyond 130 seconds or stops at the shared ceiling, settles=${settles}`, async t => { - const h = setup(t), timers = new Map(), applied = []; +for (const selected of [0, 2]) for (const settles of [true, false]) test(`pending execute respects the ceiling, selected=${selected}, settles=${settles}`, async t => { + const worktrees = Array.from({ length: 2 }, (_, i) => ({ path: 'C:/linked-' + i, removable: true, fingerprint: 'stable', sessions: [], dirty: [] })); + const h = setup(t, { worktrees }), timers = new Map(), applied = []; + const base = 3 * 20000 + 2 * 10000 + 60000 + 60000 + 70000 + 10000 + 3 * 10000 + 15000; + const ceiling = base + (selected ? 15000 + selected * (15000 + 5000 + 120000 + 15000) : 0); + const settleAt = selected ? ceiling - 1000 : 130000; let time = 0, id = 0, finished = false; h.w.Date.now = () => time; h.w.setTimeout = (fn, ms) => { timers.set(++id, { fn, at: time + ms }); return id; }; @@ -50,14 +122,15 @@ for (const settles of [true, false]) test(`pending execute follows beyond 130 se }; h.w.api.projectDeleteState = request => { h.calls.state.push(request); - return new Promise(resolve => h.w.setTimeout(() => resolve(settles && time >= 130000 + return new Promise(resolve => h.w.setTimeout(() => resolve(settles && time >= settleAt ? { ok: true, state: 'committed', operationId: 'slow', invalidation: { sessionIds: [], restoreTargets: [] } } - : pendingReply), 10000)); + : pendingReply), 1000)); }; h.w.applyProjectDeletion = async result => applied.push(result); const pending = h.start().then(result => { finished = true; return result; }); - await flush(); h.confirm().click(); await flush(); - const ceiling = 3 * 20000 + 2 * 10000 + 60000 + 60000 + 70000 + 10000 + 3 * 10000 + 15000; + await flush(); + for (let i = 0; i < selected; i++) { h.document.querySelector(`[data-choice-id="worktree:${i}"]`).click(); await flush(); } + h.confirm().click(); await flush(); for (; time < ceiling && !finished;) { time += 1000; for (const [key, timer] of [...timers]) if (timer.at <= time) { timers.delete(key); timer.fn(); } @@ -69,7 +142,7 @@ for (const settles of [true, false]) test(`pending execute follows beyond 130 se assert.ok(h.calls.state.every(request => request.operationId === 'slow'), 'all reads must keep the accepted operation ID'); if (settles) { assert.equal(applied.length, 1, 'a pending execution settling after 130 seconds must apply its committed result'); - assert.equal(time, 130000); + assert.equal(time, settleAt); assert.equal(h.document.querySelector('.app-notice'), null); } else { assert.equal(time, ceiling, 'persistent pending must be followed until the shared ceiling'); @@ -78,7 +151,7 @@ for (const settles of [true, false]) test(`pending execute follows beyond 130 se assert.match(h.document.querySelector('.app-notice').textContent, /Check deletion state/); assert.equal(h.w.isProjectDeleting(h.p), true); } - assert.equal(require('../public/setting-defaults').PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS, ceiling); + assert.equal(require('../public/setting-defaults').PROJECT_DELETE_FOLLOWUP_TIMEOUT_MS, base); }); test('pending follow-up rejects a changed operation identity', async t => { diff --git a/test/project-action-harness.js b/test/project-action-harness.js index ca4a5145a..8ba4fcde8 100644 --- a/test/project-action-harness.js +++ b/test/project-action-harness.js @@ -25,6 +25,7 @@ function loadProjectActionHandlers(overrides = {}) { const start = source.indexOf('// --- IPC: remap-project ---'); const end = source.indexOf('// --- IPC: get-projects ---', start); const context = vm.createContext({ + ...require('../public/setting-defaults'), fs, path, encodeProjectPath, isPanelShellSession, require: require('node:module').createRequire(path.join(__dirname, '../main.js')), ipcMain: { handle: (name, handler) => handlers.set(name, handler) }, diff --git a/test/project-delete-main.test.js b/test/project-delete-main.test.js index 1ab7dac7c..4ecf6fc50 100644 --- a/test/project-delete-main.test.js +++ b/test/project-delete-main.test.js @@ -413,6 +413,53 @@ for (const populated of [false, true]) test(`real composition previews and commi if (populated) assert.ok(fs.existsSync(h.transcript)); }); +test('E main composition removes a selected folder before real writer completion and keeps external transcripts', supported, async t => { + const h = await setup(t, true); + h.main.dispose(); + const linked = path.join(h.projectPath, 'linked'); fs.mkdirSync(linked); + fs.writeFileSync(path.join(linked, 'draft'), 'discard only on consent'); + const activitySignals = []; + h.ports.cliSessionState.getSidebarDescriptors = () => [{ sessionId: 'linked-session', cwd: linked }]; + h.ports.cliSessionState.readProcessTableSnapshot = async (_deadline, opts) => ({ + signal: opts.signal, map: new Map(), expiresAt: h.time.now() + 3000, + }); + h.ports.cliSessionState.readStatusEvidence = async (id, _deadline, opts) => { + if (id === 'linked-session') activitySignals.push(opts?.processTable?.signal); + return { known: true, live: null }; + }; + const removed = []; + h.ports.worktreeGit = async args => { + if (args.includes('list')) { + const separator = args.includes('-z') ? '\0' : '\n'; + return [h.projectPath, linked].filter(p => fs.existsSync(p)).map(p => + ['worktree ' + p.replaceAll('\\', '/'), 'HEAD abc', 'branch refs/heads/topic', ''].join(separator) + separator).join(''); + } + if (args.includes('rev-parse')) return path.join(h.projectPath, 'no-lock') + '\n'; + if (args.includes('ls-files')) return ''; + if (args.includes('status')) return path.resolve(args[1]) === linked ? '?? draft\0' : ''; + if (args.includes('remove')) { + assert.ok(activitySignals.slice(-2).every(Boolean), 'main composition must start isolated reads for both disk guards'); + assert.notEqual(activitySignals.at(-1), activitySignals.at(-2), 'each disk guard needs its own process table'); + assert.equal(h.calls.includes('completeProjectDeletion'), false, 'disk must precede writer submission'); + removed.push(args.at(-1)); fs.rmSync(linked, { recursive: true }); return ''; + } + throw new Error('Unexpected git call'); + }; + const main = h.compose(); main.attach(h.ports.getMainWindow()); h.load(); await main.startRecovery(); + const capability = await h.preview(); + const selected = capability.plan.worktrees.find(row => path.resolve(row.path) === linked); + assert.equal(selected.removable, true, JSON.stringify(selected)); + const preview = await h.invoke('preview-project-delete', { projectPath: h.projectPath, options, worktrees: [selected.path] }); + assert.ok(preview.token, JSON.stringify(preview)); + assert.equal(fs.existsSync(linked), true, 'preview must have no filesystem effects'); + const result = await h.execute(preview); + assert.equal(result.state, 'committed', JSON.stringify(result)); + assert.deepEqual(removed, [selected.path]); + assert.equal(result.worktrees[0].state, 'removed'); + assert.ok(fs.existsSync(h.transcript)); + assert.equal(fs.existsSync(linked), false); +}); + test('early attach binds first loaded document and reload revokes old token', supported, async t => { const h = await setup(t); await h.main.startRecovery(); assert.equal((await h.preview()).code, 'UNAUTHORIZED'); diff --git a/test/project-delete-worktrees-real-git.test.js b/test/project-delete-worktrees-real-git.test.js new file mode 100644 index 000000000..fe2dabfb5 --- /dev/null +++ b/test/project-delete-worktrees-real-git.test.js @@ -0,0 +1,64 @@ +'use strict'; + +const test = require('node:test'); +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const os = require('node:os'); +const path = require('node:path'); +const { execFileSync } = require('node:child_process'); +const { localGitEnv } = require('../src/main/changes/git-changes-runner'); +const shared = require('../worktree-delete'); +let implementation; +try { implementation = require('../src/main/projects/project-delete-worktrees'); } +catch (error) { if (error.code !== 'MODULE_NOT_FOUND') throw error; } + +function gitFixture(t) { + assert.equal(typeof implementation?.createProjectDeleteWorktrees, 'function', 'production linked-worktree adapter must exist'); + const root = fs.realpathSync.native(fs.mkdtempSync(path.join(os.tmpdir(), 'delete-e-'))); + t.after(() => fs.rmSync(root, { recursive: true, force: true })); + const env = { ...localGitEnv(), GIT_CONFIG_GLOBAL: path.join(root, 'no-config'), GIT_CONFIG_NOSYSTEM: '1', + GIT_AUTHOR_NAME: 'Test', GIT_AUTHOR_EMAIL: 'test@example.invalid', GIT_COMMITTER_NAME: 'Test', GIT_COMMITTER_EMAIL: 'test@example.invalid' }; + const commands = [], git = args => execFileSync('git', args, { cwd: root, env, encoding: 'utf8', timeout: 15000, windowsHide: true }); + git(['init', '-q', '--template=']); fs.writeFileSync(path.join(root, 'tracked'), 'base'); + git(['add', '.']); git(['commit', '-qm', 'fixture']); + const target = path.join(root, 'linked é'), kept = path.join(root, 'kept'); + git(['worktree', 'add', '-qb', 'topic', target]); git(['worktree', 'add', '-qb', 'keep', kept]); + const state = { sessions: [], candidates: [], jobs: [] }; + const runGit = async (args, consume) => { commands.push(args); return consume ? shared.streamGit(args, consume, { env }) : git(args); }; + const adapter = implementation.createProjectDeleteWorktrees({ runGit, readActivity: async () => ({ complete: true, ...state }) }); + const project = { alias: null, projectPath: root }; + const budget = () => ({ signal: new AbortController().signal, deadline: Date.now() + 15000, limit: 20000 }); + return { root, target, kept, state, commands, adapter, project, budget }; +} + +test('E real Git discovery lists main, branch, dirty/untracked bytes; removes exactly the reviewed linked directory', async t => { + const f = gitFixture(t); + fs.writeFileSync(path.join(f.target, 'untracked'), 'discard'); + let rows; + await assert.doesNotReject(async () => { rows = await f.adapter.preview(f.project, f.budget()); }, 'installed Git must support worktree inventory'); + assert.equal(rows.find(row => row.main).removable, false); + const selected = rows.find(row => path.resolve(row.path) === f.target); + assert.equal(selected.branch, 'topic'); assert.equal(selected.removable, true); + assert.ok(selected.dirty.some(line => line.includes('untracked'))); + const results = []; + assert.equal(await f.adapter.remove(f.project, [selected], row => results.push(row)), true); + assert.equal(fs.existsSync(f.target), false); assert.equal(fs.existsSync(f.kept), true); + assert.equal(fs.readFileSync(path.join(f.root, 'tracked'), 'utf8'), 'base'); + assert.deepEqual(results.map(row => row.state), ['removed']); + assert.equal(f.commands.filter(args => args.includes('remove')).length, 1); +}); + +test('E real Git changed contents and new live sessions refuse before any disk removal', async t => { + const f = gitFixture(t); + fs.writeFileSync(path.join(f.target, 'untracked'), 'old'); + const rows = await f.adapter.preview(f.project, f.budget()), selected = rows.find(row => path.resolve(row.path) === f.target); + fs.writeFileSync(path.join(f.target, 'untracked'), 'new'); + assert.equal(await f.adapter.remove(f.project, [selected], () => {}), false); + assert.equal(fs.existsSync(f.target), true); + const fresh = (await f.adapter.preview(f.project, f.budget())).find(row => path.resolve(row.path) === f.target); + f.state.sessions.push({ sessionId: 'live', cwd: f.target }); + assert.equal(await f.adapter.remove(f.project, [fresh], () => {}), false); + assert.equal(f.commands.some(args => args.includes('remove')), false, 'late activity must prevent Git removal'); + const blocked = (await f.adapter.preview(f.project, f.budget())).find(row => path.resolve(row.path) === f.target); + assert.equal(blocked.removable, false); assert.equal(blocked.sessions[0].sessionId, 'live'); +}); diff --git a/test/project-delete-worktrees.test.js b/test/project-delete-worktrees.test.js new file mode 100644 index 000000000..51847efaf --- /dev/null +++ b/test/project-delete-worktrees.test.js @@ -0,0 +1,679 @@ +'use strict'; + +const test = require('node:test'); +const assert = require('node:assert/strict'); +const fs = require('node:fs'); +const os = require('node:os'); +const path = require('node:path'); +const { createProjectDeletePlanner } = require('../src/main/projects/project-delete-plan'); +const { createProjectDeleteService } = require('../src/main/projects/project-delete'); +const { createProjectOperationGate } = require('../src/main/shared/project-operation-gate'); +let implementation; +try { implementation = require('../src/main/projects/project-delete-worktrees'); } +catch (error) { if (error.code !== 'MODULE_NOT_FOUND') throw error; } +const options = { sessions: false, settings: false, schedules: false, transcripts: false, stopBackgroundJobs: false }; + +for (const located of [true, false]) for (const mode of ['fresh', 'stale', 'missing', 'mismatched']) { + test(`E activity consumes isolated ${mode} process evidence, located=${located}`, async t => { + const f = gitFixture(t), vm = require('node:vm'); + const filename = path.join(__dirname, '../cli-session-state.js'); + const context = vm.createContext({ require: require('node:module').createRequire(filename), module: { exports: {} }, + process, Buffer, Map, Set, setTimeout, clearTimeout, setInterval, clearInterval }); + vm.runInContext(fs.readFileSync(filename, 'utf8'), context, { filename }); + const state = context.module.exports, id = '01234567-89ab-cdef-0123-456789abcdef'; + const dir = path.join(f.root, 'status'); fs.mkdirSync(dir); + const start = '133000000000000000'; + fs.writeFileSync(path.join(dir, '42.json'), JSON.stringify({ pid: 42, sessionId: id, kind: 'interactive', + status: 'idle', pidDomain: 'win32:anchor', procStart: start })); + let time = Date.now(), reads = 0; + state.init({ dir, platform: 'win32', activeSessions: new Map(), now: () => time, isProcessAlive: () => true, + readProcessTable: async () => new Map(), readProcStartMany: async () => new Map([[42, start]]) }); + t.after(() => state.stop()); + const refresh = t.mock.method(context, 'refreshProcessTable'); + const tables = []; + const runtime = require('../src/main/projects/project-delete-main').createProjectDeleteRuntime({ + now: () => time, activeSessions: new Map(), jobsDir: path.join(f.root, 'jobs'), homeDir: f.root, + runClaude: async () => ({ code: 0, stdout: '[]' }), cliSessionState: { + getSidebarDescriptors: () => [{ sessionId: id, cwd: located ? f.target : null }], getScheduleRunSnapshot: () => [], + readProcessTableSnapshot: async (deadline, opts) => { + assert.equal(deadline, budget.deadline); assert.equal(opts.signal, budget.signal); assert.equal(opts.fresh, true); + reads++; + return { at: time, observedAt: time, expiresAt: time + 3000, + map: mode === 'missing' ? null : new Map([[42, { ppid: 1, created: mode === 'mismatched' ? '134000000000000000' : start }]]) }; + }, + readStatusEvidence: (id, deadline, opts) => { tables.push(opts?.processTable); return state.readStatusEvidence(id, deadline, opts); }, + }, + }); + const budget = { ...f.budget(), snapshot: { sessions: [] }, selectedWorktrees: [f.target] }; + runtime.startProcessReads({}, budget); + await new Promise(resolve => setImmediate(resolve)); + time += 4000; + let result = await runtime.readWorktreeActivity({ ...f.project, worktreePaths: [f.target] }, budget); + if (mode === 'stale') { + time += 4000; + result = await runtime.readWorktreeActivity({ ...f.project, worktreePaths: [f.target] }, budget); + } + assert.equal(refresh.mock.callCount(), 0, 'E must never fall back to refreshProcessTable'); + assert.equal(reads, 2, 'E shares one deadline-bounded refresh per inventory signal'); + assert.ok(tables.every(table => table?.expiresAt), 'every E evidence read receives the isolated table'); + const row = result.byPath[f.target]; + if (!located) assert.equal(row.ownershipUncertain, true, 'unlocated live or uncertain evidence blocks removal'); + else if (mode === 'fresh') assert.equal(row.sessions.length, 1); + else assert.equal(row.candidates.length, 1, 'stale, missing or mismatched table leaves activity uncertain'); + }); +} + +test('E removal starts isolated process reads for preflight and every final folder guard', async t => { + const f = gitFixture(t), started = [], activities = [], commands = []; + const adapter = implementation.createProjectDeleteWorktrees({ + startProcessReads: (_request, budget) => started.push(budget.signal), + readActivity: async (_project, budget) => { activities.push(budget.signal); return { complete: true, sessions: [], jobs: [], candidates: [] }; }, + runGit: async args => { + commands.push(args); + if (args.includes('list')) return [f.root, f.target, f.kept].map(dir => `worktree ${dir}\nHEAD abc\n\n`).join(''); + if (args.includes('rev-parse')) return path.join(f.root, 'absent-lock'); + return ''; + }, + }); + const budget = f.budget(); + const rows = (await adapter.preview(f.project, budget)).filter(row => !row.main); + activities.length = 0; + assert.equal(await adapter.remove(f.project, rows, () => {}), true); + assert.equal(started.length, 3, 'preflight and two final guards must each start process reads'); + assert.equal(new Set(started).size, 3, 'removal budgets must not share process-table snapshots'); + assert.ok(started.every(signal => signal !== budget.signal)); + assert.deepEqual(activities, started, 'activity checks consume the signal whose reads were started'); + assert.equal(commands.filter(args => args.includes('remove')).length, 2); +}); + +test('slow unselected status leaves a metadata plan with uninspected rows', async t => { + const f = gitFixture(t), p = planning([]); + p.deps.readSnapshot = async () => ({ complete: true, initialScanComplete: true, revision: '1', + projects: [{ alias: null, projectPath: f.root, folderKeys: [] }], declaredHosts: [] }); + const calls = []; + p.deps.worktrees = implementation.createProjectDeleteWorktrees({ + runGit: async args => { + calls.push(args); + if (args.includes('list')) return [f.root, f.target, f.kept].map(dir => `worktree ${dir}\nHEAD abc\n\n`).join(''); + if (args.includes('rev-parse')) return path.join(f.root, 'absent-lock'); + return new Promise(() => {}); + }, readActivity: async () => ({ complete: true, sessions: [], jobs: [], candidates: [] }), + }); + const started = Date.now(); + const result = await createProjectDeletePlanner({ ...p.deps, timeoutMs: 1000 }).preview({ + projectPath: f.root, options, worktrees: [], + }); + assert.equal(result.ok, true, 'slow worktree status must not time out metadata planning'); + assert.ok(Date.now() - started < 1000, 'inventory must reserve time for metadata planning'); + for (const row of result.plan.worktrees.filter(row => !row.main)) { + assert.equal(row.removable, false); + assert.equal(row.statusKnown, false); + assert.match(row.reason, /not inspected/i); + } + assert.equal(calls.filter(args => args.includes('status')).length, 1, 'expired inventory starts no further status calls'); + assert.equal(result.plan.refusals.length, 0); +}); + +for (const selected of [false, true]) test(`three-second status gets the ${selected ? 'selected' : 'unselected'} inspection budget`, async t => { + const f = gitFixture(t), p = planning([]), deletion = require('../worktree-delete'); + let time = 0; + const deadlines = []; + t.mock.method(deletion, 'readStatus', async (directory, _root, _git, _unused, _inventory, budget) => { + deadlines.push({ directory, remaining: budget.deadline - time }); + time += 3000; + return { dirty: [], fingerprint: directory }; + }); + p.deps.readSnapshot = async () => ({ complete: true, initialScanComplete: true, revision: '1', + projects: [{ alias: null, projectPath: f.root, folderKeys: [] }], declaredHosts: [] }); + p.deps.worktrees = implementation.createProjectDeleteWorktrees({ now: () => time, + runGit: async () => [f.root, f.kept, f.target].map(dir => `worktree ${dir}\nHEAD abc\n\n`).join(''), + readActivity: async () => ({ complete: true, sessions: [], jobs: [], candidates: [] }), + }); + const planner = createProjectDeletePlanner({ ...p.deps, now: () => time, timeoutMs: 6500 }); + const result = await planner.preview({ projectPath: f.root, options, worktrees: selected ? [f.target] : [] }); + assert.equal(result.ok, true, 'slow physical inspection must leave a complete metadata plan'); + assert.deepEqual(result.plan.refusals, [], 'a three-second selected inspection must be allowed'); + const chosen = result.plan.worktrees.find(row => row.path === f.target); + assert.equal(chosen.removable, selected, 'selected rows must have enough time for a three-second status'); + assert.equal(chosen.statusKnown, selected); + const unselected = result.plan.worktrees.find(row => row.path === f.kept); + assert.equal(unselected.removable, false); + assert.match(unselected.reason, /not inspected/i); + for (const read of deadlines.filter(row => !selected || row.directory !== f.target)) { + assert.ok(read.remaining <= 2000, 'unselected reads retain the two-second cap even with a selection'); + assert.ok(read.remaining <= (selected ? 1750 : 3250), 'unselected reads take at most half the remaining planner budget'); + } + if (selected) { + assert.equal(deadlines[0].directory, f.target, 'unselected inventory cannot starve a selected row'); + assert.equal((await planner.revalidate(result.plan)).same, true, 'confirm must allow the same slow selected row'); + } +}); + +test('planner deadline still bounds the metadata fence after a selected inspection expires', async t => { + const f = gitFixture(t), p = planning([]), deletion = require('../worktree-delete'); + t.mock.method(deletion, 'readStatus', () => new Promise(() => {})); + p.deps.readSnapshot = async () => ({ complete: true, initialScanComplete: true, revision: '1', + projects: [{ alias: null, projectPath: f.root, folderKeys: [] }], declaredHosts: [] }); + p.deps.worktrees = implementation.createProjectDeleteWorktrees({ + runGit: async () => [f.root, f.target].map(dir => `worktree ${dir}\nHEAD abc\n\n`).join(''), + readActivity: async () => ({ complete: true, sessions: [], jobs: [], candidates: [] }), + }); + p.deps.readRevision = () => new Promise(() => {}); + const result = await createProjectDeletePlanner({ ...p.deps, timeoutMs: 1000 }).preview({ + projectPath: f.root, options, worktrees: [f.target], + }); + assert.equal(result.ok, false, 'the overall deadline remains authoritative for a stalled metadata fence'); + assert.equal(result.code, 'DISCOVERY_TIMEOUT'); + assert.match(result.error, /Delete worktree.*sidebar/i); +}); + +test('selected inspection reserves 500ms for the metadata fence and returns an uninspected row', async t => { + const f = gitFixture(t), p = planning([]); + let time = 0, inspectionDeadline, fenceTime; + p.deps.readSnapshot = async () => ({ complete: true, initialScanComplete: true, revision: '1', + projects: [{ alias: null, projectPath: f.root, folderKeys: [] }], declaredHosts: [] }); + p.deps.readRevision = async () => { fenceTime = time; time += 100; return '1'; }; + p.deps.worktrees = implementation.createProjectDeleteWorktrees({ now: () => time, + runGit: async args => { + if (args.includes('list')) return [f.root, f.target].map(dir => `worktree ${dir}\nHEAD abc\n\n`).join(''); + if (args.includes('rev-parse')) return path.join(f.root, 'absent-lock'); + if (args.includes('status')) time = inspectionDeadline; + return ''; + }, + readActivity: async (_project, budget) => { + inspectionDeadline = budget.deadline; + return { complete: true, sessions: [], jobs: [], candidates: [] }; + }, + }); + const result = await createProjectDeletePlanner({ ...p.deps, now: () => time, timeoutMs: 10000 }).preview({ + projectPath: f.root, options, worktrees: [f.target], + }); + assert.equal(result.ok, true, 'exhausted selected inspection must leave time for metadata planning'); + assert.equal(inspectionDeadline, 9500, 'selected inspection must end 500ms before the planner deadline'); + assert.equal(fenceTime, 9500); + assert.equal(result.plan.revision, '1'); + const selected = result.plan.worktrees.find(row => row.path === f.target); + assert.equal(selected.removable, false); + assert.equal(selected.statusKnown, false); + assert.match(selected.reason, /not inspected/i); + assert.match(selected.reason, /Delete worktree.*sidebar/i); + assert.equal(result.plan.refusals.length, 1); + assert.equal(result.plan.refusals[0].target, f.target); +}); + +test('selected inspection failure directs the user to Delete worktree in the sidebar', async t => { + const f = gitFixture(t), deletion = require('../worktree-delete'); + t.mock.method(deletion, 'readStatus', async () => { throw new Error('Worktree not inspected: status unavailable.'); }); + const rows = await f.adapter.preview(f.project, { ...f.budget(), selectedWorktrees: [f.target.replaceAll('\\', '/')] }); + const selected = rows.find(row => path.resolve(row.path) === f.target); + assert.equal(selected.removable, false); + assert.match(selected.reason, /Delete worktree.*sidebar/i, 'uninspectable selection must offer the dedicated sidebar action'); +}); + +for (const cwd of ['relative', null]) for (const binding of [null, 'folder', 'projectPath']) test(`session cwd ${cwd} is scoped by ${binding || 'dialog-level ownership'}`, async t => { + const f = gitFixture(t), { createProjectDeleteRuntime } = require('../src/main/projects/project-delete-main'); + const row = { sessionId: 'stray', cwd, ...(binding === 'folder' ? { folder: 'linked-folder' } + : binding === 'projectPath' ? { projectPath: f.target } : {}) }; + const runtime = createProjectDeleteRuntime({ activeSessions: new Map(), jobsDir: path.join(f.root, 'jobs'), homeDir: f.root, + runClaude: async () => ({ code: 0, stdout: '[]' }), cliSessionState: { + getSidebarDescriptors: () => [row], getScheduleRunSnapshot: () => [], readStatusEvidence: async () => ({ known: true, live: null }), + } }); + const result = await runtime.readWorktreeActivity({ ...f.project, worktreePaths: [f.target, f.kept] }, { + ...f.budget(), snapshot: { sessions: [], projects: [{ alias: null, projectPath: f.target, folderKeys: ['linked-folder'] }] }, + }); + assert.deepEqual(result.byPath[f.kept].candidates, [], 'an unrelated row must not make every folder uncertain'); + assert.equal(result.byPath[f.target].candidates.length, binding ? 1 : 0); + assert.equal(result.candidates.length, binding ? 0 : 1, 'unattributed session reason is shown once at dialog level'); +}); + +for (const kind of ['active', 'scheduled run', 'live descriptor', 'unknown descriptor', 'ambiguous descriptor', 'stopped descriptor', 'dormant']) { + test(`unlocated ${kind} only blocks selected folders when activity is live or uncertain`, async t => { + const f = gitFixture(t), { createProjectDeleteRuntime } = require('../src/main/projects/project-delete-main'); + const row = { sessionId: 'unlocated', cwd: null }; + const blocking = !['stopped descriptor', 'dormant'].includes(kind); + const runtime = createProjectDeleteRuntime({ + activeSessions: new Map(kind === 'active' ? [[row.sessionId, row]] : []), + jobsDir: path.join(f.root, 'jobs'), homeDir: f.root, runClaude: async () => ({ code: 0, stdout: '[]' }), + cliSessionState: { + getSidebarDescriptors: () => kind.includes('descriptor') ? [row] : [], + getScheduleRunSnapshot: () => kind === 'scheduled run' ? [row] : [], + readStatusEvidence: async () => ({ known: kind !== 'unknown descriptor', + live: kind === 'live descriptor' ? { pid: 123 } : null, ambiguous: kind === 'ambiguous descriptor' }), + }, + }); + const p = planning([]); + p.deps.readSnapshot = async () => ({ complete: true, initialScanComplete: true, revision: '1', sessions: [row], + projects: [{ alias: null, projectPath: f.root, folderKeys: [] }], declaredHosts: [] }); + p.deps.worktrees = implementation.createProjectDeleteWorktrees({ readActivity: runtime.readWorktreeActivity, + runGit: async args => args.includes('list') ? [f.root, f.target, f.kept].map(dir => `worktree ${dir}\nHEAD abc\n\n`).join('') + : args.includes('rev-parse') ? path.join(f.root, 'absent-lock') : '' }); + const planner = createProjectDeletePlanner(p.deps); + for (const selected of [[], [f.target], [f.target, f.kept]]) { + const preview = await planner.preview({ projectPath: f.root, options, worktrees: selected }); + assert.equal(preview.ok, true, 'unlocated activity must not prevent the metadata plan'); + assert.equal(preview.plan.warnings.filter(row => /Session cwd unavailable/.test(row.error)).length, 1, + 'duplicate session sources must produce one dialog reason'); + assert.equal(preview.plan.refusals.length, blocking ? selected.length : 0, + 'unlocated live or uncertain session must refuse every selected folder'); + for (const row of preview.plan.worktrees.filter(row => !row.main)) { + const refused = blocking && selected.includes(row.path); + assert.equal(row.removable, !refused); + if (refused) assert.match(row.reason, /unattributed activity/i); + } + } + }); +} + +test('global unknown job is shown once and blocks selected folders only', async t => { + const f = gitFixture(t), { createProjectDeleteRuntime } = require('../src/main/projects/project-delete-main'); + const runtime = createProjectDeleteRuntime({ activeSessions: new Map(), jobsDir: path.join(f.root, 'jobs'), homeDir: f.root, + runClaude: async () => ({ code: 0, stdout: JSON.stringify([{ id: '1234abcd', kind: 'background', sessionId: 'unknown' }]) }), + cliSessionState: { getSidebarDescriptors: () => [], getScheduleRunSnapshot: () => [] } }); + const result = await runtime.readWorktreeActivity({ ...f.project, worktreePaths: [f.target, f.kept] }, + { ...f.budget(), selectedWorktrees: [f.target], snapshot: { sessions: [] } }); + assert.deepEqual(result.byPath[f.kept].candidates, [], 'global job reason must not be copied to each folder'); + assert.equal(result.candidates.length, 1); + assert.match(result.candidates[0].reason, /no durable job record/); + assert.equal(result.byPath[f.target].ownershipUncertain, true, 'unknown job may own selected folder'); + assert.equal(result.byPath[f.kept].ownershipUncertain, false); + const p = planning([]); + p.deps.readSnapshot = async () => ({ complete: true, initialScanComplete: true, revision: '1', sessions: [], + projects: [{ alias: null, projectPath: f.root, folderKeys: [] }], declaredHosts: [] }); + p.deps.worktrees = implementation.createProjectDeleteWorktrees({ readActivity: runtime.readWorktreeActivity, + runGit: async args => args.includes('list') ? [f.root, f.target, f.kept].map(dir => `worktree ${dir}\nHEAD abc\n\n`).join('') + : args.includes('rev-parse') ? path.join(f.root, 'absent-lock') : '' }); + const planner = createProjectDeletePlanner(p.deps); + for (const selected of [[], [f.target]]) { + const preview = await planner.preview({ projectPath: f.root, options, worktrees: selected }); + assert.equal(preview.ok, true); + assert.equal(preview.plan.warnings.filter(row => /no durable job record/.test(row.error)).length, 1); + assert.equal(preview.plan.worktrees.find(row => row.path === f.target).removable, selected.length === 0); + assert.equal(preview.plan.worktrees.find(row => row.path === f.kept).removable, true); + assert.equal(preview.plan.refusals.length, selected.length); + } +}); + +test('shared status stops after a late Git reply when its inspection deadline expires', async t => { + const f = gitFixture(t), deletion = require('../worktree-delete'); + let now = 0; + const commands = []; + await assert.rejects(deletion.readStatus(f.target, f.root, async args => { + commands.push(args); + now = 20; + return args.includes('rev-parse') ? path.join(f.root, 'absent-lock') : ''; + }, undefined, { records: [f.root, f.target].map(directory => ({ path: directory, fields: [] })) }, + { deadline: 10, signal: new AbortController().signal, now: () => now }), /not inspected/i); + assert.equal(commands.length, 1, 'late Git reply must not trigger further status or hashing'); +}); + +test('E production activity reader includes descendant sessions, schedules and refused background records', async t => { + const { createProjectDeleteRuntime } = require('../src/main/projects/project-delete-main'); + const root = fs.realpathSync.native(fs.mkdtempSync(path.join(os.tmpdir(), 'e-activity-'))); + t.after(() => fs.rmSync(root, { recursive: true, force: true })); + const child = path.join(root, 'child'); fs.mkdirSync(child); + const jobsDir = path.join(root, 'jobs'); fs.mkdirSync(path.join(jobsDir, '1234abcd'), { recursive: true }); + fs.writeFileSync(path.join(jobsDir, '1234abcd', 'state.json'), JSON.stringify({ state: 'done', cwd: child, + sessionId: '12345678-1234-1234-1234-123456789abc' })); + const runtime = createProjectDeleteRuntime({ activeSessions: new Map([['live', { cwd: child, sessionId: 'live' }]]), jobsDir, + homeDir: root, runClaude: async () => ({ code: 0, stdout: '[]' }), cliSessionState: { + getSidebarDescriptors: options => { + assert.equal(options?.allWriters, true, 'worktree deletion must include every descriptor writer'); + return [{ sessionId: 'external', cwd: child }]; + }, + readStatusEvidence: async () => ({ known: true, live: { pid: 123 }, ambiguous: false }), + getScheduleRunSnapshot: () => [{ sessionId: 'schedule', cwd: child }], + } }); + assert.equal(typeof runtime.readWorktreeActivity, 'function', 'linked worktrees require authoritative descendant activity'); + const result = await runtime.readWorktreeActivity({ alias: null, projectPath: root }, + { signal: new AbortController().signal, deadline: Date.now() + 15000, limit: 20000, snapshot: { sessions: [] } }); + assert.ok(result.sessions.some(row => row.sessionId === 'live')); + assert.ok(result.sessions.some(row => row.sessionId === 'external')); + assert.ok(result.jobs.some(row => row.id === '1234abcd'), 'done background record must remain refused'); + assert.ok(result.jobs.some(row => row.sessionId === 'schedule')); + assert.ok(result.candidates.some(row => row.reason.includes('#1090'))); +}); + +function planning(rows) { + const projectPath = path.resolve(os.tmpdir(), 'e-planning'); + const state = { rows, removed: [], events: [], revision: '1' }; + const empty = { complete: true, groups: [], members: [], tabs: [], jobs: [], schedules: [], candidates: [] }; + const worktrees = { + preview: async () => structuredClone(state.rows), + async remove(project, selected, record) { + for (const row of selected) { + state.events.push('remove:' + row.path); + const result = { path: row.path, state: state.fail === row.path ? 'failed' : 'removed', error: state.fail === row.path ? 'Git refused; inspect disk' : undefined }; + record(result); + if (result.state === 'failed') return false; + state.removed.push(row.path); + } + return true; + }, + }; + const deps = { + waitForIndex: async () => {}, readSnapshot: async () => ({ complete: true, initialScanComplete: true, revision: state.revision, + projects: [{ alias: null, projectPath, folderKeys: [] }], declaredHosts: [] }), + discoverOwnership: async () => empty, discoverSchedules: async () => empty, + readRuntimeState: async () => empty, readRevision: async () => state.revision, worktrees, + }; + const planner = createProjectDeletePlanner(deps); + const request = selected => ({ projectPath, options, worktrees: selected }); + return { state, deps, planner, request, projectPath, worktrees }; +} + +test('E planner binds exact individual selection and content to the fingerprint', async () => { + const row = { path: path.resolve(os.tmpdir(), 'linked-e'), branch: 'topic', removable: true, fingerprint: 'one', sessions: [], dirty: [] }; + const f = planning([row]); + const kept = await f.planner.preview(f.request([])); + assert.equal(kept.ok, true, 'empty worktree selection must be accepted'); + const chosen = await f.planner.preview(f.request([row.path])); + assert.equal(chosen.ok, true, 'individual worktree selection must be accepted'); + assert.equal(chosen.plan.worktrees[0].selected, true); + assert.notEqual(chosen.plan.fingerprint, kept.plan.fingerprint, 'selection must change the token fingerprint'); + assert.equal((await f.planner.revalidate(chosen.plan)).same, true); + f.state.rows[0].fingerprint = 'changed-content'; + assert.equal((await f.planner.revalidate(chosen.plan)).same, false, 'changed worktree content must invalidate consent'); + for (const selected of [[row.path, row.path], [path.resolve(os.tmpdir(), 'foreign')], [f.projectPath]]) { + const reply = await f.planner.preview(f.request(selected)); + assert.ok(!reply.ok || reply.plan.refusals.length, 'foreign, main and duplicate selections must refuse'); + } + f.state.rows[0].removable = false; f.state.rows[0].reason = 'Stop live session first'; + assert.ok((await f.planner.preview(f.request([row.path]))).plan.refusals.length); +}); + +test('E subtree holds drain admitted children and reject new descendant launches', async () => { + const gate = createProjectOperationGate(), root = path.resolve(os.tmpdir(), 'e-gate'); + assert.equal(typeof gate.holdTree, 'function', 'worktree deletion needs subtree exclusion'); + const lease = gate.tryAdmit(path.join(root, 'nested')); + const hold = gate.holdTree(root); let ready = false; + hold.ready.then(() => { ready = true; }); await Promise.resolve(); + assert.equal(ready, false, 'existing descendant launch must drain'); + assert.equal(gate.tryAdmit(path.join(root, 'new')), null); + assert.throws(() => gate.hold(path.join(root, 'child'))); + const sibling = gate.tryAdmit(root + '-sibling'); assert.ok(sibling); sibling.release(); + const remote = gate.tryAdmit(root, 'remote'); assert.ok(remote); remote.release(); + lease.release(); await hold.ready; hold.release(); + const reopened = gate.tryAdmit(path.join(root, 'new')); assert.ok(reopened); reopened.release(); +}); + +async function serviceFixture(t, fail) { + const a = path.resolve(os.tmpdir(), 'e-selected-a'), b = path.resolve(os.tmpdir(), 'e-selected-b'); + const f = planning([a, b].map(p => ({ path: p, removable: true, fingerprint: p, sessions: [], dirty: [] }))); + f.state.fail = fail ? b : undefined; + const gate = createProjectOperationGate(), sender = { valid: () => true }; + const writer = { + listProjectDeletionOperations: async () => ({ rows: [], revision: 1, nextCursor: null }), + readProjectDeletionScope: async () => ({ writerRevision: 1, projectEpoch: 0, writerMembershipDigest: 'durable' }), + reserveProjectDeletion: () => ({ ready: Promise.resolve(), release() {} }), + async completeProjectDeletion() { + f.state.events.push('metadata'); + return { state: 'committed', terminal: true, receiptAvailable: true, invalidation: {}, committedRevision: 2 }; + }, + }; + const stop = { preflight: async () => ({ ok: true }), stop: async () => { + f.state.events.push('stop'); return { ok: true, stopped: [], failed: [], skipped: [] }; + }, verify: async () => ({ ok: true }) }; + const service = createProjectDeleteService({ writer, planner: f.planner, inventory: { inspectRetainedFiles: async () => [] }, + stop, gate, worktrees: f.worktrees }); + t.after(() => service.dispose()); await service.initialize(); + return { ...f, a, b, gate, service, sender, writer }; +} + +test('E disk effects remain partial when the metadata writer proves no commit', async t => { + const f = await serviceFixture(t); + f.writer.completeProjectDeletion = async () => ({ state: 'notStarted', terminal: true, receiptAvailable: true, noLateCommit: true }); + const preview = await f.service.preview(f.sender, f.request([f.a])); + const result = await f.service.execute(f.sender, { token: preview.token, fingerprint: preview.plan.fingerprint }); + assert.equal(result.state, 'partial', 'removed folders cannot be reported as an operation that never started'); + assert.equal(result.partial, true); + assert.equal(result.worktrees[0].state, 'removed'); +}); + +test('E service holds selected descendant launches until the removal promise settles', async t => { + const f = await serviceFixture(t); let finish, entered; + const started = new Promise(resolve => { entered = resolve; }); + f.worktrees.remove = async () => { entered(); await new Promise(resolve => { finish = resolve; }); return false; }; + const preview = await f.service.preview(f.sender, f.request([f.a])); + const executing = f.service.execute(f.sender, { token: preview.token, fingerprint: preview.plan.fingerprint }); + await started; + const lease = f.gate.tryAdmit(path.join(f.a, 'new-session')); + finish(); await executing; + assert.equal(lease, null, 'no descendant may launch while disk removal is in flight'); +}); + +test('E service removes only selected worktrees after stop and before metadata', async t => { + const f = await serviceFixture(t); + const preview = await f.service.preview(f.sender, f.request([f.a])); + assert.ok(preview.token, 'selected worktrees must produce an owned token'); + const result = await f.service.execute(f.sender, { token: preview.token, fingerprint: preview.plan.fingerprint }); + assert.equal(result.ok, true); + assert.deepEqual(f.state.events, ['stop', 'remove:' + f.a, 'metadata']); + assert.deepEqual(result.worktrees.map(row => [row.path, row.state]), [[f.a, 'removed']]); + assert.deepEqual(f.state.removed, [f.a]); +}); + +test('E failed second removal seals a partial result, never submits metadata or replays on state read', async t => { + const f = await serviceFixture(t, true); + const preview = await f.service.preview(f.sender, f.request([f.a, f.b])); + assert.ok(preview.token, 'selected worktrees must produce an owned token'); + const result = await f.service.execute(f.sender, { token: preview.token, fingerprint: preview.plan.fingerprint }); + assert.equal(result.state, 'partial'); assert.equal(result.ok, false); + assert.deepEqual(result.worktrees.map(row => row.state), ['removed', 'failed']); + assert.equal(f.state.events.includes('metadata'), false, 'disk failure must keep parent metadata untouched'); + await f.service.readState(f.sender, { operationId: result.operationId }); + assert.deepEqual(f.state.events, ['stop', 'remove:' + f.a, 'remove:' + f.b]); + const lease = f.gate.tryAdmit(path.join(f.a, 'child')); assert.ok(lease); lease.release(); +}); + +function gitFixture(t) { + assert.equal(typeof implementation?.createProjectDeleteWorktrees, 'function', 'production linked-worktree adapter must exist'); + const root = fs.realpathSync.native(fs.mkdtempSync(path.join(os.tmpdir(), 'delete-e-'))); + t.after(() => fs.rmSync(root, { recursive: true, force: true })); + const target = path.join(root, 'linked'), kept = path.join(root, 'kept'); + fs.mkdirSync(target); fs.mkdirSync(kept); fs.writeFileSync(path.join(root, 'tracked'), 'base'); + const commands = [], state = { sessions: [], candidates: [], jobs: [] }; + const runGit = async args => { + commands.push(args); + if (args.includes('list')) { + const separator = args.includes('-z') ? '\0' : '\n'; + return [root, target, kept].filter(p => fs.existsSync(p)).map(p => + ['worktree ' + p.replaceAll('\\', '/'), 'HEAD abc', 'branch refs/heads/topic', ''].join(separator) + separator).join(''); + } + if (args.includes('rev-parse')) return path.join(root, 'absent-lock') + '\n'; + if (args.includes('ls-files')) return ''; + if (args.includes('status')) return fs.existsSync(path.join(args[1], 'untracked')) ? '?? untracked\0' : ''; + if (args.includes('remove')) { fs.rmSync(args.at(-1), { recursive: true }); return ''; } + throw new Error('Unexpected Git command: ' + args.join(' ')); + }; + const adapter = implementation.createProjectDeleteWorktrees({ runGit, readActivity: async () => ({ complete: true, ...state }) }); + const project = { alias: null, projectPath: root.replaceAll('\\', '/').toLowerCase() }; + if (process.platform !== 'win32') project.projectPath = root; + const budget = () => ({ signal: new AbortController().signal, deadline: Date.now() + 15000, limit: 20000 }); + return { root, target, kept, state, commands, adapter, project, budget, runGit }; +} + +for (const stage of ['preflight', 'final', 'reread']) { + test(`E ${stage} inspection aborts both process reads before returning`, async t => { + const f = gitFixture(t); + const selected = (await f.adapter.preview(f.project, f.budget())).find(row => path.resolve(row.path) === f.target); + const signals = [], pending = new Set(); + const hold = signal => new Promise(resolve => { + pending.add(resolve); + signal.addEventListener('abort', () => { pending.delete(resolve); resolve({ code: 0, stdout: '[]', map: null }); }, { once: true }); + }); + const runtime = require('../src/main/projects/project-delete-main').createProjectDeleteRuntime({ + homeDir: f.root, runClaude: (_args, opts) => hold(opts.signal), + cliSessionState: { readProcessTableSnapshot: (_deadline, opts) => hold(opts.signal) }, + }); + let inspections = 0; + const adapter = implementation.createProjectDeleteWorktrees({ + runGit: async args => { + if (stage === 'reread' && args.includes('remove')) throw new Error('Git refused'); + return f.runGit(args); + }, + startProcessReads: (project, budget) => { + signals.push(budget.signal); + runtime.startProcessReads(project, budget); + }, + readActivity: async () => ({ complete: ++inspections < ({ preflight: 1, final: 2, reread: 3 })[stage], ...f.state }), + }); + t.after(() => { + for (const resolve of pending) resolve({ code: 0, stdout: '[]', map: null }); + }); + assert.equal(await adapter.remove(f.project, [selected], () => {}), false); + assert.equal(signals.length, ({ preflight: 1, final: 2, reread: 3 })[stage]); + assert.ok(signals.every(signal => signal.aborted), 'every completed inspection must abort its process-read signal'); + assert.equal(pending.size, 0, 'neither Claude nor process-table reads may remain pending'); + }); +} + +for (const stage of ['preflight', 'final']) for (const reason of ['list error', 'ineligible']) { + test(`E ${stage} ${reason} does not start unnecessary process reads`, async t => { + const f = gitFixture(t); + const selected = (await f.adapter.preview(f.project, f.budget())).find(row => path.resolve(row.path) === f.target); + let lists = 0, reads = 0; + const adapter = implementation.createProjectDeleteWorktrees({ + runGit: async args => { + if (args.includes('list') && ++lists === (stage === 'preflight' ? 1 : 2)) { + if (reason === 'list error') throw new Error('Git list unavailable'); + return `worktree ${selected.path}\nHEAD abc\n\n`; + } + return f.runGit(args); + }, + startProcessReads: () => { reads++; }, + readActivity: async () => ({ complete: true, ...f.state }), + }); + assert.equal(await adapter.remove(f.project, [selected], () => {}), false); + assert.equal(reads, stage === 'preflight' ? 0 : 1, 'ineligible or unreadable registration must not start Claude or table reads'); + assert.equal(f.commands.some(args => args.includes('remove')), false); + }); +} + +test('E shared removal with a controlled Git port discovery lists main, branch, dirty/untracked bytes; removes exactly the reviewed linked directory', async t => { + const f = gitFixture(t); + fs.writeFileSync(path.join(f.target, 'untracked'), 'discard'); + const rows = await f.adapter.preview(f.project, f.budget()); + assert.equal(rows.find(row => row.main).removable, false); + assert.equal(rows.find(row => row.main).statusKnown, false, 'kept checkout must not be scanned'); + const selected = rows.find(row => path.resolve(row.path) === f.target); + assert.equal(selected.branch, 'topic'); assert.equal(selected.removable, true); + assert.ok(selected.dirty.some(line => line.includes('untracked'))); + const results = []; + assert.equal(await f.adapter.remove(f.project, [selected], row => results.push(row)), true); + assert.equal(fs.existsSync(f.target), false); assert.equal(fs.existsSync(f.kept), true); + assert.equal(fs.readFileSync(path.join(f.root, 'tracked'), 'utf8'), 'base'); + assert.deepEqual(results.map(row => row.state), ['removed']); + assert.equal(f.commands.filter(args => args.includes('remove')).length, 1); +}); + +test('E adapter rejects remote, main checkout and uncertain activity without invoking Git removal', async t => { + const f = gitFixture(t); + await assert.rejects(f.adapter.preview({ ...f.project, alias: 'remote' }, f.budget()), { code: 'WORKTREE_UNAVAILABLE' }); + let rows = await f.adapter.preview(f.project, f.budget()); + assert.equal(await f.adapter.remove(f.project, [rows.find(row => row.main)], () => {}), false); + f.state.candidates.push({ reason: 'External ownership unknown' }); + rows = await f.adapter.preview(f.project, f.budget()); + assert.equal(rows.find(row => path.resolve(row.path) === f.target).removable, false); + assert.equal(f.commands.some(args => args.includes('remove')), false); +}); + +test('E shared removal with a controlled Git port changed contents and new live sessions refuse before any disk removal', async t => { + const f = gitFixture(t); + fs.writeFileSync(path.join(f.target, 'untracked'), 'old'); + const rows = await f.adapter.preview(f.project, f.budget()), selected = rows.find(row => path.resolve(row.path) === f.target); + fs.writeFileSync(path.join(f.target, 'untracked'), 'new'); + assert.equal(await f.adapter.remove(f.project, [selected], () => {}), false); + assert.equal(fs.existsSync(f.target), true); + const fresh = (await f.adapter.preview(f.project, f.budget())).find(row => path.resolve(row.path) === f.target); + f.state.sessions.push({ sessionId: 'live', cwd: f.target }); + assert.equal(await f.adapter.remove(f.project, [fresh], () => {}), false); + assert.equal(f.commands.some(args => args.includes('remove')), false, 'late activity must prevent Git removal'); + const blocked = (await f.adapter.preview(f.project, f.budget())).find(row => path.resolve(row.path) === f.target); + assert.equal(blocked.removable, false); assert.equal(blocked.sessions[0].sessionId, 'live'); +}); + +test('E inventory supports Git 2.24 newline porcelain and scans only removable rows', async t => { + const f = gitFixture(t); + await f.adapter.preview(f.project, f.budget()); + assert.equal(f.commands.some(args => args.includes('list') && args.includes('-z')), false, 'Git 2.24 rejects list -z'); + assert.equal(f.commands.filter(args => args.includes('list')).length, 1, 'registration is read once per inventory'); + assert.equal(f.commands.some(args => args.includes('status') && path.resolve(args[1]) === f.root), false, 'main checkout must not be scanned'); +}); + +test('E no selection ignores dirty changes while selected bytes invalidate consent', async t => { + const f = await serviceFixture(t); + const preview = await f.service.preview(f.sender, f.request([])); + f.state.rows[0].dirty.push('?? new.txt'); f.state.rows[0].fingerprint = 'new'; + const result = await f.service.execute(f.sender, { token: preview.token, fingerprint: preview.plan.fingerprint }); + assert.equal(result.state, 'committed', 'unselected dirty bytes must not invalidate project consent'); + const g = await serviceFixture(t); + const selected = await g.service.preview(g.sender, g.request([g.a])); + g.state.rows[0].fingerprint = 'new'; + const changed = await g.service.execute(g.sender, { token: selected.token, fingerprint: selected.plan.fingerprint }); + assert.equal(changed.code, 'PREVIEW_CHANGED'); + assert.equal(g.state.removed.length, 0); +}); + +test('E precheck refusal has no partial disk effect or invented failed path', async t => { + const f = gitFixture(t), results = []; + const rows = await f.adapter.preview(f.project, f.budget()); + const selected = rows.find(row => path.resolve(row.path) === f.target); + fs.writeFileSync(path.join(f.target, 'untracked'), 'late'); + await f.adapter.remove(f.project, [selected], row => results.push(row)); + assert.equal(results[0].state, 'refused', 'no Git remove was attempted'); +}); + +test('E whole-inventory failure refuses without blaming the first selected path', async t => { + const f = gitFixture(t); + const selected = (await f.adapter.preview(f.project, f.budget())).find(row => path.resolve(row.path) === f.target); + const adapter = implementation.createProjectDeleteWorktrees({ runGit: async () => { throw new Error('inventory offline'); }, readActivity: async () => ({ complete: true }) }); + const failures = []; + await adapter.remove(f.project, [selected], row => failures.push(row)); + assert.equal(failures[0].state, 'refused'); + assert.equal(failures[0].path, undefined, 'whole inventory failure has no individual path'); +}); + +test('E service reports precheck refusal without partially completed deletion', async t => { + const f = await serviceFixture(t); + f.worktrees.remove = async (_project, _selected, record) => { record({ state: 'refused', error: 'inventory offline' }); return false; }; + const preview = await f.service.preview(f.sender, f.request([f.a])); + const result = await f.service.execute(f.sender, { token: preview.token, fingerprint: preview.plan.fingerprint }); + assert.equal(result.partial, false, 'refusal is not a disk effect'); + assert.equal(result.state, 'notStarted'); + assert.equal(f.state.events.includes('metadata'), false); +}); + +test('E confirm only inspects selected worktrees and retains the last removal guard', async t => { + const f = gitFixture(t); + const selected = (await f.adapter.preview(f.project, f.budget())).find(row => path.resolve(row.path) === f.target); + f.commands.length = 0; + assert.equal(await f.adapter.remove(f.project, [selected], () => {}), true); + assert.equal(f.commands.some(args => args.includes('status') && path.resolve(args[1]) !== f.target), false, 'confirm must not inspect unselected folders'); + assert.equal(f.commands.filter(args => args.includes('status') && !args.includes('--ignored')).length, 2, 'preflight and immediately before removal'); +}); + +test('E preview shares one Claude roster and path resolution across sibling worktree rows', async t => { + const f = gitFixture(t), { createProjectDeleteRuntime } = require('../src/main/projects/project-delete-main'); + let spawns = 0, descriptors = 0; + const resolutions = new Map(); + const runtime = createProjectDeleteRuntime({ fs: { ...fs.promises, realpath: async value => { + resolutions.set(value, (resolutions.get(value) || 0) + 1); return fs.promises.realpath(value); + } }, activeSessions: new Map(), jobsDir: path.join(f.root, 'jobs'), homeDir: f.root, + runClaude: async () => { spawns++; return { code: 0, stdout: '[]' }; }, cliSessionState: { + getSidebarDescriptors: () => { descriptors++; return [{ sessionId: 'one', cwd: f.target }, { sessionId: 'two', cwd: f.target }]; }, + readStatusEvidence: async () => ({ known: true, live: null }), getScheduleRunSnapshot: () => [], + } }); + const adapter = implementation.createProjectDeleteWorktrees({ runGit: async args => { + f.commands.push(args); + if (args.includes('list')) return [f.root, f.target, f.kept].map(p => `worktree ${p.replaceAll('\\', '/')}\nHEAD abc\n\n`).join('').replaceAll('\n', args.includes('-z') ? '\0' : '\n'); + if (args.includes('rev-parse')) return path.join(f.root, 'absent-lock'); + return ''; + }, readActivity: runtime.readWorktreeActivity }); + const budget = { ...f.budget(), snapshot: { sessions: [] } }; + await runtime.readJobs(f.project, budget); + const rows = await adapter.preview(f.project, budget); + assert.equal(rows.length, 3); + assert.equal(spawns, 1, 'one claude agents spawn per preview, including parent inventory'); + assert.equal(descriptors, 1, 'session inventory is read once'); + assert.equal(Math.max(...resolutions.values()), 1, 'paths resolve once per inventory'); +}); diff --git a/test/session-index-sequences.test.js b/test/session-index-sequences.test.js index ad32e4ca7..d7b4039db 100644 --- a/test/session-index-sequences.test.js +++ b/test/session-index-sequences.test.js @@ -23,6 +23,7 @@ function handler(name, deps) { assert.ok(registration, name); let captured; const context = vm.createContext({ ...deps, writer: memoryWriter(deps), + ...require('../public/setting-defaults'), spawnChild: require('./project-action-harness').spawnFromExec(deps.execFile), worktreeDelete: require('../worktree-delete'), activeSessions: new Map(), cliSessionState: { getSidebarDescriptors: () => [] }, diff --git a/test/worktree-delete-safety.test.js b/test/worktree-delete-safety.test.js index e293a9271..98c53bf94 100644 --- a/test/worktree-delete-safety.test.js +++ b/test/worktree-delete-safety.test.js @@ -106,6 +106,7 @@ test('worktree removal has a longer timeout than preview Git calls', async () => const source = fs.readFileSync(path.join(__dirname, '../main.js'), 'utf8'); const options = []; const context = vm.createContext({ localGitEnv: () => ({}), + ...require('../public/setting-defaults'), execFile: (_exe, _args, opts, callback) => { options.push(opts); callback(null, '', ''); } }); vm.runInContext(source.slice(source.indexOf('function worktreeGit('), source.indexOf('async function worktreeDeletionStatus(')), context, { filename: path.join(__dirname, '../main.js') }); diff --git a/test/worktree-delete.test.js b/test/worktree-delete.test.js index 93e7f9844..8b73306a8 100644 --- a/test/worktree-delete.test.js +++ b/test/worktree-delete.test.js @@ -9,6 +9,27 @@ const deletion = require('../worktree-delete'); const target = '/home/jb/repo/.claude/worktrees/task'; +test('Git removal timeout follows the subcommand after leading options, never a path called remove', async () => { + const fs = require('node:fs'), vm = require('node:vm'); + const filename = path.join(__dirname, '../main.js'); + const source = fs.readFileSync(filename, 'utf8'); + const timeouts = []; + const defaults = require('../public/setting-defaults'); + const context = vm.createContext({ ...defaults, localGitEnv: () => ({}), execFile: (_exe, _args, options, cb) => { + timeouts.push(options.timeout); cb(null, '', ''); + } }); + vm.runInContext(require('./app-source').extractFunction(source, 'worktreeGit'), context, { filename }); + await context.worktreeGit(['-C', 'remove', 'status']); + await context.worktreeGit(['-c', 'x=y', '-C', '/repo', 'worktree', 'remove', '--', '/linked']); + await context.worktreeGit(['-C', '/repo', 'worktree', 'list', 'remove']); + assert.deepEqual(timeouts, [15000, 120000, 15000]); + context.PROJECT_DELETE_WORKTREE_INSPECTION_TIMEOUT_MS = 17000; + context.PROJECT_DELETE_WORKTREE_REMOVE_TIMEOUT_MS = 125000; + await context.worktreeGit(['worktree', 'list', '--porcelain']); + await context.worktreeGit(['worktree', 'remove', '--', '/linked']); + assert.deepEqual(timeouts.slice(3), [17000, 125000], 'Git must use the shared timeout bindings'); +}); + function fixture() { const state = { dirty: '', lock: null, removes: [], cleaned: 0, failRemove: false }; const handlers = loadProjectActionHandlers({ diff --git a/worktree-delete.js b/worktree-delete.js index 3baade8d2..baaf9b1e2 100644 --- a/worktree-delete.js +++ b/worktree-delete.js @@ -5,23 +5,31 @@ const path = require('node:path'); const fs = require('node:fs'); const { StringDecoder } = require('node:string_decoder'); const { resolveOnDisk } = require('./src/main/shared/resolve-path-on-disk'); +const { DIRECTORY_SCAN_MS } = require('./public/setting-defaults'); const HASH_LIMIT = 512 * 1024 * 1024; const DIRECTORY_LIMIT = 200000; -const DIRECTORY_SCAN_MS = 5000; function within(root, candidate) { const relative = path.relative(root, candidate); return relative && relative !== '..' && !relative.startsWith('..' + path.sep) && !path.isAbsolute(relative); } -async function refuseDirectoryLinks(root) { +function checkInspection(budget) { + if (budget?.signal?.aborted || (budget?.now || Date.now)() >= budget?.deadline) { + throw Object.assign(new Error('Worktree not inspected: inventory time budget exhausted. Reopen Delete to retry.'), { code: 'DISCOVERY_TIMEOUT' }); + } +} + +async function refuseDirectoryLinks(root, budget) { + checkInspection(budget); let stat; try { stat = await fs.promises.lstat(root); } catch (error) { if (error.code === 'ENOENT') return; throw error; } if (stat.isSymbolicLink()) throw new Error(`Deletion refused: the worktree path itself is a directory link: ${root}. Remove the link first without recursive deletion, then select the registered worktree.`); const started = Date.now(); const checkTime = () => { + checkInspection(budget); if (Date.now() - started >= DIRECTORY_SCAN_MS) throw new Error('Directory link scan exceeded its 5 second time budget. Review or reduce the worktree directories before trying Delete again.'); }; const realRoot = await fs.promises.realpath(root).catch(() => null); @@ -77,6 +85,7 @@ async function refuseDirectoryLinks(root) { } function hashBytes(budget, bytes) { + checkInspection(budget); budget.used += bytes; if (budget.used > HASH_LIMIT) { const largest = [...budget.files].sort((a, b) => b[1] - a[1]).slice(0, 10).map(([name, size]) => `${name} (${size} bytes)`); @@ -141,10 +150,11 @@ async function canonicalPath(value) { return comparablePath(await fs.promises.realpath(value).catch(() => value)); } -async function registeredPath(value) { +async function registeredPath(value, memo = new Map()) { const absolute = path.resolve(value); const parent = path.dirname(absolute); - return comparablePath(path.join(await fs.promises.realpath(parent).catch(() => parent), path.basename(absolute))); + if (!memo.has(parent)) memo.set(parent, fs.promises.realpath(parent).catch(() => parent)); + return comparablePath(path.join(await memo.get(parent), path.basename(absolute))); } async function runningSessions(worktreePath, activeSessions, descriptors) { @@ -182,7 +192,16 @@ function unquote(value) { return Buffer.from(bytes).toString('utf8'); } +function parseWorktreeList(list) { + return list.split(/\r?\n\r?\n/).filter(record => record.trim()).map(record => { + const fields = record.split(/\r?\n/); + if (!fields[0].startsWith('worktree ')) throw new Error('Git returned invalid worktree registration.'); + return { path: unquote(fields[0].slice(9)), fields }; + }); +} + async function fileFingerprint(root, name, submodules, runGit, depth, budget) { + checkInspection(budget); const absolute = path.resolve(root, name); const relative = path.relative(path.resolve(root), absolute); if (!relative || relative === '..' || relative.startsWith('..' + path.sep) || path.isAbsolute(relative)) { @@ -191,8 +210,13 @@ async function fileFingerprint(root, name, submodules, runGit, depth, budget) { let stat; try { stat = await fs.promises.lstat(absolute); } catch (error) { if (error.code === 'ENOENT') return ['missing']; throw error; } - const realRoot = resolveOnDisk(root); - const candidate = resolveOnDisk(stat.isSymbolicLink() ? path.dirname(absolute) : absolute); + const resolve = value => { + budget.resolutions ||= new Map(); + if (!budget.resolutions.has(value)) budget.resolutions.set(value, resolveOnDisk(value)); + return budget.resolutions.get(value); + }; + const realRoot = resolve(root); + const candidate = resolve(stat.isSymbolicLink() ? path.dirname(absolute) : absolute); if (!realRoot || !candidate || (candidate !== realRoot && !within(realRoot, candidate))) { throw new Error('A file resolves outside the worktree. Review its directory links before deleting.'); } @@ -265,10 +289,16 @@ async function statusSnapshot(worktreePath, runGit, depth = 0, budget = { used: return { dirty, ignored, submodules, index, records: recordsForFingerprint.sort() }; } -async function readStatus(worktreePath, parentRepo, runGit, readFile = fs.promises.readFile) { +async function readStatus(worktreePath, parentRepo, runGit, readFile = fs.promises.readFile, inventory = {}, budget) { + checkInspection(budget); const rawGit = runGit; runGit = async (...args) => { - try { return await rawGit(...args); } + try { + checkInspection(budget); + const result = await rawGit(...args); + checkInspection(budget); + return result; + } catch (error) { if (error.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER' || /maxBuffer/i.test(error.message)) { throw new Error('Git preview output is too large. Review or reduce the changed files with Git before trying Delete again.'); @@ -277,12 +307,11 @@ async function readStatus(worktreePath, parentRepo, runGit, readFile = fs.promis throw error; } }; - const list = await runGit(['-C', parentRepo, 'worktree', 'list', '--porcelain']); - const records = list.split(/\r?\n\r?\n/).map(record => record.split(/\r?\n/)); - const registered = records.filter(record => record[0]?.startsWith('worktree ')); - const requestedPath = await registeredPath(worktreePath); - const registeredPaths = await Promise.all(registered.map(record => registeredPath(unquote(record[0].slice(9))))); - const fields = registered[registeredPaths.indexOf(requestedPath)]; + const registered = inventory.records || parseWorktreeList(await runGit(['-C', parentRepo, 'worktree', 'list', '--porcelain'])); + const memo = inventory.resolutions ||= new Map(); + const requestedPath = await registeredPath(worktreePath, memo); + const registeredPaths = inventory.registeredPaths ||= await Promise.all(registered.map(record => registeredPath(record.path, memo))); + const fields = registered[registeredPaths.indexOf(requestedPath)]?.fields; if (!fields) throw new Error('This path is no longer a registered worktree. Refresh the project list before trying Delete again.'); if (requestedPath === registeredPaths[0]) throw new Error('The main worktree cannot be deleted. Select a linked worktree instead.'); const branch = fields.find(line => line.startsWith('branch '))?.slice(7).replace(/^refs\/heads\//, '') || '(detached HEAD)'; @@ -299,8 +328,9 @@ async function readStatus(worktreePath, parentRepo, runGit, readFile = fs.promis if (error.code !== 'ENOENT') throw error; } } - await refuseDirectoryLinks(worktreePath); - const snapshot = await statusSnapshot(worktreePath, runGit); + await refuseDirectoryLinks(worktreePath, budget); + const snapshot = await statusSnapshot(worktreePath, runGit, 0, { ...budget, used: 0, files: new Map() }); + checkInspection(budget); const { dirty, ignored, submodules } = snapshot; const fingerprint = createHash('sha256').update(JSON.stringify([ comparablePath(worktreePath), fields, locked, lockReason, snapshot, @@ -339,4 +369,4 @@ async function removeWorktree(worktreePath, parentRepo, shown, read, runGit) { } } -module.exports = { readStatus, removeWorktree, runningSessions, streamGit }; +module.exports = { readStatus, removeWorktree, runningSessions, streamGit, parseWorktreeList };