From 93b7d35bfaa7df7773f1ea82697ac007993f0eab Mon Sep 17 00:00:00 2001 From: Frank Song Date: Wed, 13 May 2026 09:04:00 +0800 Subject: [PATCH 1/4] Issue #2057 Slice 2: Add worktree remove action MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Backend: - POST /api/session/worktree/remove — removes a session's git worktree - Guards: stream/terminal lock, dirty/untracked without force - remove_worktree_for_session() in api/worktrees.py Frontend: - 'Remove Worktree' context menu item + confirm modal - i18n keys for all 11 locales Tests: - 5 tests: clean remove, missing worktree, no-path, route success, 404 --- ARCHITECTURE.md | 5 +- api/routes.py | 53 +++++++++++ api/worktrees.py | 87 ++++++++++++++++++ static/i18n.js | 143 +++++++++++++++++++++++++++++ static/sessions.js | 78 ++++++++++++++++ tests/test_worktree_remove.py | 165 ++++++++++++++++++++++++++++++++++ 6 files changed, 529 insertions(+), 2 deletions(-) create mode 100644 tests/test_worktree_remove.py diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md index bc8b3630..1d8f5a71 100644 --- a/ARCHITECTURE.md +++ b/ARCHITECTURE.md @@ -156,10 +156,11 @@ Python stdlib ThreadingHTTPServer (from http.server). Each HTTP request runs in thread. The Handler class subclasses BaseHTTPRequestHandler with two methods: do_GET Routes: /, /health, /api/session, /api/sessions, /api/list, - /api/chat/stream, /api/file, /api/approval/pending + /api/chat/stream, /api/file, /api/approval/pending, + /api/session/worktree/status do_POST Routes: /api/upload, /api/session/new, /api/session/update, /api/session/delete, /api/chat/start, /api/chat, - /api/approval/respond + /api/approval/respond, /api/session/worktree/remove Routing is a flat if/elif chain inside each method. No routing framework. diff --git a/api/routes.py b/api/routes.py index 65f12285..a78cead0 100644 --- a/api/routes.py +++ b/api/routes.py @@ -3066,6 +3066,7 @@ def handle_get(handler, parsed) -> bool: if parsed.path.startswith("/static/"): return _serve_static(handler, parsed) + if parsed.path == "/api/session/worktree/status": query = parse_qs(parsed.query) sid = query.get("session_id", [""])[0] @@ -4273,6 +4274,58 @@ def handle_post(handler, parsed) -> bool: set_last_workspace(new_ws) return j(handler, {"session": s.compact() | {"messages": s.messages}}) + + + if parsed.path == "/api/session/worktree/status": + query = parse_qs(parsed.query) + sid = query.get("session_id", [""])[0] + if not sid: + return bad(handler, "session_id is required", status=400) + try: + s = get_session(sid, metadata_only=True) + except KeyError: + return bad(handler, "Session not found", status=404) + try: + from api.worktrees import worktree_status_for_session + + return j(handler, {"status": worktree_status_for_session(s)}) + except ValueError as exc: + return bad(handler, str(exc), status=400) + except Exception as exc: + logger.exception("failed to read worktree status for session %s", sid) + return bad(handler, _sanitize_error(exc), status=500) + + if parsed.path == "/api/session/compress/status": + query = parse_qs(parsed.query) + return _handle_session_compress_status(handler, query.get("session_id", [""])[0]) + + if parsed.path == "/api/session": + import time as _time + _t0 = _time.monotonic() + _debug_slow = os.environ.get("HERMES_DEBUG_SLOW", "") + if parsed.path == "/api/session/worktree/remove": + sid = body.get("session_id", "") + if not sid or not isinstance(sid, str) or not sid.strip(): + return bad(handler, "session_id must be a non-empty string", status=400) + sid = sid.strip() + if not all(c in '0123456789abcdefghijklmnopqrstuvwxyz_' for c in sid): + return bad(handler, "Invalid session_id", 400) + try: + s = get_session(sid, metadata_only=True) + except KeyError: + return bad(handler, "Session not found", status=404) + force = bool(body.get("force", False)) + try: + from api.worktrees import remove_worktree_for_session + + result = remove_worktree_for_session(s, force=force) + return j(handler, result) + except ValueError as exc: + return bad(handler, str(exc), status=400) + except Exception as exc: + logger.exception("failed to remove worktree for session %s", sid) + return bad(handler, _sanitize_error(exc), status=500) + if parsed.path == "/api/session/delete": sid = body.get("session_id", "") if not sid: diff --git a/api/worktrees.py b/api/worktrees.py index e71fea6c..64929a1f 100644 --- a/api/worktrees.py +++ b/api/worktrees.py @@ -201,6 +201,93 @@ def worktree_status_for_session(session) -> dict: return status +def remove_worktree_for_session(session, *, force: bool = False) -> dict: + """Remove a session's git worktree from disk. + + Returns status dict with keys: ok, removed_path, warnings. + Raises ValueError for terminal blockers (locked by stream/terminal, + dirty with force=False). + """ + raw_path = getattr(session, "worktree_path", None) + if not raw_path: + raise ValueError("Session is not worktree-backed") + + worktree_path = _resolve_path(raw_path) + if worktree_path is None: + raise ValueError("Session is not worktree-backed") + + # Read current status before removal + status = worktree_status_for_session(session) + + if not status["exists"]: + return { + "ok": True, + "removed_path": str(worktree_path), + "warnings": ["Worktree directory no longer exists on disk."], + } + + warnings = [] + + # Guard: locked by stream + if status["locked_by_stream"]: + raise ValueError("Worktree is locked by an active streaming session") + + # Guard: locked by terminal + if status["locked_by_terminal"]: + raise ValueError("Worktree is locked by an active terminal session") + + # Guard: dirty / untracked files without force + if status["dirty"] and not force: + raise ValueError( + "Worktree has uncommitted changes. Use force=true to override." + ) + if status["untracked_count"] > 0: + if force: + warnings.append( + f"{status['untracked_count']} untracked file(s) will be removed." + ) + else: + raise ValueError( + f"Worktree has {status['untracked_count']} untracked file(s). " + "Use force=true to override." + ) + + # Remove the worktree — must run from the repo root, not the worktree dir + repo_root = getattr(session, "worktree_repo_root", None) + if not repo_root: + raise ValueError("Session missing worktree_repo_root") + try: + result = _run_git( + ["worktree", "remove", "--force", str(worktree_path)], + str(repo_root), + timeout=10, + ) + except (OSError, subprocess.TimeoutExpired) as exc: + raise ValueError(f"Failed to remove worktree: {exc}") from exc + + if result.returncode != 0: + stderr = (result.stderr or "").strip().split("\n")[-1] + raise ValueError( + f"git worktree remove failed: {stderr or result.stdout.strip()}" + ) + + # Prune in case the worktree dir was already gone + try: + _run_git( + ["worktree", "prune"], + str(repo_root), + timeout=5, + ) + except Exception: + pass + + return { + "ok": True, + "removed_path": str(worktree_path), + "warnings": warnings or None, + } + + def find_git_repo_root(workspace: str | Path) -> Path: """Return the enclosing git repo root for *workspace*. diff --git a/static/i18n.js b/static/i18n.js index 4cdd841c..235c5d5e 100644 --- a/static/i18n.js +++ b/static/i18n.js @@ -430,6 +430,19 @@ const LOCALES = { session_delete_worktree_confirm: (path) => `Delete this conversation? The worktree at ${path} will remain on disk.`, session_deleted: 'Conversation deleted', session_deleted_worktree: 'Conversation deleted. Worktree remains on disk.', + session_worktree_remove: 'Remove worktree', + session_worktree_remove_desc: (path) => `Delete the git worktree at ${path} from disk`, + session_worktree_remove_confirm: (path) => `Remove git worktree from disk?\n\nPath: ${path}\n\nThis will delete the entire worktree directory. Session data remains in WebUI.`, + session_worktree_remove_not_exists: (path) => `The worktree at ${path} no longer exists on disk.`, + session_worktree_remove_confirm_label: 'Remove', + session_worktree_removed: 'Worktree removed.', + session_worktree_remove_failed: 'Failed to remove worktree: ', + session_worktree_remove_status_failed: 'Failed to read worktree status: ', + session_worktree_remove_locked_by_stream: 'Cannot remove — an active streaming session is using this worktree.', + session_worktree_remove_locked_by_terminal: 'Cannot remove — an active terminal session is using this worktree.', + session_worktree_remove_dirty_warning: 'WARNING: This worktree has uncommitted changes which will be lost.', + session_worktree_remove_untracked_warning: (count) => `${count} untracked file(s) will be permanently deleted.`, + session_worktree_remove_ahead_warning: (ahead) => `${ahead} unpushed commit(s) will be lost.`, session_select_mode: 'Select', session_select_mode_desc: 'Select conversations to batch manage', session_select_all: 'Select all', @@ -1538,6 +1551,19 @@ const LOCALES = { session_delete_worktree_confirm: (path) => `Eliminare questa conversazione? Il worktree in ${path} rimarrà su disco.`, session_deleted: 'Conversazione eliminata', session_deleted_worktree: 'Conversazione eliminata. Il worktree rimane su disco.', + session_worktree_remove: 'Rimuovi worktree', + session_worktree_remove_desc: (path) => `Elimina il git worktree in ${path} dal disco`, + session_worktree_remove_confirm: (path) => `Rimuovere il git worktree dal disco?\n\nPercorso: ${path}\n\nVerrà eliminata l'intera directory del worktree. I dati della sessione restano in WebUI.`, + session_worktree_remove_not_exists: (path) => `Il worktree in ${path} non esiste più sul disco.`, + session_worktree_remove_confirm_label: 'Rimuovi', + session_worktree_removed: 'Worktree rimosso.', + session_worktree_remove_failed: 'Rimozione worktree fallita: ', + session_worktree_remove_status_failed: 'Lettura stato worktree fallita: ', + session_worktree_remove_locked_by_stream: 'Impossibile rimuovere — una sessione di streaming attiva sta usando questo worktree.', + session_worktree_remove_locked_by_terminal: 'Impossibile rimuovere — una sessione terminale attiva sta usando questo worktree.', + session_worktree_remove_dirty_warning: 'ATTENZIONE: Questo worktree ha modifiche non committate che andranno perse.', + session_worktree_remove_untracked_warning: (count) => `${count} file non tracciati verranno eliminati definitivamente.`, + session_worktree_remove_ahead_warning: (ahead) => `${ahead} commit non inviati andranno persi.`, session_select_mode: 'Seleziona', session_select_mode_desc: 'Seleziona conversazioni per gestione in blocco', session_select_all: 'Seleziona tutto', @@ -2641,6 +2667,19 @@ const LOCALES = { session_delete_worktree_confirm: (path) => `この会話を削除しますか? ${path} の worktree はディスク上に残ります。`, session_deleted: '会話を削除しました', session_deleted_worktree: '会話を削除しました。Worktree はディスク上に残ります。', + session_worktree_remove: 'ワークツリーを削除', + session_worktree_remove_desc: (path) => `${path} のgitワークツリーをディスクから削除します`, + session_worktree_remove_confirm: (path) => `gitワークツリーをディスクから削除しますか？\n\nパス: ${path}\n\nワークツリーディレクトリ全体が削除されます。セッションデータはWebUIに残ります。`, + session_worktree_remove_not_exists: (path) => `${path} のワークツリーはディスク上に存在しません。`, + session_worktree_remove_confirm_label: '削除', + session_worktree_removed: 'ワークツリーを削除しました。', + session_worktree_remove_failed: 'ワークツリーの削除に失敗: ', + session_worktree_remove_status_failed: 'ワークツリー状態の読み取りに失敗: ', + session_worktree_remove_locked_by_stream: '削除できません — アクティブなストリーミングセッションがこのワークツリーを使用中です。', + session_worktree_remove_locked_by_terminal: '削除できません — アクティブな端末セッションがこのワークツリーを使用中です。', + session_worktree_remove_dirty_warning: '警告: このワークツリーにはコミットされていない変更があり、失われます。', + session_worktree_remove_untracked_warning: (count) => `${count}件の追跡されていないファイルが完全に削除されます。`, + session_worktree_remove_ahead_warning: (ahead) => `${ahead}件の未プッシュコミットが失われます。`, session_select_mode: '選択', session_select_mode_desc: '会話を選択して一括管理', session_select_all: 'すべて選択', @@ -4187,6 +4226,19 @@ const LOCALES = { session_delete_worktree_confirm: (path) => `Delete this conversation? The worktree at ${path} will remain on disk.`, session_deleted: 'Conversation deleted', session_deleted_worktree: 'Conversation deleted. Worktree remains on disk.', + session_worktree_remove: 'Remove worktree', + session_worktree_remove_desc: (path) => `Delete the git worktree at ${path} from disk`, + session_worktree_remove_confirm: (path) => `Remove git worktree from disk?\n\nPath: ${path}\n\nThis will delete the entire worktree directory. Session data remains in WebUI.`, + session_worktree_remove_not_exists: (path) => `The worktree at ${path} no longer exists on disk.`, + session_worktree_remove_confirm_label: 'Remove', + session_worktree_removed: 'Worktree removed.', + session_worktree_remove_failed: 'Failed to remove worktree: ', + session_worktree_remove_status_failed: 'Failed to read worktree status: ', + session_worktree_remove_locked_by_stream: 'Cannot remove — an active streaming session is using this worktree.', + session_worktree_remove_locked_by_terminal: 'Cannot remove — an active terminal session is using this worktree.', + session_worktree_remove_dirty_warning: 'WARNING: This worktree has uncommitted changes which will be lost.', + session_worktree_remove_untracked_warning: (count) => `${count} untracked file(s) will be permanently deleted.`, + session_worktree_remove_ahead_warning: (ahead) => `${ahead} unpushed commit(s) will be lost.`, session_duplicate: 'Duplicate conversation', session_duplicate_desc: 'Create a copy with the same workspace and model', session_duplicate_failed: 'Duplicate failed: ', @@ -5217,6 +5269,19 @@ const LOCALES = { session_delete_worktree_confirm: (path) => `¿Eliminar esta conversación? El worktree en ${path} permanecerá en disco.`, session_deleted: 'Conversación eliminada', session_deleted_worktree: 'Conversación eliminada. El worktree permanece en disco.', + session_worktree_remove: 'Eliminar worktree', + session_worktree_remove_desc: (path) => `Eliminar el git worktree en ${path} del disco`, + session_worktree_remove_confirm: (path) => `¿Eliminar el git worktree del disco?\n\nRuta: ${path}\n\nSe eliminará todo el directorio del worktree. Los datos de la sesión permanecen en WebUI.`, + session_worktree_remove_not_exists: (path) => `El worktree en ${path} ya no existe en el disco.`, + session_worktree_remove_confirm_label: 'Eliminar', + session_worktree_removed: 'Worktree eliminado.', + session_worktree_remove_failed: 'Error al eliminar worktree: ', + session_worktree_remove_status_failed: 'Error al leer el estado del worktree: ', + session_worktree_remove_locked_by_stream: 'No se puede eliminar — una sesión de streaming activa está usando este worktree.', + session_worktree_remove_locked_by_terminal: 'No se puede eliminar — una sesión de terminal activa está usando este worktree.', + session_worktree_remove_dirty_warning: 'ADVERTENCIA: Este worktree tiene cambios no confirmados que se perderán.', + session_worktree_remove_untracked_warning: (count) => `${count} archivo(s) no rastreados se eliminarán permanentemente.`, + session_worktree_remove_ahead_warning: (ahead) => `${ahead} commit(s) no enviados se perderán.`, session_duplicate: 'Duplicate conversation', session_duplicate_desc: 'Create a copy with the same workspace and model', session_duplicate_failed: 'Duplicate failed: ', @@ -5987,6 +6052,19 @@ const LOCALES = { session_delete_worktree_confirm: (path) => `Diese Konversation löschen? Der Worktree unter ${path} bleibt auf der Festplatte.`, session_deleted: 'Konversation gelöscht', session_deleted_worktree: 'Konversation gelöscht. Der Worktree bleibt auf der Festplatte.', + session_worktree_remove: 'Worktree entfernen', + session_worktree_remove_desc: (path) => `Git-Worktree unter ${path} von der Festplatte löschen`, + session_worktree_remove_confirm: (path) => `Git-Worktree von der Festplatte entfernen?\n\nPfad: ${path}\n\nDas gesamte Worktree-Verzeichnis wird gelöscht. Sitzungsdaten bleiben in WebUI.`, + session_worktree_remove_not_exists: (path) => `Der Worktree unter ${path} existiert nicht mehr auf der Festplatte.`, + session_worktree_remove_confirm_label: 'Entfernen', + session_worktree_removed: 'Worktree entfernt.', + session_worktree_remove_failed: 'Fehler beim Entfernen des Worktree: ', + session_worktree_remove_status_failed: 'Fehler beim Lesen des Worktree-Status: ', + session_worktree_remove_locked_by_stream: 'Entfernen nicht möglich — eine aktive Streaming-Sitzung verwendet diesen Worktree.', + session_worktree_remove_locked_by_terminal: 'Entfernen nicht möglich — eine aktive Terminal-Sitzung verwendet diesen Worktree.', + session_worktree_remove_dirty_warning: 'WARNUNG: Dieser Worktree hat nicht festgeschriebene Änderungen, die verloren gehen.', + session_worktree_remove_untracked_warning: (count) => `${count} nicht verfolgte Datei(en) werden dauerhaft gelöscht.`, + session_worktree_remove_ahead_warning: (ahead) => `${ahead} nicht gepushte Commit(s) gehen verloren.`, session_duplicate: 'Duplicate conversation', session_duplicate_desc: 'Create a copy with the same workspace and model', session_duplicate_failed: 'Duplicate failed: ', @@ -7298,6 +7376,19 @@ const LOCALES = { session_delete_worktree_confirm: (path) => `删除此会话？位于 ${path} 的 worktree 将保留在磁盘上。`, session_deleted: '会话已删除', session_deleted_worktree: '会话已删除。Worktree 仍保留在磁盘上。', + session_worktree_remove: '删除 worktree', + session_worktree_remove_desc: (path) => `删除位于 ${path} 的 git worktree`, + session_worktree_remove_confirm: (path) => `确定从磁盘删除 git worktree？\n\n路径：${path}\n\n整个 worktree 目录将被删除，WebUI 中的会话数据保留。`, + session_worktree_remove_not_exists: (path) => `位于 ${path} 的 worktree 在磁盘上已不存在。`, + session_worktree_remove_confirm_label: '删除', + session_worktree_removed: 'Worktree 已删除。', + session_worktree_remove_failed: '删除 worktree 失败：', + session_worktree_remove_status_failed: '读取 worktree 状态失败：', + session_worktree_remove_locked_by_stream: '无法删除 — 存在活跃的流式会话正在使用此 worktree。', + session_worktree_remove_locked_by_terminal: '无法删除 — 存在活跃的终端会话正在使用此 worktree。', + session_worktree_remove_dirty_warning: '⚠️ 此 worktree 有未提交的更改，将被永久删除。', + session_worktree_remove_untracked_warning: (count) => `${count} 个未追踪文件将被永久删除。`, + session_worktree_remove_ahead_warning: (ahead) => `${ahead} 个未推送的提交将丢失。`, session_duplicate: '复制会话', session_duplicate_desc: '用相同工作区和模型创建副本', session_duplicate_failed: '复制失败：', @@ -7743,6 +7834,19 @@ const LOCALES = { session_delete_worktree_confirm: (path) => `刪除此對話？位於 ${path} 的 worktree 將保留在磁碟上。`, session_deleted: '對話已刪除', session_deleted_worktree: '對話已刪除。Worktree 仍保留在磁碟上。', + session_worktree_remove: '刪除 worktree', + session_worktree_remove_desc: (path) => `刪除位於 ${path} 的 git worktree`, + session_worktree_remove_confirm: (path) => `確定從磁碟刪除 git worktree？\n\n路徑：${path}\n\n整個 worktree 目錄將被刪除，WebUI 中的工作階段資料保留。`, + session_worktree_remove_not_exists: (path) => `位於 ${path} 的 worktree 在磁碟上已不存在。`, + session_worktree_remove_confirm_label: '刪除', + session_worktree_removed: 'Worktree 已刪除。', + session_worktree_remove_failed: '刪除 worktree 失敗：', + session_worktree_remove_status_failed: '讀取 worktree 狀態失敗：', + session_worktree_remove_locked_by_stream: '無法刪除 — 存在活躍的串流工作階段正在使用此 worktree。', + session_worktree_remove_locked_by_terminal: '無法刪除 — 存在活躍的終端機工作階段正在使用此 worktree。', + session_worktree_remove_dirty_warning: '⚠️ 此 worktree 有未提交的變更，將被永久刪除。', + session_worktree_remove_untracked_warning: (count) => `${count} 個未追蹤檔案將被永久刪除。`, + session_worktree_remove_ahead_warning: (ahead) => `${ahead} 個未推送的提交將丟失。`, session_select_mode: '選取', session_select_mode_desc: '選取會話以批次管理', session_select_all: '全選', @@ -8945,6 +9049,19 @@ const LOCALES = { session_delete_worktree_confirm: (path) => `Excluir esta conversa? O worktree em ${path} permanecerá no disco.`, session_deleted: 'Conversa excluída', session_deleted_worktree: 'Conversa excluída. O worktree permanece no disco.', + session_worktree_remove: 'Remover worktree', + session_worktree_remove_desc: (path) => `Excluir o git worktree em ${path} do disco`, + session_worktree_remove_confirm: (path) => `Remover git worktree do disco?\n\nCaminho: ${path}\n\nTodo o diretório do worktree será excluído. Dados da sessão permanecem no WebUI.`, + session_worktree_remove_not_exists: (path) => `O worktree em ${path} não existe mais no disco.`, + session_worktree_remove_confirm_label: 'Remover', + session_worktree_removed: 'Worktree removido.', + session_worktree_remove_failed: 'Falha ao remover worktree: ', + session_worktree_remove_status_failed: 'Falha ao ler o status do worktree: ', + session_worktree_remove_locked_by_stream: 'Não é possível remover — uma sessão de streaming ativa está usando este worktree.', + session_worktree_remove_locked_by_terminal: 'Não é possível remover — uma sessão de terminal ativa está usando este worktree.', + session_worktree_remove_dirty_warning: 'AVISO: Este worktree tem alterações não confirmadas que serão perdidas.', + session_worktree_remove_untracked_warning: (count) => `${count} arquivo(s) não rastreados serão excluídos permanentemente.`, + session_worktree_remove_ahead_warning: (ahead) => `${ahead} commit(s) não enviados serão perdidos.`, session_batch_delete_worktree_confirm: 'Excluir {0} conversas? {1} conversa(s) com worktree manterão seus diretórios de worktree no disco.', session_batch_archive_worktree_confirm: 'Arquivar {0} conversas? {1} conversa(s) com worktree manterão seus diretórios de worktree no disco.', session_batch_delete_confirm: 'Excluir {0} conversas?', @@ -9947,6 +10064,19 @@ const LOCALES = { session_delete_worktree_confirm: (path) => `이 대화를 삭제하시겠습니까? ${path}의 worktree는 디스크에 남아 있습니다.`, session_deleted: '대화가 삭제되었습니다', session_deleted_worktree: '대화가 삭제되었습니다. Worktree는 디스크에 남아 있습니다.', + session_worktree_remove: '워크트리 삭제', + session_worktree_remove_desc: (path) => `${path}의 git worktree를 디스크에서 삭제합니다`, + session_worktree_remove_confirm: (path) => `git worktree를 디스크에서 삭제하시겠습니까?\n\n경로: ${path}\n\n전체 worktree 디렉토리가 삭제됩니다. 세션 데이터는 WebUI에 보존됩니다.`, + session_worktree_remove_not_exists: (path) => `${path}의 worktree가 디스크에 더 이상 존재하지 않습니다.`, + session_worktree_remove_confirm_label: '삭제', + session_worktree_removed: '워크트리가 삭제되었습니다.', + session_worktree_remove_failed: '워크트리 삭제 실패: ', + session_worktree_remove_status_failed: '워크트리 상태 읽기 실패: ', + session_worktree_remove_locked_by_stream: '삭제할 수 없습니다 — 활성 스트리밍 세션이 이 worktree를 사용 중입니다.', + session_worktree_remove_locked_by_terminal: '삭제할 수 없습니다 — 활성 터미널 세션이 이 worktree를 사용 중입니다.', + session_worktree_remove_dirty_warning: '경고: 이 worktree에는 커밋되지 않은 변경 사항이 있으며 손실됩니다.', + session_worktree_remove_untracked_warning: (count) => `${count}개의 추적되지 않은 파일이 영구적으로 삭제됩니다.`, + session_worktree_remove_ahead_warning: (ahead) => `${ahead}개의 푸시되지 않은 커밋이 손실됩니다.`, session_select_mode: '선택', session_select_mode_desc: '일괄 관리할 대화를 선택하세요', session_select_all: '전체 선택', @@ -10973,6 +11103,19 @@ const LOCALES = { session_delete_worktree_desc: 'Supprimez uniquement la conversation WebUI ; garder l\'arbre de travail sur le disque', session_deleted: 'Conversation supprimée', session_deleted_worktree: 'Conversation supprimée. Worktree reste sur le disque.', + session_worktree_remove: 'Supprimer le worktree', + session_worktree_remove_desc: (path) => `Supprimer le git worktree à ${path} du disque`, + session_worktree_remove_confirm: (path) => `Supprimer le git worktree du disque ?\n\nChemin : ${path}\n\nTout le répertoire worktree sera supprimé. Les données de session restent dans WebUI.`, + session_worktree_remove_not_exists: (path) => `Le worktree à ${path} n'existe plus sur le disque.`, + session_worktree_remove_confirm_label: 'Supprimer', + session_worktree_removed: 'Worktree supprimé.', + session_worktree_remove_failed: 'Échec de la suppression du worktree : ', + session_worktree_remove_status_failed: 'Échec de la lecture du statut du worktree : ', + session_worktree_remove_locked_by_stream: 'Impossible de supprimer — une session de streaming active utilise ce worktree.', + session_worktree_remove_locked_by_terminal: 'Impossible de supprimer — une session de terminal active utilise ce worktree.', + session_worktree_remove_dirty_warning: 'ATTENTION : Ce worktree a des modifications non validées qui seront perdues.', + session_worktree_remove_untracked_warning: (count) => `${count} fichier(s) non suivi(s) seront définitivement supprimés.`, + session_worktree_remove_ahead_warning: (ahead) => `${ahead} commit(s) non poussé(s) seront perdus.`, session_select_mode: 'Sélectionner', session_select_mode_desc: 'Sélectionnez les conversations à gérer par lots', session_select_all: 'Tout sélectionner', diff --git a/static/sessions.js b/static/sessions.js index 17ee262c..58d49eb9 100644 --- a/static/sessions.js +++ b/static/sessions.js @@ -1666,6 +1666,18 @@ function _openSessionActionMenu(session, anchorEl){ )); } if(!isExternalSession){ + if(session.worktree_path){ + menu.appendChild(_buildSessionAction( + t('session_worktree_remove'), + t('session_worktree_remove_desc', session.worktree_path), + ICONS.trash, + async()=>{ + closeSessionActionMenu(); + await removeWorktree(session); + }, + 'danger' + )); + } menu.appendChild(_buildSessionAction( t('session_delete'), _sessionDeleteDescription(session), @@ -3152,6 +3164,72 @@ if(typeof window!=='undefined'){ }); } +async function removeWorktree(session){ + // Fetch status first + let status=null; + try{ + const statusResp=await api('/api/session/worktree/status?session_id='+encodeURIComponent(session.session_id)); + status=statusResp.status; + }catch(e){ + showToast(t('session_worktree_remove_status_failed')+e.message,0,'error'); + return; + } + if(!status){ + showToast(t('session_worktree_remove_status_failed'),0,'error'); + return; + } + // Build confirm message + let details=''; + if(!status.exists){ + details=t('session_worktree_remove_not_exists',status.path); + }else{ + details=t('session_worktree_remove_confirm',status.path); + if(status.locked_by_stream){ + showToast(t('session_worktree_remove_locked_by_stream'),0,'error'); + return; + } + if(status.locked_by_terminal){ + showToast(t('session_worktree_remove_locked_by_terminal'),0,'error'); + return; + } + if(status.dirty){ + details+='\n\n'+t('session_worktree_remove_dirty_warning'); + } + if(status.untracked_count>0){ + details+='\n'+t('session_worktree_remove_untracked_warning',status.untracked_count); + } + if(status.ahead_behind&&status.ahead_behind.ahead>0){ + details+='\n'+t('session_worktree_remove_ahead_warning',status.ahead_behind.ahead); + } + } + const ok=await showConfirmDialog({ + message:details, + confirmLabel:t('session_worktree_remove_confirm_label'), + danger:true + }); + if(!ok)return; + const force=(status.dirty||status.untracked_count>0); + try{ + const result=await api('/api/session/worktree/remove',{ + method:'POST', + body:JSON.stringify({session_id:session.session_id, force:force}) + }); + const warn=result.warnings&&result.warnings.length?(' '+result.warnings.join(' ')):''; + showToast(t('session_worktree_removed')+warn); + // Clear the worktree_path from cached session so menu doesn't show stale remove action + if(session.worktree_path){ + session.worktree_path=null; + } + // Re-render the list if this is the active session + if(S.session&&S.session.session_id===session.session_id&&S.session.worktree_path){ + S.session.worktree_path=null; + } + await renderSessionList(); + }catch(e){ + showToast(t('session_worktree_remove_failed')+e.message,0,'error'); + } +} + async function deleteSession(sid){ const session=_sessionSnapshotById(sid); const ok=await showConfirmDialog({ diff --git a/tests/test_worktree_remove.py b/tests/test_worktree_remove.py new file mode 100644 index 00000000..ad88b9c3 --- /dev/null +++ b/tests/test_worktree_remove.py @@ -0,0 +1,165 @@ +"""Tests for the worktree remove functionality (Issue #2057 Slice 2).""" + +from types import SimpleNamespace +from pathlib import Path + +import api.models as models +import api.routes as routes +import api.worktrees as worktrees + + +def _capture_post(monkeypatch, body): + captured = {} + monkeypatch.setattr(routes, "_check_csrf", lambda handler: True) + monkeypatch.setattr(routes, "read_body", lambda handler: body) + # Monkeypatch both helpers.j and routes.j — bad() lives in helpers but calls the module-global j + import api.helpers as helpers + def _fake_j(handler, payload, status=200, extra_headers=None): + captured.update(payload=payload, status=status) + return True + monkeypatch.setattr(routes, "j", _fake_j) + monkeypatch.setattr(helpers, "j", _fake_j) + return captured + + +def _isolate_session_store(tmp_path, monkeypatch): + session_dir = tmp_path / "sessions" + session_dir.mkdir() + monkeypatch.setattr(models, "SESSION_DIR", session_dir) + monkeypatch.setattr(models, "SESSION_INDEX_FILE", session_dir / "_index.json") + monkeypatch.setattr(routes, "SESSION_DIR", session_dir) + monkeypatch.setattr(routes, "SESSION_INDEX_FILE", session_dir / "_index.json") + models.SESSIONS.clear() + return session_dir + + +def _make_minimal_git_repo(tmp_path): + import subprocess + main = tmp_path / "main" + main.mkdir() + subprocess.run(["git", "init", "-b", "main", str(main)], check=True, capture_output=True) + subprocess.run(["git", "-C", str(main), "config", "user.email", "test@test.test"], check=True, capture_output=True) + subprocess.run(["git", "-C", str(main), "config", "user.name", "Test"], check=True, capture_output=True) + (main / "file.txt").write_text("content") + subprocess.run(["git", "-C", str(main), "add", "file.txt"], check=True, capture_output=True) + subprocess.run(["git", "-C", str(main), "commit", "-m", "init"], check=True, capture_output=True) + return main + + +# ── Function-level tests ───────────────────────────────────────────────────── + + +def test_remove_clean_worktree_succeeds(tmp_path): + import subprocess + from api.models import Session + + main = _make_minimal_git_repo(tmp_path) + wt_path = tmp_path / "wt_clean" + subprocess.run( + ["git", "-C", str(main), "worktree", "add", str(wt_path), "-b", "hermes/testclean"], + check=True, capture_output=True, + ) + assert wt_path.exists() + + s = Session( + session_id="testclean", + title="Clean", + workspace=str(wt_path), + worktree_path=str(wt_path), + worktree_branch="hermes/testclean", + worktree_repo_root=str(main), + ) + + result = worktrees.remove_worktree_for_session(s, force=False) + assert result["ok"] is True + assert result["removed_path"] == str(wt_path.resolve()) + assert not wt_path.exists() + + +def test_remove_worktree_not_exists(tmp_path): + from api.models import Session + + s = Session( + session_id="testgone", + title="Gone", + workspace=str(tmp_path / "gone"), + worktree_path=str(tmp_path / "gone"), + worktree_branch="hermes/gone", + worktree_repo_root=str(tmp_path / "repo"), + ) + + result = worktrees.remove_worktree_for_session(s, force=False) + assert result["ok"] is True + assert len(result.get("warnings", [])) >= 1 + + +def test_remove_worktree_no_path_raises(tmp_path): + from api.models import Session + + s = Session( + session_id="testnowt", + title="No worktree", + workspace=str(tmp_path), + ) + + try: + worktrees.remove_worktree_for_session(s, force=False) + assert False, "should have raised ValueError" + except ValueError as e: + assert "not worktree-backed" in str(e) + + +# ── Route-level tests ──────────────────────────────────────────────────────── + + +def test_remove_worktree_route_succeeds(tmp_path, monkeypatch): + import subprocess + from api.models import Session + + main = _make_minimal_git_repo(tmp_path) + wt_path = tmp_path / "wt_route" + subprocess.run( + ["git", "-C", str(main), "worktree", "add", str(wt_path), "-b", "hermes/testroute"], + check=True, capture_output=True, + ) + + _isolate_session_store(tmp_path, monkeypatch) + + s = Session( + session_id="testroute1", + title="Route", + workspace=str(wt_path), + worktree_path=str(wt_path), + worktree_branch="hermes/testroute", + worktree_repo_root=str(main), + ) + s.save() + + body = {"session_id": "testroute1"} + captured = _capture_post(monkeypatch, body) + + assert routes.handle_post(object(), SimpleNamespace(path="/api/session/worktree/remove")) is True + assert captured["status"] == 200 + assert captured["payload"]["ok"] is True + assert captured["payload"]["removed_path"] == str(wt_path.resolve()) + assert not wt_path.exists() + + +def test_remove_missing_session_returns_404(tmp_path, monkeypatch): + from api.models import Session + + _isolate_session_store(tmp_path, monkeypatch) + + s = Session( + session_id="someother", + title="Other", + workspace=str(tmp_path), + ) + s.save() + + body = {"session_id": "nonexistent"} + captured = _capture_post(monkeypatch, body) + + routes.handle_post(object(), SimpleNamespace(path="/api/session/worktree/remove")) + assert captured["status"] == 404 + assert "not found" in captured["payload"].get("error", "").lower() From 46c62851ad0db3307837e57cde6127dd3d82281a Mon Sep 17 00:00:00 2001 From: Frank Song Date: Wed, 13 May 2026 09:49:15 +0800 Subject: [PATCH 2/4] Harden worktree removal safeguards --- api/routes.py | 30 ---- api/worktrees.py | 21 ++- static/i18n.js | 1 + static/sessions.js | 13 +- tests/test_issue2057_worktree_ui_static.py | 12 ++ tests/test_worktree_remove.py | 170 +++++++++++++++++++++ 6 files changed, 209 insertions(+), 38 deletions(-) diff --git a/api/routes.py b/api/routes.py index a78cead0..47bca9ba 100644 --- a/api/routes.py +++ b/api/routes.py @@ -4273,36 +4273,6 @@ def handle_post(handler, parsed) -> bool: logger.debug("Failed to close workspace terminal after workspace update") set_last_workspace(new_ws) return j(handler, {"session": s.compact() | {"messages": s.messages}}) - - - - if parsed.path == "/api/session/worktree/status": - query = parse_qs(parsed.query) - sid = query.get("session_id", [""])[0] - if not sid: - return bad(handler, "session_id is required", status=400) - try: - s = get_session(sid, metadata_only=True) - except KeyError: - return bad(handler, "Session not found", status=404) - try: - from api.worktrees import worktree_status_for_session - - return j(handler, {"status": worktree_status_for_session(s)}) - except ValueError as exc: - return bad(handler, str(exc), status=400) - except Exception as exc: - logger.exception("failed to read worktree status for session %s", sid) - return bad(handler, _sanitize_error(exc), status=500) - - if parsed.path == "/api/session/compress/status": - query = parse_qs(parsed.query) - return _handle_session_compress_status(handler, query.get("session_id", [""])[0]) - - if parsed.path == "/api/session": - import time as _time - _t0 = _time.monotonic() - _debug_slow = os.environ.get("HERMES_DEBUG_SLOW", "") if parsed.path == "/api/session/worktree/remove": sid = body.get("session_id", "") if not sid or not isinstance(sid, str) or not sid.strip(): diff --git a/api/worktrees.py b/api/worktrees.py index 64929a1f..42424ee5 100644 --- a/api/worktrees.py +++ b/api/worktrees.py @@ -236,7 +236,7 @@ def remove_worktree_for_session(session, *, force: bool = False) -> dict: if status["locked_by_terminal"]: raise ValueError("Worktree is locked by an active terminal session") - # Guard: dirty / untracked files without force + # Guard: local changes and unpushed commits without explicit force. if status["dirty"] and not force: raise ValueError( "Worktree has uncommitted changes. Use force=true to override." @@ -251,17 +251,26 @@ def remove_worktree_for_session(session, *, force: bool = False) -> dict: f"Worktree has {status['untracked_count']} untracked file(s). " "Use force=true to override." ) + ahead = int((status.get("ahead_behind") or {}).get("ahead") or 0) + if ahead > 0: + if force: + warnings.append(f"{ahead} unpushed commit(s) will be removed.") + else: + raise ValueError( + f"Worktree has {ahead} unpushed commit(s). " + "Use force=true to override." + ) # Remove the worktree — must run from the repo root, not the worktree dir repo_root = getattr(session, "worktree_repo_root", None) if not repo_root: raise ValueError("Session missing worktree_repo_root") try: - result = _run_git( - ["worktree", "remove", "--force", str(worktree_path)], - str(repo_root), - timeout=10, - ) + remove_args = ["worktree", "remove"] + if force: + remove_args.append("--force") + remove_args.append(str(worktree_path)) + result = _run_git(remove_args, str(repo_root), timeout=10) except (OSError, subprocess.TimeoutExpired) as exc: raise ValueError(f"Failed to remove worktree: {exc}") from exc diff --git a/static/i18n.js b/static/i18n.js index 235c5d5e..e14b516f 100644 --- a/static/i18n.js +++ b/static/i18n.js @@ -440,6 +440,7 @@ const LOCALES = { session_worktree_remove_status_failed: 'Failed to read worktree status: ', session_worktree_remove_locked_by_stream: 'Cannot remove — an active streaming session is using this worktree.', session_worktree_remove_locked_by_terminal: 'Cannot remove — an active terminal session is using this worktree.', + session_worktree_remove_unsafe_blocked: 'Resolve local changes or unpushed commits before removing this worktree.', session_worktree_remove_dirty_warning: 'WARNING: This worktree has uncommitted changes which will be lost.', session_worktree_remove_untracked_warning: (count) => `${count} untracked file(s) will be permanently deleted.`, session_worktree_remove_ahead_warning: (ahead) => `${ahead} unpushed commit(s) will be lost.`, diff --git a/static/sessions.js b/static/sessions.js index 58d49eb9..60754a19 100644 --- a/static/sessions.js +++ b/static/sessions.js @@ -3201,6 +3201,16 @@ async function removeWorktree(session){ if(status.ahead_behind&&status.ahead_behind.ahead>0){ details+='\n'+t('session_worktree_remove_ahead_warning',status.ahead_behind.ahead); } + if(status.dirty||status.untracked_count>0||(status.ahead_behind&&status.ahead_behind.ahead>0)){ + showToast(t('session_worktree_remove_failed')+t('session_worktree_remove_unsafe_blocked'),0,'error'); + await showConfirmDialog({ + message:details, + confirmLabel:t('dialog_confirm_btn'), + danger:true, + focusCancel:true + }); + return; + } } const ok=await showConfirmDialog({ message:details, @@ -3208,11 +3218,10 @@ async function removeWorktree(session){ danger:true }); if(!ok)return; - const force=(status.dirty||status.untracked_count>0); try{ const result=await api('/api/session/worktree/remove',{ method:'POST', - body:JSON.stringify({session_id:session.session_id, force:force}) + body:JSON.stringify({session_id:session.session_id, force:false}) }); const warn=result.warnings&&result.warnings.length?(' '+result.warnings.join(' ')):''; showToast(t('session_worktree_removed')+warn); diff --git a/tests/test_issue2057_worktree_ui_static.py b/tests/test_issue2057_worktree_ui_static.py index b9233280..3b99921c 100644 --- a/tests/test_issue2057_worktree_ui_static.py +++ b/tests/test_issue2057_worktree_ui_static.py @@ -68,3 +68,15 @@ def test_worktree_archive_delete_api_responses_are_explicit(): assert '"worktree_retained": True' in src assert '{"ok": True, **worktree_retained}' in src assert '{"ok": True, "session": s.compact(), **_worktree_retained_payload(s)}' in src + + +def test_remove_worktree_ui_does_not_force_unsafe_status_by_default(): + src = read("static/sessions.js") + i18n = read("static/i18n.js") + assert "async function removeWorktree(session)" in src + assert "status.dirty||status.untracked_count>0||(status.ahead_behind&&status.ahead_behind.ahead>0)" in src + assert "session_worktree_remove_unsafe_blocked" in src + assert "session_worktree_remove_unsafe_blocked" in i18n + assert "Resolve local changes or unpushed commits before removing this worktree." in i18n + assert "JSON.stringify({session_id:session.session_id, force:false})" in src + assert "const force=(status.dirty||status.untracked_count>0)" not in src diff --git a/tests/test_worktree_remove.py b/tests/test_worktree_remove.py index ad88b9c3..0c658235 100644 --- a/tests/test_worktree_remove.py +++ b/tests/test_worktree_remove.py @@ -3,6 +3,8 @@ from types import SimpleNamespace from pathlib import Path +import pytest + import api.models as models import api.routes as routes import api.worktrees as worktrees @@ -76,6 +78,167 @@ def test_remove_clean_worktree_succeeds(tmp_path): assert not wt_path.exists() +def test_remove_clean_worktree_does_not_force(tmp_path, monkeypatch): + from api.models import Session + + worktree_path = tmp_path / "wt_clean" + worktree_path.mkdir() + repo_root = tmp_path / "repo" + repo_root.mkdir() + s = Session( + session_id="testcleanforce", + title="Clean", + workspace=str(worktree_path), + worktree_path=str(worktree_path), + worktree_branch="hermes/testcleanforce", + worktree_repo_root=str(repo_root), + ) + monkeypatch.setattr(worktrees, "worktree_status_for_session", lambda session: { + "exists": True, + "dirty": False, + "untracked_count": 0, + "ahead_behind": {"ahead": 0, "behind": 0, "available": False, "upstream": None}, + "locked_by_stream": False, + "locked_by_terminal": False, + }) + calls = [] + + def fake_run_git(args, cwd, timeout=2): + calls.append(args) + return SimpleNamespace(returncode=0, stdout="", stderr="") + + monkeypatch.setattr(worktrees, "_run_git", fake_run_git) + + result = worktrees.remove_worktree_for_session(s, force=False) + assert result["ok"] is True + assert calls[0] == ["worktree", "remove", str(worktree_path.resolve())] + + +def test_remove_dirty_worktree_without_force_is_rejected(tmp_path, monkeypatch): + from api.models import Session + + worktree_path = tmp_path / "wt_dirty" + worktree_path.mkdir() + repo_root = tmp_path / "repo" + repo_root.mkdir() + s = Session( + session_id="testdirty", + title="Dirty", + workspace=str(worktree_path), + worktree_path=str(worktree_path), + worktree_branch="hermes/testdirty", + worktree_repo_root=str(repo_root), + ) + monkeypatch.setattr(worktrees, "worktree_status_for_session", lambda session: { + "exists": True, + "dirty": True, + "untracked_count": 0, + "ahead_behind": {"ahead": 0, "behind": 0, "available": False, "upstream": None}, + "locked_by_stream": False, + "locked_by_terminal": False, + }) + monkeypatch.setattr(worktrees, "_run_git", lambda *args, **kwargs: pytest.fail("git remove should not run")) + + with pytest.raises(ValueError, match="uncommitted changes"): + worktrees.remove_worktree_for_session(s, force=False) + + +def test_remove_untracked_worktree_without_force_is_rejected(tmp_path, monkeypatch): + from api.models import Session + + worktree_path = tmp_path / "wt_untracked" + worktree_path.mkdir() + repo_root = tmp_path / "repo" + repo_root.mkdir() + s = Session( + session_id="testuntracked", + title="Untracked", + workspace=str(worktree_path), + worktree_path=str(worktree_path), + worktree_branch="hermes/testuntracked", + worktree_repo_root=str(repo_root), + ) + monkeypatch.setattr(worktrees, "worktree_status_for_session", lambda session: { + "exists": True, + "dirty": False, + "untracked_count": 2, + "ahead_behind": {"ahead": 0, "behind": 0, "available": False, "upstream": None}, + "locked_by_stream": False, + "locked_by_terminal": False, + }) + monkeypatch.setattr(worktrees, "_run_git", lambda *args, **kwargs: pytest.fail("git remove should not run")) + + with pytest.raises(ValueError, match="untracked"): + worktrees.remove_worktree_for_session(s, force=False) + + +def test_remove_ahead_worktree_without_force_is_rejected(tmp_path, monkeypatch): + from api.models import Session + + worktree_path = tmp_path / "wt_ahead" + worktree_path.mkdir() + repo_root = tmp_path / "repo" + repo_root.mkdir() + s = Session( + session_id="testahead", + title="Ahead", + workspace=str(worktree_path), + worktree_path=str(worktree_path), + worktree_branch="hermes/testahead", + worktree_repo_root=str(repo_root), + ) + monkeypatch.setattr(worktrees, "worktree_status_for_session", lambda session: { + "exists": True, + "dirty": False, + "untracked_count": 0, + "ahead_behind": {"ahead": 1, "behind": 0, "available": True, "upstream": "origin/main"}, + "locked_by_stream": False, + "locked_by_terminal": False, + }) + monkeypatch.setattr(worktrees, "_run_git", lambda *args, **kwargs: pytest.fail("git remove should not run")) + + with pytest.raises(ValueError, match="unpushed"): + worktrees.remove_worktree_for_session(s, force=False) + + +def test_remove_force_warns_and_uses_git_force(tmp_path, monkeypatch): + from api.models import Session + + worktree_path = tmp_path / "wt_force" + worktree_path.mkdir() + repo_root = tmp_path / "repo" + repo_root.mkdir() + s = Session( + session_id="testforce", + title="Force", + workspace=str(worktree_path), + worktree_path=str(worktree_path), + worktree_branch="hermes/testforce", + worktree_repo_root=str(repo_root), + ) + monkeypatch.setattr(worktrees, "worktree_status_for_session", lambda session: { + "exists": True, + "dirty": True, + "untracked_count": 3, + "ahead_behind": {"ahead": 2, "behind": 0, "available": True, "upstream": "origin/main"}, + "locked_by_stream": False, + "locked_by_terminal": False, + }) + calls = [] + + def fake_run_git(args, cwd, timeout=2): + calls.append(args) + return SimpleNamespace(returncode=0, stdout="", stderr="") + + monkeypatch.setattr(worktrees, "_run_git", fake_run_git) + + result = worktrees.remove_worktree_for_session(s, force=True) + assert result["ok"] is True + assert calls[0] == ["worktree", "remove", "--force", str(worktree_path.resolve())] + assert "untracked file" in " ".join(result["warnings"]) + assert "unpushed commit" in " ".join(result["warnings"]) + + def test_remove_worktree_not_exists(tmp_path): from api.models import Session @@ -163,3 +326,10 @@ def test_remove_missing_session_returns_404(tmp_path, monkeypatch): routes.handle_post(object(), SimpleNamespace(path="/api/session/worktree/remove")) assert captured["status"] == 404 assert "not found" in captured["payload"].get("error", "").lower() + + +def test_post_router_does_not_expose_read_only_worktree_or_compress_status(): + src = Path("api/routes.py").read_text(encoding="utf-8") + post_body = src[src.index("def handle_post"):src.index('if parsed.path == "/api/session/worktree/remove"')] + assert '"/api/session/worktree/status"' not in post_body + assert '"/api/session/compress/status"' not in post_body From e177f64e78ded7995f6f13270068d0bcb83893ec Mon Sep 17 00:00:00 2001 From: Frank Song Date: Wed, 13 May 2026 09:53:56 +0800 Subject: [PATCH 3/4] Add worktree remove PR screenshots --- docs/pr-media/2156/worktree-remove-confirm.png | Bin 0 -> 83246 bytes docs/pr-media/2156/worktree-remove-menu.png | Bin 0 -> 74036 bytes 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 docs/pr-media/2156/worktree-remove-confirm.png create mode 100644 docs/pr-media/2156/worktree-remove-menu.png diff --git a/docs/pr-media/2156/worktree-remove-confirm.png b/docs/pr-media/2156/worktree-remove-confirm.png new file mode 100644 index 0000000000000000000000000000000000000000..ebbd57ad4e70eba744bd03c35764fc75eb7d3692 GIT binary patch literal 83246 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 NBc&)=B>vjxzX3rW6~O=i literal 0 HcmV?d00001 From f4efe0790b3606d03a0430f540711ef5daec1160 Mon Sep 17 00:00:00 2001 From: Frank Song Date: Wed, 13 May 2026 09:57:24 +0800 Subject: [PATCH 4/4] Complete worktree remove i18n coverage --- static/i18n.js | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/static/i18n.js b/static/i18n.js index e14b516f..2b363983 100644 --- a/static/i18n.js +++ b/static/i18n.js @@ -1562,6 +1562,7 @@ const LOCALES = { session_worktree_remove_status_failed: 'Lettura stato worktree fallita: ', session_worktree_remove_locked_by_stream: 'Impossibile rimuovere — una sessione di streaming attiva sta usando questo worktree.', session_worktree_remove_locked_by_terminal: 'Impossibile rimuovere — una sessione terminale attiva sta usando questo worktree.', + session_worktree_remove_unsafe_blocked: 'Risolvi le modifiche locali o i commit non inviati prima di rimuovere questo worktree.', session_worktree_remove_dirty_warning: 'ATTENZIONE: Questo worktree ha modifiche non committate che andranno perse.', session_worktree_remove_untracked_warning: (count) => `${count} file non tracciati verranno eliminati definitivamente.`, session_worktree_remove_ahead_warning: (ahead) => `${ahead} commit non inviati andranno persi.`, @@ -2678,6 +2679,7 @@ const LOCALES = { session_worktree_remove_status_failed: 'ワークツリー状態の読み取りに失敗: ', session_worktree_remove_locked_by_stream: '削除できません — アクティブなストリーミングセッションがこのワークツリーを使用中です。', session_worktree_remove_locked_by_terminal: '削除できません — アクティブな端末セッションがこのワークツリーを使用中です。', + session_worktree_remove_unsafe_blocked: 'このワークツリーを削除する前に、ローカル変更または未プッシュのコミットを解消してください。', session_worktree_remove_dirty_warning: '警告: このワークツリーにはコミットされていない変更があり、失われます。', session_worktree_remove_untracked_warning: (count) => `${count}件の追跡されていないファイルが完全に削除されます。`, session_worktree_remove_ahead_warning: (ahead) => `${ahead}件の未プッシュコミットが失われます。`, @@ -4237,6 +4239,7 @@ const LOCALES = { session_worktree_remove_status_failed: 'Failed to read worktree status: ', session_worktree_remove_locked_by_stream: 'Cannot remove — an active streaming session is using this worktree.', session_worktree_remove_locked_by_terminal: 'Cannot remove — an active terminal session is using this worktree.', + session_worktree_remove_unsafe_blocked: 'Resolve local changes or unpushed commits before removing this worktree.', session_worktree_remove_dirty_warning: 'WARNING: This worktree has uncommitted changes which will be lost.', session_worktree_remove_untracked_warning: (count) => `${count} untracked file(s) will be permanently deleted.`, session_worktree_remove_ahead_warning: (ahead) => `${ahead} unpushed commit(s) will be lost.`, @@ -5280,6 +5283,7 @@ const LOCALES = { session_worktree_remove_status_failed: 'Error al leer el estado del worktree: ', session_worktree_remove_locked_by_stream: 'No se puede eliminar — una sesión de streaming activa está usando este worktree.', session_worktree_remove_locked_by_terminal: 'No se puede eliminar — una sesión de terminal activa está usando este worktree.', + session_worktree_remove_unsafe_blocked: 'Resuelve los cambios locales o los commits no enviados antes de eliminar este worktree.', session_worktree_remove_dirty_warning: 'ADVERTENCIA: Este worktree tiene cambios no confirmados que se perderán.', session_worktree_remove_untracked_warning: (count) => `${count} archivo(s) no rastreados se eliminarán permanentemente.`, session_worktree_remove_ahead_warning: (ahead) => `${ahead} commit(s) no enviados se perderán.`, @@ -6063,6 +6067,7 @@ const LOCALES = { session_worktree_remove_status_failed: 'Fehler beim Lesen des Worktree-Status: ', session_worktree_remove_locked_by_stream: 'Entfernen nicht möglich — eine aktive Streaming-Sitzung verwendet diesen Worktree.', session_worktree_remove_locked_by_terminal: 'Entfernen nicht möglich — eine aktive Terminal-Sitzung verwendet diesen Worktree.', + session_worktree_remove_unsafe_blocked: 'Löse lokale Änderungen oder nicht gepushte Commits, bevor du diesen Worktree entfernst.', session_worktree_remove_dirty_warning: 'WARNUNG: Dieser Worktree hat nicht festgeschriebene Änderungen, die verloren gehen.', session_worktree_remove_untracked_warning: (count) => `${count} nicht verfolgte Datei(en) werden dauerhaft gelöscht.`, session_worktree_remove_ahead_warning: (ahead) => `${ahead} nicht gepushte Commit(s) gehen verloren.`, @@ -7387,6 +7392,7 @@ const LOCALES = { session_worktree_remove_status_failed: '读取 worktree 状态失败：', session_worktree_remove_locked_by_stream: '无法删除 — 存在活跃的流式会话正在使用此 worktree。', session_worktree_remove_locked_by_terminal: '无法删除 — 存在活跃的终端会话正在使用此 worktree。', + session_worktree_remove_unsafe_blocked: '请先处理本地更改或未推送提交，再删除此 worktree。', session_worktree_remove_dirty_warning: '⚠️ 此 worktree 有未提交的更改，将被永久删除。', session_worktree_remove_untracked_warning: (count) => `${count} 个未追踪文件将被永久删除。`, session_worktree_remove_ahead_warning: (ahead) => `${ahead} 个未推送的提交将丢失。`, @@ -7845,6 +7851,7 @@ const LOCALES = { session_worktree_remove_status_failed: '讀取 worktree 狀態失敗：', session_worktree_remove_locked_by_stream: '無法刪除 — 存在活躍的串流工作階段正在使用此 worktree。', session_worktree_remove_locked_by_terminal: '無法刪除 — 存在活躍的終端機工作階段正在使用此 worktree。', + session_worktree_remove_unsafe_blocked: '請先處理本機變更或未推送提交，再刪除此 worktree。', session_worktree_remove_dirty_warning: '⚠️ 此 worktree 有未提交的變更，將被永久刪除。', session_worktree_remove_untracked_warning: (count) => `${count} 個未追蹤檔案將被永久刪除。`, session_worktree_remove_ahead_warning: (ahead) => `${ahead} 個未推送的提交將丟失。`, @@ -9060,6 +9067,7 @@ const LOCALES = { session_worktree_remove_status_failed: 'Falha ao ler o status do worktree: ', session_worktree_remove_locked_by_stream: 'Não é possível remover — uma sessão de streaming ativa está usando este worktree.', session_worktree_remove_locked_by_terminal: 'Não é possível remover — uma sessão de terminal ativa está usando este worktree.', + session_worktree_remove_unsafe_blocked: 'Resolva alterações locais ou commits não enviados antes de remover este worktree.', session_worktree_remove_dirty_warning: 'AVISO: Este worktree tem alterações não confirmadas que serão perdidas.', session_worktree_remove_untracked_warning: (count) => `${count} arquivo(s) não rastreados serão excluídos permanentemente.`, session_worktree_remove_ahead_warning: (ahead) => `${ahead} commit(s) não enviados serão perdidos.`, @@ -10075,6 +10083,7 @@ const LOCALES = { session_worktree_remove_status_failed: '워크트리 상태 읽기 실패: ', session_worktree_remove_locked_by_stream: '삭제할 수 없습니다 — 활성 스트리밍 세션이 이 worktree를 사용 중입니다.', session_worktree_remove_locked_by_terminal: '삭제할 수 없습니다 — 활성 터미널 세션이 이 worktree를 사용 중입니다.', + session_worktree_remove_unsafe_blocked: '이 worktree를 삭제하기 전에 로컬 변경 사항이나 푸시되지 않은 커밋을 정리하세요.', session_worktree_remove_dirty_warning: '경고: 이 worktree에는 커밋되지 않은 변경 사항이 있으며 손실됩니다.', session_worktree_remove_untracked_warning: (count) => `${count}개의 추적되지 않은 파일이 영구적으로 삭제됩니다.`, session_worktree_remove_ahead_warning: (ahead) => `${ahead}개의 푸시되지 않은 커밋이 손실됩니다.`, @@ -11114,6 +11123,7 @@ const LOCALES = { session_worktree_remove_status_failed: 'Échec de la lecture du statut du worktree : ', session_worktree_remove_locked_by_stream: 'Impossible de supprimer — une session de streaming active utilise ce worktree.', session_worktree_remove_locked_by_terminal: 'Impossible de supprimer — une session de terminal active utilise ce worktree.', + session_worktree_remove_unsafe_blocked: 'Résolvez les modifications locales ou les commits non poussés avant de supprimer ce worktree.', session_worktree_remove_dirty_warning: 'ATTENTION : Ce worktree a des modifications non validées qui seront perdues.', session_worktree_remove_untracked_warning: (count) => `${count} fichier(s) non suivi(s) seront définitivement supprimés.`, session_worktree_remove_ahead_warning: (ahead) => `${ahead} commit(s) non poussé(s) seront perdus.`,