feat: support deleting archived sessions

Author: vnt-dev

apps/kimi-code/src-tauri/src/lib.rs

@@ -327,6 +327,22 @@ async fn list_archived_sessions(state: State<'_, AppState>) -> Result<Vec<Sessio
     state.client.list_archived_sessions().await
 }
 
+#[tauri::command]
+async fn delete_archived_sessions(
+    state: State<'_, AppState>,
+    session_ids: Vec<String>,
+) -> Result<Vec<String>, String> {
+    let session_ids = state.client.delete_archived_sessions(&session_ids).await?;
+    if !session_ids.is_empty() {
+        state
+            .web_server
+            .desktop_state_changed(DesktopStateChange::SessionsDeleted {
+                session_ids: session_ids.clone(),
+            });
+    }
+    Ok(session_ids)
+}
+
 #[tauri::command]
 async fn fork_session(state: State<'_, AppState>, session_id: String) -> Result<String, String> {
     let session_id = state.client.fork_session(&session_id).await?;
@@ -750,6 +766,7 @@ pub fn run() {
             remove_workspace,
             list_workspace_sessions,
             list_archived_sessions,
+            delete_archived_sessions,
             fork_session,
             archive_session,
             restore_session,

apps/kimi-code/src/ArchivedSessionsSettings.tsx

@@ -6,16 +6,23 @@ import {
   RefreshCw,
   RotateCcw,
   Search,
+  Trash2,
 } from "lucide-react";
 import { useEffect, useMemo, useState } from "react";
 
-import { listArchivedSessions, restoreSession } from "./agentRpc";
 import {
+  deleteArchivedSessions,
+  listArchivedSessions,
+  restoreSession,
+} from "./agentRpc";
+import {
+  archivedSessionIdsForWorkspace,
   archivedSessionPath,
   archivedSessionTitle,
   filterArchivedSessions,
   formatArchivedTime,
   groupArchivedSessions,
+  removeArchivedSessions,
   type ArchivedSessionSort,
 } from "./archivedSessions";
 import SettingsSelect from "./components/SettingsSelect";
@@ -25,6 +32,18 @@ import { conciseError } from "./utils/errors";
 
 const ALL_WORKSPACES = "all";
 
+type DeleteTarget =
+  | {
+      kind: "session";
+      sessionIds: string[];
+      label: string;
+    }
+  | {
+      kind: "workspace";
+      sessionIds: string[];
+      label: string;
+    };
+
 export default function ArchivedSessionsSettings() {
   const [sessions, setSessions] = useState<SessionSummary[]>([]);
   const [loading, setLoading] = useState(true);
@@ -33,6 +52,8 @@ export default function ArchivedSessionsSettings() {
   const [workspacePath, setWorkspacePath] = useState(ALL_WORKSPACES);
   const [sort, setSort] = useState<ArchivedSessionSort>("archived-desc");
   const [restoringId, setRestoringId] = useState<string>();
+  const [deleteTarget, setDeleteTarget] = useState<DeleteTarget>();
+  const [deleting, setDeleting] = useState(false);
   const [reloadKey, setReloadKey] = useState(0);
 
   useEffect(() => {
@@ -54,6 +75,18 @@ export default function ArchivedSessionsSettings() {
     };
   }, [reloadKey]);
 
+  useEffect(() => {
+    if (!deleteTarget) return;
+    const handleKeyDown = (event: KeyboardEvent): void => {
+      if (event.key !== "Escape") return;
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      if (!deleting) setDeleteTarget(undefined);
+    };
+    document.addEventListener("keydown", handleKeyDown, true);
+    return () => document.removeEventListener("keydown", handleKeyDown, true);
+  }, [deleteTarget, deleting]);
+
   const untitledLabel = t("conversation.new");
   const unknownWorkspaceLabel = t("settings.archivedUnknownWorkspace");
   const locale = getLanguage() === "zh" ? "zh-CN" : "en";
@@ -72,6 +105,17 @@ export default function ArchivedSessionsSettings() {
     ];
   }, [locale, sessions, unknownWorkspaceLabel]);
 
+  useEffect(() => {
+    if (
+      loading ||
+      workspacePath === ALL_WORKSPACES ||
+      workspaceOptions.some((option) => option.value === workspacePath)
+    ) {
+      return;
+    }
+    setWorkspacePath(ALL_WORKSPACES);
+  }, [loading, workspaceOptions, workspacePath]);
+
   const filtered = useMemo(
     () =>
       filterArchivedSessions(sessions, {
@@ -96,23 +140,58 @@ export default function ArchivedSessionsSettings() {
     () => groupArchivedSessions(filtered, unknownWorkspaceLabel),
     [filtered, unknownWorkspaceLabel],
   );
+  const mutationBusy = restoringId !== undefined || deleting;
 
   const handleRestore = async (sessionId: string): Promise<void> => {
-    if (restoringId) return;
+    if (mutationBusy) return;
     setRestoringId(sessionId);
     setError(undefined);
     try {
       await restoreSession(sessionId);
-      setSessions((current) =>
-        current.filter((session) => session.id !== sessionId),
-      );
+      setSessions((current) => removeArchivedSessions(current, [sessionId]));
     } catch (restoreError) {
       setError(conciseError(restoreError));
     } finally {
       setRestoringId(undefined);
     }
   };
 
+  const requestWorkspaceDelete = (
+    workspaceId: string,
+    path: string,
+  ): void => {
+    if (mutationBusy) return;
+    const sessionIds = archivedSessionIdsForWorkspace(sessions, workspaceId);
+    if (sessionIds.length === 0) return;
+    setDeleteTarget({ kind: "workspace", sessionIds, label: path });
+  };
+
+  const handleDelete = async (): Promise<void> => {
+    if (!deleteTarget || mutationBusy) return;
+    setDeleting(true);
+    setError(undefined);
+    try {
+      const deletedSessionIds = await deleteArchivedSessions(
+        deleteTarget.sessionIds,
+      );
+      setSessions((current) =>
+        removeArchivedSessions(current, deletedSessionIds),
+      );
+      setDeleteTarget(undefined);
+    } catch (deleteError) {
+      const message = conciseError(deleteError);
+      try {
+        const items = await listArchivedSessions();
+        setSessions(items.filter((session) => session.archived));
+      } catch {
+        // Preserve the original mutation error; Retry performs a full reload.
+      }
+      setError(message);
+    } finally {
+      setDeleting(false);
+    }
+  };
+
   return (
     <section
       className="settings-archived"
@@ -196,7 +275,7 @@ export default function ArchivedSessionsSettings() {
       ) : groups.length > 0 ? (
         <div className="settings-archived-list">
           {groups.map((group) => (
-            <section className="settings-archived-group" key={group.path}>
+            <section className="settings-archived-group" key={group.workspaceId}>
               <div className="settings-archived-workspace">
                 <Folder size={15} aria-hidden="true" />
                 <span title={group.path}>{group.path}</span>
@@ -205,36 +284,70 @@ export default function ArchivedSessionsSettings() {
                     count: group.sessions.length,
                   })}
                 </small>
+                <button
+                  className="settings-archived-delete-all"
+                  type="button"
+                  disabled={mutationBusy}
+                  aria-label={t("settings.archivedDeleteAllLabel", {
+                    path: group.path,
+                  })}
+                  onClick={() =>
+                    requestWorkspaceDelete(group.workspaceId, group.path)
+                  }
+                >
+                  <Trash2 size={13} />
+                  {t("settings.archivedDeleteAll")}
+                </button>
               </div>
               <div className="settings-archived-card">
-                {group.sessions.map((session) => (
-                  <div className="settings-archived-row" key={session.id}>
-                    <div className="settings-archived-meta">
-                      <strong title={archivedSessionTitle(session, untitledLabel)}>
-                        {archivedSessionTitle(session, untitledLabel)}
-                      </strong>
-                      <span>
-                        {t("settings.archivedAt", {
-                          time: formatArchivedTime(session.updatedAt),
-                        })}
-                      </span>
+                {group.sessions.map((session) => {
+                  const title = archivedSessionTitle(session, untitledLabel);
+                  return (
+                    <div className="settings-archived-row" key={session.id}>
+                      <div className="settings-archived-meta">
+                        <strong title={title}>{title}</strong>
+                        <span>
+                          {t("settings.archivedAt", {
+                            time: formatArchivedTime(session.updatedAt),
+                          })}
+                        </span>
+                      </div>
+                      <div className="settings-archived-actions">
+                        <button
+                          className="settings-archived-restore"
+                          type="button"
+                          disabled={mutationBusy}
+                          onClick={() => void handleRestore(session.id)}
+                        >
+                          <RotateCcw
+                            size={14}
+                            className={
+                              restoringId === session.id ? "spinning" : undefined
+                            }
+                          />
+                          {restoringId === session.id
+                            ? t("settings.archivedRestoring")
+                            : t("settings.archivedRestore")}
+                        </button>
+                        <button
+                          className="settings-archived-delete"
+                          type="button"
+                          disabled={mutationBusy}
+                          onClick={() =>
+                            setDeleteTarget({
+                              kind: "session",
+                              sessionIds: [session.id],
+                              label: title,
+                            })
+                          }
+                        >
+                          <Trash2 size={14} />
+                          {t("settings.archivedDelete")}
+                        </button>
+                      </div>
                     </div>
-                    <button
-                      className="settings-archived-restore"
-                      type="button"
-                      disabled={restoringId !== undefined}
-                      onClick={() => void handleRestore(session.id)}
-                    >
-                      <RotateCcw
-                        size={14}
-                        className={restoringId === session.id ? "spinning" : undefined}
-                      />
-                      {restoringId === session.id
-                        ? t("settings.archivedRestoring")
-                        : t("settings.archivedRestore")}
-                    </button>
-                  </div>
-                ))}
+                  );
+                })}
               </div>
             </section>
           ))}
@@ -246,6 +359,63 @@ export default function ArchivedSessionsSettings() {
             : t("settings.archivedNoMatch")}
         </div>
       )}
+
+      {deleteTarget && (
+        <div
+          className="settings-archived-confirm-backdrop"
+          onMouseDown={(event) => {
+            if (event.target === event.currentTarget && !deleting) {
+              setDeleteTarget(undefined);
+            }
+          }}
+        >
+          <div
+            className="settings-archived-confirm"
+            role="alertdialog"
+            aria-modal="true"
+            aria-labelledby="archived-delete-confirm-title"
+          >
+            <span className="settings-archived-confirm-icon">
+              <Trash2 size={19} />
+            </span>
+            <h4 id="archived-delete-confirm-title">
+              {t(
+                deleteTarget.kind === "session"
+                  ? "settings.archivedDeleteSessionTitle"
+                  : "settings.archivedDeleteWorkspaceTitle",
+              )}
+            </h4>
+            <p>
+              {deleteTarget.kind === "session"
+                ? t("settings.archivedDeleteSessionCopy", {
+                    title: deleteTarget.label,
+                  })
+                : t("settings.archivedDeleteWorkspaceCopy", {
+                    path: deleteTarget.label,
+                    count: deleteTarget.sessionIds.length,
+                  })}
+            </p>
+            <div className="settings-archived-confirm-actions">
+              <button
+                type="button"
+                autoFocus
+                disabled={deleting}
+                onClick={() => setDeleteTarget(undefined)}
+              >
+                {t("common.cancel")}
+              </button>
+              <button
+                className="danger"
+                type="button"
+                disabled={deleting}
+                onClick={() => void handleDelete()}
+              >
+                {deleting ? t("settings.archivedDeleting") : t("settings.archivedConfirmDelete")}
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
     </section>
   );
 }

apps/kimi-code/src/agentRpc.ts

@@ -309,6 +309,12 @@ export function listArchivedSessions(): Promise<SessionSummary[]> {
   return invoke<SessionSummary[]>("list_archived_sessions");
 }
 
+export function deleteArchivedSessions(
+  sessionIds: string[],
+): Promise<string[]> {
+  return invoke<string[]>("delete_archived_sessions", { sessionIds });
+}
+
 export function forkSession(sessionId: string): Promise<string> {
   return invoke<string>("fork_session", { sessionId });
 }