@rightkit/system-ui 0.0.0-stage → 0.1.0

package/dist/views/Chat.js

@@ -0,0 +1,255 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { invoke } from "@tauri-apps/api/core";
+import { Button, ConfirmDialog, Input } from "@rightkit/react-shell/react";
+import { ChevronDown, ChevronRight, Search } from "lucide-react";
+import { clearVisibleInterval, visibleInterval } from "../visible.js";
+import { chatKindName } from "../lib/chatKind.js";
+/** The hub's web view is destroyed on window close, so the chosen chat and the unsent draft are kept here. */
+const KEPT_CHAT = "pulse.hub.chat.selected";
+const KEPT_DRAFT = "pulse.hub.chat.draft";
+const readKept = (key) => {
+    try {
+        return localStorage.getItem(key);
+    }
+    catch {
+        return null;
+    }
+};
+const writeKept = (key, value) => {
+    try {
+        if (value)
+            localStorage.setItem(key, value);
+        else
+            localStorage.removeItem(key);
+    }
+    catch {
+        // Storage unavailable: the draft is lost on close, as before.
+    }
+};
+/** The receipt states that mean the chat's side took the message, so the draft can go. */
+const TOOK_IT = new Set(["delivered", "sent", "queued", "held"]);
+/** What each receipt state means, in plain words. The receipt's own detail follows it. */
+const RECEIPT_WORDS = {
+    delivered: "Delivered.",
+    sent: "Sent, no verdict. The chat raised no objection, but it has not confirmed it read the message.",
+    queued: "Queued. It shows at the chat's next turn; reading is not confirmed.",
+    held: "Held. It will not be read until its owner continues or approves it.",
+    refused: "Refused.",
+    unsupported: "Unsupported. That chat cannot take messages this way.",
+    unknown: "Unknown. It may or may not have arrived. Check the inbox, then send once more.",
+};
+/** "42s", "5min", "3h" or "2d" since `ms`. */
+function ageOf(ms) {
+    const secs = Math.max(0, Math.floor((Date.now() - ms) / 1000));
+    if (secs < 60)
+        return `${secs}s`;
+    if (secs < 3600)
+        return `${Math.floor(secs / 60)}min`;
+    if (secs < 86400)
+        return `${Math.floor(secs / 3600)}h`;
+    return `${Math.floor(secs / 86400)}d`;
+}
+function lastSeen(ms) {
+    return ms ? `${ageOf(ms)} ago` : "not seen";
+}
+function plural(count, word) {
+    return `${count} ${word}${count === 1 ? "" : "s"}`;
+}
+function linkLine(link) {
+    if (link.online)
+        return `${link.device}: reached ${link.lastOkMs ? ageOf(link.lastOkMs) : "just now"} ago`;
+    const since = link.lastOkMs ? `, last reached ${ageOf(link.lastOkMs)} ago` : ", never reached";
+    return `${link.device}: offline${since}`;
+}
+/** Chats grouped by computer: this computer first, then the linked ones in the order given. */
+function groupByDevice(chats) {
+    const groups = new Map();
+    for (const chat of chats) {
+        const rows = groups.get(chat.device) ?? [];
+        rows.push(chat);
+        groups.set(chat.device, rows);
+    }
+    const isLocal = (rows) => (rows.some((c) => c.local) ? 1 : 0);
+    return Array.from(groups.entries()).sort(([, a], [, b]) => isLocal(b) - isLocal(a));
+}
+export function Chat() {
+    const [status, setStatus] = useState(null);
+    const [liveError, setLiveError] = useState(null);
+    const [inbox, setInbox] = useState(null);
+    const [inboxOpen, setInboxOpen] = useState(false);
+    const [peers, setPeers] = useState(null);
+    const [peersError, setPeersError] = useState(null);
+    const [query, setQuery] = useState("");
+    const [selectedId, setSelectedId] = useState(() => readKept(KEPT_CHAT));
+    const [draft, setDraft] = useState(() => readKept(KEPT_DRAFT) ?? "");
+    const [sending, setSending] = useState(false);
+    const [receipt, setReceipt] = useState(null);
+    const [sendError, setSendError] = useState(null);
+    const [linkDevice, setLinkDevice] = useState("");
+    const [linkSsh, setLinkSsh] = useState("");
+    const [linkPulse, setLinkPulse] = useState("");
+    const [linking, setLinking] = useState(false);
+    const [linkNote, setLinkNote] = useState(null);
+    const [linkError, setLinkError] = useState(null);
+    const [unlinking, setUnlinking] = useState(null);
+    // Set while the section is shown; a late answer after it closes is dropped.
+    const alive = useRef(false);
+    // One chat listing at a time: linked computers answer over ssh, which can take seconds.
+    const peersBusy = useRef(false);
+    useEffect(() => {
+        alive.current = true;
+        return () => {
+            alive.current = false;
+        };
+    }, []);
+    const refreshLive = useCallback(() => {
+        invoke("chat_status")
+            .then((value) => {
+            if (!alive.current)
+                return;
+            setStatus(value);
+            setLiveError(null);
+        })
+            .catch((e) => {
+            if (alive.current)
+                setLiveError(String(e));
+        });
+        invoke("chat_inbox")
+            .then((value) => {
+            if (alive.current)
+                setInbox(value);
+        })
+            .catch((e) => {
+            if (alive.current)
+                setLiveError(String(e));
+        });
+    }, []);
+    const refreshPeers = useCallback(() => {
+        if (peersBusy.current)
+            return;
+        peersBusy.current = true;
+        invoke("chat_peers")
+            .then((list) => {
+            if (!alive.current)
+                return;
+            setPeers(list);
+            setPeersError(null);
+        })
+            .catch((e) => {
+            if (alive.current)
+                setPeersError(String(e));
+        })
+            .finally(() => {
+            peersBusy.current = false;
+        });
+    }, []);
+    // Local state every 3 seconds (as the other pages poll); linked computers every 10 seconds.
+    // The timers run only while this section is shown.
+    useEffect(() => {
+        refreshLive();
+        const timer = visibleInterval(refreshLive, 3000);
+        return () => clearVisibleInterval(timer);
+    }, [refreshLive]);
+    useEffect(() => {
+        refreshPeers();
+        const timer = visibleInterval(refreshPeers, 30000);
+        return () => clearVisibleInterval(timer);
+    }, [refreshPeers]);
+    const list = peers ?? [];
+    const q = query.trim().toLowerCase();
+    const visible = q
+        ? list.filter((c) => [c.name, c.device, c.kind, c.folder, c.state].join(" ").toLowerCase().includes(q))
+        : list;
+    useEffect(() => writeKept(KEPT_CHAT, selectedId), [selectedId]);
+    useEffect(() => writeKept(KEPT_DRAFT, draft), [draft]);
+    const chosen = list.find((c) => c.id === selectedId) ?? null;
+    const canSend = chosen !== null && draft.trim() !== "" && !sending;
+    const send = () => {
+        if (!chosen || !canSend)
+            return;
+        const text = draft;
+        setSending(true);
+        setSendError(null);
+        invoke("chat_send", { target: chosen.id, text })
+            .then((value) => {
+            if (!alive.current)
+                return;
+            setReceipt(value);
+            // Keep the draft when the chat did not take it, so it can be sent again.
+            if (TOOK_IT.has(value.state))
+                setDraft((current) => (current === text ? "" : current));
+        })
+            .catch((e) => {
+            if (alive.current)
+                setSendError(String(e));
+        })
+            .finally(() => {
+            if (alive.current)
+                setSending(false);
+        });
+    };
+    const onDraftKey = (e) => {
+        if (e.key === "Enter" && (e.metaKey || e.ctrlKey)) {
+            e.preventDefault();
+            send();
+        }
+    };
+    const canLink = linkDevice.trim() !== "" && linkSsh.trim() !== "" && !linking;
+    const linkComputer = () => {
+        if (!canLink)
+            return;
+        setLinking(true);
+        setLinkError(null);
+        setLinkNote(null);
+        invoke("chat_link", { device: linkDevice, sshHost: linkSsh, pulse: linkPulse.trim() || null })
+            .then((value) => {
+            if (!alive.current)
+                return;
+            setLinkNote(`Linked ${value.device} (${value.ssh}): ${plural(value.chats, "chat")} there now.`);
+            setLinkDevice("");
+            setLinkSsh("");
+            setLinkPulse("");
+            refreshLive();
+            refreshPeers();
+        })
+            .catch((e) => {
+            if (alive.current)
+                setLinkError(String(e));
+        })
+            .finally(() => {
+            if (alive.current)
+                setLinking(false);
+        });
+    };
+    const unlink = (device) => {
+        setUnlinking(null);
+        setLinkError(null);
+        setLinkNote(null);
+        invoke("chat_unlink", { device })
+            .then(() => {
+            if (!alive.current)
+                return;
+            setLinkNote(`Unlinked ${device}.`);
+            refreshLive();
+            refreshPeers();
+        })
+            .catch((e) => {
+            if (alive.current)
+                setLinkError(String(e));
+        });
+    };
+    let statusLine = "Reading…";
+    if (status && !status.enabled) {
+        statusLine = "Chat is off on this computer, so messages are refused. Turn it on in Settings, under General.";
+    }
+    else if (status) {
+        statusLine = `${plural(status.chatsHere, "chat")} on ${status.device}.`;
+        if (!status.hubRunning) {
+            statusLine += " Pulse's hub is not reporting as running, so messages to Claude chats may be held until it is.";
+        }
+    }
+    const groups = groupByDevice(visible);
+    const inboxCount = inbox?.messages.length ?? 0;
+    return (_jsxs("div", { className: "view ck-chat", children: [_jsx("p", { className: "ck-chat-intro", children: "Chat sends a message from one agent chat to another, on this computer or a linked one. The receiver is another agent, not a person. A reply arrives in the chat that sent the message, not in this window." }), _jsxs("section", { className: "ck-chat-panel", "aria-label": "Chat status", children: [_jsx("div", { className: "ck-chat-status", role: "status", children: statusLine }), liveError && _jsx("div", { className: "error", role: "alert", children: liveError }), status?.enabled && status.links.map((link) => (_jsxs("div", { className: "ck-chat-link-line", children: [_jsx("span", { children: linkLine(link) }), !link.online && link.lastError && _jsx("span", { className: "ck-chat-link-error", children: link.lastError })] }, link.device)))] }), _jsxs("div", { className: "ck-chat-main", children: [_jsxs("section", { className: "ck-chat-panel ck-chat-chats", "aria-label": "Chats", children: [_jsx("h2", { children: "Chats" }), _jsxs("label", { className: "ck-chat-search", children: [_jsx(Search, { size: 15, strokeWidth: 1.75, "aria-hidden": "true" }), _jsx(Input, { type: "search", "aria-label": "Search chats", placeholder: "Search by name, computer or folder", value: query, onChange: (e) => setQuery(e.target.value) })] }), peersError && _jsx("div", { className: "error", role: "alert", children: peersError }), peers === null && !peersError && _jsx("p", { className: "ck-sub", children: "Reading chats\u2026" }), peers !== null && list.length === 0 && (_jsx("p", { className: "ck-sub", children: "No chats found. Open a Claude, Codex or Muse chat on this computer, or link another computer." })), peers !== null && list.length > 0 && visible.length === 0 && _jsx("p", { className: "ck-sub", children: "No chat matches the search." }), groups.map(([device, rows]) => (_jsxs("div", { className: "ck-chat-device", children: [_jsx("h3", { children: device }), _jsx("ul", { className: "ck-chat-list", children: rows.map((c) => (_jsx("li", { children: _jsxs(Button, { variant: "ghost", className: "ck-chat-item", "aria-pressed": c.id === selectedId, onClick: () => setSelectedId(c.id), children: [_jsx("span", { className: `ck-chat-kind ck-chat-kind-${c.kind}`, children: chatKindName(c.kind) }), _jsx("span", { className: "ck-chat-name", title: c.folder || undefined, children: c.name }), _jsxs("span", { className: "ck-chat-meta", children: [c.state, c.liveness !== "unknown" ? ` · ${c.liveness}` : "", " \u00B7 ", lastSeen(c.updatedMs)] })] }) }, c.id))) })] }, device)))] }), _jsxs("section", { className: "ck-chat-panel ck-chat-compose", "aria-label": "Message", children: [_jsx("h2", { children: chosen ? `Message to ${chosen.display}` : "Message" }), !chosen && _jsx("p", { className: "ck-sub", children: selectedId ? "That chat is no longer listed." : "Choose a chat to message." }), _jsxs("label", { className: "ck-chat-field", children: [_jsx("span", { children: "Message text" }), _jsx("textarea", { rows: 5, value: draft, disabled: !chosen, placeholder: "Written for another agent, not a person", onChange: (e) => setDraft(e.target.value), onKeyDown: onDraftKey })] }), _jsxs("div", { className: "ck-chat-compose-foot", children: [_jsx("span", { className: "ck-sub", children: "Cmd+Enter or Ctrl+Enter sends. Sent from here, the message has no sending chat, so a reply has nowhere to return." }), _jsx(Button, { variant: "primary", size: "sm", disabled: !canSend, onClick: send, children: sending ? "Sending…" : "Send" })] }), sendError && _jsx("div", { className: "error", role: "alert", children: sendError }), receipt && (_jsxs("div", { className: "ck-chat-receipt", role: "status", children: [_jsxs("strong", { children: [receipt.chat, ":"] }), " ", RECEIPT_WORDS[receipt.state] ?? receipt.state, " ", receipt.detail] }))] })] }), _jsxs("section", { className: "ck-chat-panel", "aria-label": "Inbox", children: [_jsxs(Button, { variant: "ghost", className: "ck-chat-disclosure", "aria-expanded": inboxOpen, "aria-controls": "ck-chat-inbox-body", onClick: () => setInboxOpen((open) => !open), children: [inboxOpen ? _jsx(ChevronDown, { size: 15, strokeWidth: 1.75, "aria-hidden": "true" }) : _jsx(ChevronRight, { size: 15, strokeWidth: 1.75, "aria-hidden": "true" }), "Inbox", inbox ? ` (${inboxCount})` : ""] }), inboxOpen && (_jsxs("div", { id: "ck-chat-inbox-body", className: "ck-chat-inbox", children: [_jsx("p", { className: "ck-sub", children: "Messages for chats on this computer that they have not read yet. Opening this list does not mark them read." }), inboxCount === 0 && _jsx("p", { className: "ck-sub", children: "No unread messages." }), inbox?.messages.map((m) => (_jsxs("div", { className: "ck-chat-message", children: [_jsxs("div", { className: "ck-sub", children: [m.from, " to ", m.chat, " \u00B7 ", lastSeen(m.receivedMs)] }), _jsx("pre", { children: m.body })] }, m.id))), inbox && inbox.evicted > 0 && (_jsxs("p", { className: "ck-sub", children: [plural(inbox.evicted, "older message"), " dropped to keep the inbox small."] }))] }))] }), _jsxs("section", { className: "ck-chat-panel", "aria-label": "Linked computers", children: [_jsx("h2", { children: "Link a computer" }), _jsx("p", { className: "ck-sub", children: "Link each computer to the other, so replies can come back. The computer must be reachable over ssh with keys that work. Checking the link can take a little while." }), status?.links.map((link) => (_jsxs("div", { className: "ck-chat-link-row", children: [_jsxs("span", { className: "ck-chat-link-name", children: [link.device, " ", _jsx("span", { className: "ck-sub", children: link.ssh })] }), _jsx(Button, { size: "sm", variant: "secondary", onClick: () => setUnlinking(link.device), children: "Unlink" })] }, link.device))), status && status.links.length === 0 && _jsx("p", { className: "ck-sub", children: "No linked computers yet." }), _jsxs("div", { className: "ck-chat-form", children: [_jsxs("label", { className: "ck-chat-field", children: [_jsx("span", { children: "Computer name" }), _jsx(Input, { type: "text", value: linkDevice, placeholder: "mac-mini", onChange: (e) => setLinkDevice(e.target.value) })] }), _jsxs("label", { className: "ck-chat-field", children: [_jsx("span", { children: "ssh host" }), _jsx(Input, { type: "text", value: linkSsh, placeholder: "mac-mini.local", onChange: (e) => setLinkSsh(e.target.value) })] }), _jsxs("label", { className: "ck-chat-field", children: [_jsx("span", { children: "Path of pulse there (optional)" }), _jsx(Input, { type: "text", value: linkPulse, placeholder: "pulse", onChange: (e) => setLinkPulse(e.target.value) })] }), _jsx(Button, { size: "sm", variant: "primary", disabled: !canLink, onClick: linkComputer, children: linking ? "Linking…" : "Link" })] }), linkNote && _jsx("div", { className: "ck-sub", role: "status", children: linkNote }), linkError && _jsx("div", { className: "error", role: "alert", children: linkError })] }), unlinking && (_jsx(ConfirmDialog, { danger: true, title: `Unlink ${unlinking}?`, description: "Chats there stop being reachable from this computer until you link it again.", confirmLabel: "Unlink", onConfirm: () => unlink(unlinking), onCancel: () => setUnlinking(null) }))] }));
+}

package/dist/views/ChromeSnapshots.d.ts

@@ -0,0 +1,6 @@
+import { type ChromeSnapshots } from "../api.js";
+/** Chrome's leftover signing snapshots as a normal finding row: how many, the
+ *  change since the last check, and what moving them would really give back. */
+export declare function ChromeSnapshotsLine({ info }: {
+    info: ChromeSnapshots | null | undefined;
+}): import("react").JSX.Element | null;

package/dist/views/ChromeSnapshots.js

@@ -0,0 +1,19 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { bytes } from "../api.js";
+const dateText = (secs) => new Date(secs * 1000).toLocaleDateString(undefined, { month: "short", day: "numeric" });
+/** Chrome's leftover signing snapshots as a normal finding row: how many, the
+ *  change since the last check, and what moving them would really give back. */
+export function ChromeSnapshotsLine({ info }) {
+    if (!info || info.count === 0)
+        return null;
+    const n = info.count;
+    const delta = info.since_at != null && info.since_count != null ? n - info.since_count : null;
+    const since = info.since_at != null ? dateText(info.since_at) : "";
+    const change = delta == null || delta === 0 ? null : delta < 0 ? `${-delta} fewer since ${since}` : `+${delta} since ${since}`;
+    const detail = !info.reclaimable_known
+        ? `Apparent ${bytes(info.apparent_bytes)}, much less to free; shares space with Chrome`
+        : info.reclaimable_bytes === 0
+            ? "Nothing to free; shares space with Chrome"
+            : `About ${bytes(info.reclaimable_bytes)} to gain (apparent ${bytes(info.apparent_bytes)}, shares space with Chrome)`;
+    return (_jsxs("div", { className: "finding", title: "Temporary copies of the Chrome app left behind when Chrome is force-quit", children: [_jsx("span", {}), _jsxs("div", { className: "finding-main", children: [_jsxs("span", { className: "name", children: ["Chrome ", n === 1 ? "snapshot" : "snapshots", _jsxs("span", { className: "muted", children: [" \u00B7 ", n, change ? ` (${change})` : ""] })] }), _jsxs("span", { className: "muted small finding-reason", children: [detail, info.running && ` · Close Chrome to clear ${n === 1 ? "it" : "them"}`] })] }), _jsx("span", { className: "size strong", children: info.reclaimable_known ? bytes(info.reclaimable_bytes) : "" }), _jsx("span", {})] }));
+}

package/dist/views/Cleanup.d.ts

@@ -0,0 +1,4 @@
+/** `autoScan` is Settings > General > Background > "Scan when Storage or Cleanup opens" (on by default). */
+export declare function Cleanup({ autoScan }: {
+    autoScan?: boolean;
+}): import("react").JSX.Element;

package/dist/views/Cleanup.js

@@ -0,0 +1,291 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { Badge, Button, Checkbox, ConfirmDialog, Notice, SegmentedControl } from "@rightkit/react-shell/react";
+import { invoke } from "@tauri-apps/api/core";
+import { ChevronRight } from "lucide-react";
+import { ago, bytes, isStale, isWindows } from "../api.js";
+import { readKept, writeKept } from "../kept.js";
+// Windows moves files to the Recycle Bin; the Mac moves them to the Trash.
+const TRASH = isWindows ? "Recycle Bin" : "Trash";
+const KEPT_SELECTED = "pulse.hub.cleanup.selected";
+/** How each past move was measured, by activity id: a lower bound (≥) or an upper bound (up to). Absent means exact. */
+const KEPT_BOUNDS = "pulse.hub.cleanup.bounds";
+import { ChromeSnapshotsLine } from "./ChromeSnapshots.js";
+const cleanup = {
+    scan: () => invoke("cleanup_scan"),
+    cached: () => invoke("cleanup_cached"),
+    apply: (items) => invoke("cleanup_apply", { items }),
+    history: () => invoke("cleanup_history"),
+    restore: (id) => invoke("cleanup_restore", { id }),
+};
+const shortPath = (path) => path.replace(/^\/Users\/[^/]+/, "~");
+const items = (n) => `${n} item${n === 1 ? "" : "s"}`;
+// The plain-words warning for one run, or null when nothing needs saying.
+const runWarning = (a) => {
+    const parts = [];
+    const unknown = a.unknown ?? 0;
+    const skipped = a.skipped ?? 0;
+    if (unknown > 0)
+        parts.push(`${items(unknown)} could not be confirmed`);
+    if (skipped > 0)
+        parts.push(`${items(skipped)} ${skipped === 1 ? "was" : "were"} skipped`);
+    const detail = parts.join(" and ");
+    if (a.recovered) {
+        const lead = "Pulse was interrupted during this cleanup";
+        return detail ? `${lead}; ${detail}.` : `${lead}.`;
+    }
+    if (!detail)
+        return null;
+    return `${detail.charAt(0).toUpperCase()}${detail.slice(1)}.`;
+};
+// One predicate for what can be selected, totalled and submitted. The backend
+// still decides again when the move runs, and unknown liveness never passes.
+const movable = (f) => f.eligible && f.action === "Move to Trash" && (f.risk === "safe" || f.risk === "review") && !!f.dev && !!f.ino;
+const total = (xs) => {
+    const sum = xs.reduce((s, f) => s + f.bytes, 0);
+    const prefix = xs.some((f) => f.partial) ? "≥ " : xs.some((f) => f.upper_bound) ? "up to " : "";
+    return `${prefix}${bytes(sum)}`;
+};
+// The plain facts under an item's name: what it is, how safe it is to move, who made it, when it was last written.
+const facts = (f) => [f.kind, f.safety, f.owner ? `from ${f.owner}` : null, f.last_used ? `last used ${ago(f.last_used)}` : "last use unknown"]
+    .filter(Boolean)
+    .join(" · ");
+// Wording for a size the scan could not prove would be freed.
+const ESTIMATE = "An estimate from allocated size on disk, not file size. Hard links and clones can make the real gain smaller.";
+// The drive's own free-space reading around a run: observed, and moved by anything else using the drive too.
+const freeSpaceLine = (v) => {
+    const change = v.after_available - v.before_available;
+    const amount = change === 0 ? "none" : `${change > 0 ? "+" : "-"}${bytes(Math.abs(change))}`;
+    return `Free space on ${v.volume} changed by ${amount} (observed).`;
+};
+const FREE_SPACE_CAVEAT = `Items in the ${TRASH} stay on the drive, so space is not freed until the ${TRASH} is emptied. Other activity on the drive also moves this number.`;
+function GroupHead({ title, xs, selected, onToggle, disabled, }) {
+    const count = xs.filter((f) => selected.has(f.id)).length;
+    return (_jsxs("div", { className: "ck-group-head", children: [_jsx(Checkbox, { checked: count === xs.length, indeterminate: count > 0 && count < xs.length, onChange: onToggle, disabled: disabled, label: _jsx("strong", { "aria-label": `Select all ${title.toLowerCase()} items`, children: title }) }), _jsx("span", { className: "muted ck-num", children: total(xs) })] }));
+}
+/** `autoScan` is Settings > General > Background > "Scan when Storage or Cleanup opens" (on by default). */
+export function Cleanup({ autoScan = true }) {
+    const [report, setReport] = useState(null);
+    const [history, setHistory] = useState([]);
+    const [historyWarnings, setHistoryWarnings] = useState([]);
+    // Kept apart from `error`, so a rescan's clear does not hide a failed history load.
+    const [historyError, setHistoryError] = useState(null);
+    const [selected, setSelected] = useState(new Set());
+    // The selection from before the window was closed; it replaces the preselection on the first scan.
+    const kept = useRef(readKept(KEPT_SELECTED));
+    const [pending, setPending] = useState(null);
+    const [pane, setPane] = useState("findings");
+    const [busy, setBusy] = useState(false);
+    const [refreshing, setRefreshing] = useState(false);
+    const [error, setError] = useState(null);
+    const [note, setNote] = useState(null);
+    const [restoreIssue, setRestoreIssue] = useState({});
+    // Recorded when each move ran, since the history itself does not carry the scan's bounds.
+    const [bounds, setBounds] = useState(() => readKept(KEPT_BOUNDS) ?? {});
+    const seeded = useRef(false);
+    // One findings scan at a time; a request made while one runs asks for another after it.
+    const scanning = useRef(false);
+    const again = useRef(false);
+    useEffect(() => {
+        // Until the first scan has replaced the kept selection, the empty set must not overwrite it.
+        if (!seeded.current)
+            return;
+        writeKept(KEPT_SELECTED, selected.size ? [...selected] : null);
+    }, [selected]);
+    const run = async (work) => {
+        setBusy(true);
+        setError(null);
+        try {
+            await work();
+        }
+        catch (e) {
+            setError(String(e));
+        }
+        finally {
+            setBusy(false);
+        }
+    };
+    // Preselected items are chosen once; later scans keep only what is still movable.
+    // A move waiting on confirmation keeps the items that are still offered.
+    const show = (next) => {
+        const first = !seeded.current;
+        seeded.current = true;
+        setReport(next);
+        const now = next.findings.filter(movable);
+        const restored = first ? kept.current : null;
+        if (first)
+            kept.current = null;
+        setSelected((prev) => first
+            ? restored
+                ? new Set(now.filter((f) => restored.includes(f.id)).map((f) => f.id))
+                : new Set(now.filter((f) => f.preselected).map((f) => f.id))
+            : new Set(now.filter((f) => prev.has(f.id)).map((f) => f.id)));
+        setPending((prev) => {
+            const kept = prev ? now.filter((f) => prev.some((p) => p.id === f.id)) : [];
+            return kept.length ? kept : null;
+        });
+    };
+    // A rescan runs behind the page, which stays usable while it runs: the saved
+    // findings can be selected and moved meanwhile, since every item is checked
+    // again when it moves.
+    const refresh = async () => {
+        if (scanning.current) {
+            again.current = true;
+            return;
+        }
+        scanning.current = true;
+        setRefreshing(true);
+        setError(null);
+        try {
+            do {
+                again.current = false;
+                show(await cleanup.scan());
+            } while (again.current);
+        }
+        catch (e) {
+            setError(String(e));
+        }
+        finally {
+            scanning.current = false;
+            setRefreshing(false);
+        }
+    };
+    // A failed history load stays on screen until a later load succeeds.
+    const loadHistory = () => cleanup
+        .history()
+        .then((next) => {
+        setHistory(next.actions);
+        setHistoryWarnings(next.warnings);
+        setHistoryError(null);
+    })
+        .catch((e) => setHistoryError(String(e)));
+    // Saved findings show at once. A rescan follows only when there are none or they are old.
+    useEffect(() => {
+        void loadHistory();
+        cleanup
+            .cached()
+            .then((saved) => {
+            if (saved)
+                show(saved);
+            if (autoScan && (!saved || isStale(saved.scanned_at)))
+                void refresh();
+        })
+            .catch(() => { if (autoScan)
+            void refresh(); });
+    }, []);
+    const all = report?.findings ?? [];
+    const eligible = all.filter(movable);
+    const safe = eligible.filter((f) => f.risk === "safe");
+    const review = eligible.filter((f) => f.risk === "review");
+    const held = all.filter((f) => !movable(f));
+    const chosen = useMemo(() => eligible.filter((f) => selected.has(f.id)), [report, selected]);
+    // Where the space is: every item the scan found, by category, whether or not it can be moved.
+    const byCategory = useMemo(() => {
+        const groups = new Map();
+        for (const f of all)
+            groups.set(f.category, [...(groups.get(f.category) ?? []), f]);
+        return [...groups.entries()]
+            .map(([category, xs]) => ({
+            category,
+            xs,
+            bytes: xs.reduce((s, f) => s + f.bytes, 0),
+            safety: [...new Set(xs.map((f) => f.safety).filter(Boolean))].join(", "),
+        }))
+            .sort((a, b) => b.bytes - a.bytes);
+    }, [report]);
+    const toggle = (id) => setSelected((prev) => {
+        const next = new Set(prev);
+        if (next.has(id))
+            next.delete(id);
+        else
+            next.add(id);
+        return next;
+    });
+    // One button for the common case: select the safe items and Chrome's signing copies for review.
+    // It only selects; nothing moves until the person confirms the move.
+    const freeable = eligible.filter((f) => f.risk === "safe" || f.rule_id === "chrome-signing-copies");
+    const freeUp = () => setSelected(new Set(freeable.map((f) => f.id)));
+    const toggleGroup = (xs, on) => setSelected((prev) => {
+        const next = new Set(prev);
+        xs.forEach((f) => (on ? next.add(f.id) : next.delete(f.id)));
+        return next;
+    });
+    const move = (picked) => {
+        setPending(null);
+        return run(async () => {
+            const sent = picked.filter(movable);
+            const result = await cleanup.apply(sent.map((f) => ({ rule_id: f.rule_id, path: f.path, dev: f.dev, ino: f.ino })));
+            const warnings = result.warnings ?? [];
+            if (result.activity_id) {
+                const bound = sent.some((f) => f.partial) ? "lower" : sent.some((f) => f.upper_bound) ? "upper" : null;
+                if (bound) {
+                    const next = { ...bounds, [result.activity_id]: bound };
+                    setBounds(next);
+                    writeKept(KEPT_BOUNDS, next);
+                }
+            }
+            const detail = [...result.skipped.map((s) => `${shortPath(s.path)}: ${s.reason}`), ...warnings].join("\n");
+            setNote(result.skipped.length
+                ? {
+                    tone: "warn",
+                    text: `Partly moved: ${bytes(result.moved_bytes)} (${items(result.moved_items)}) went to the ${TRASH}, ${result.skipped.length} skipped.`,
+                    detail,
+                }
+                : warnings.length
+                    ? {
+                        tone: "warn",
+                        text: `Moved to the ${TRASH}: ${bytes(result.moved_bytes)} (${items(result.moved_items)}), with a warning.`,
+                        detail,
+                    }
+                    : { tone: "ok", text: `Moved to the ${TRASH}: ${bytes(result.moved_bytes)} (${items(result.moved_items)}).`, detail: (result.free_space ?? []).length ? `${(result.free_space ?? []).map(freeSpaceLine).join(" ")} ${FREE_SPACE_CAVEAT}` : undefined });
+            // What moved leaves the list at once; the rescan behind it confirms.
+            const left = new Set(result.skipped.map((s) => s.path));
+            const gone = new Set(sent.filter((f) => !left.has(f.path)).map((f) => f.id));
+            setReport((prev) => (prev ? { ...prev, findings: prev.findings.filter((f) => !gone.has(f.id)) } : prev));
+            setSelected((prev) => new Set([...prev].filter((id) => !gone.has(id))));
+            await loadHistory();
+            void refresh();
+        });
+    };
+    const restore = (id) => run(async () => {
+        setRestoreIssue((prev) => {
+            const next = { ...prev };
+            delete next[id];
+            return next;
+        });
+        const result = await cleanup.restore(id);
+        const detail = result.skipped.map((s) => `${shortPath(s.path)}: ${s.reason}`).join("\n");
+        const warnings = result.warnings ?? [];
+        if (result.skipped.length)
+            setRestoreIssue((prev) => ({ ...prev, [id]: detail }));
+        setNote(result.skipped.length
+            ? { tone: "warn", text: `Partly restored: ${bytes(result.restored_bytes)} (${items(result.restored_items)}), ${result.skipped.length} stayed in the ${TRASH}.`, detail: warnings.join("\n") }
+            : warnings.length
+                ? { tone: "warn", text: `Restored: ${bytes(result.restored_bytes)} (${items(result.restored_items)}), with a warning.`, detail: warnings.join("\n") }
+                : { tone: "ok", text: `Restored: ${bytes(result.restored_bytes)} (${items(result.restored_items)}).` });
+        await loadHistory();
+        void refresh();
+    });
+    // A plain function, not a component: a component declared here is a new type on every
+    // render, which remounts its rows and drops focus and open details on each selection.
+    const group = (title, xs) => xs.length === 0 ? null : (_jsxs("section", { className: "ck-group", children: [_jsx(GroupHead, { title: title, xs: xs, selected: selected, onToggle: (on) => toggleGroup(xs, on), disabled: busy }), xs.map((f) => (_jsxs("div", { className: "ck-row", children: [_jsx("span", { className: "ck-check", children: _jsx(Checkbox, { checked: selected.has(f.id), onChange: () => toggle(f.id), disabled: busy, label: _jsxs("span", { className: "ov-vh", children: ["Select ", f.name] }) }) }), _jsxs("details", { className: "ck-detail", children: [_jsxs("summary", { children: [_jsx(ChevronRight, { size: 14, strokeWidth: 1.75, "aria-hidden": true }), _jsxs("span", { children: [_jsxs("span", { className: "ck-title", children: [_jsx("strong", { children: f.name }), _jsx(Badge, { tone: f.risk === "safe" ? "ok" : "warn", children: f.risk === "safe" ? "Safe" : "Review" })] }), _jsx("span", { className: "muted ck-reason", children: f.reason }), _jsx("span", { className: "muted ck-reason", children: facts(f) })] })] }), _jsx("p", { className: "muted ck-path", children: shortPath(f.path) }), _jsx("p", { className: "muted ck-path", children: f.category })] }), _jsxs("span", { className: "ck-num ck-size", title: f.upper_bound ? ESTIMATE : undefined, children: [f.partial ? "≥ " : f.upper_bound ? "up to " : "", bytes(f.bytes)] })] }, f.id)))] }, title));
+    const historyPane = (_jsxs("div", { className: "ck-card", children: [_jsx("h2", { children: "Moves and restore" }), historyWarnings.length > 0 && (_jsx(Notice, { tone: "warn", children: historyWarnings.map((w, n) => (_jsx("span", { className: "ck-lines", children: w }, n))) })), history.length === 0 && _jsx("p", { className: "muted", children: "Nothing moved yet. Confirmed moves appear here." }), history.map((a) => {
+                const left = a.items.filter((i) => !i.restored);
+                // An item whose state is unknown (interrupted) is never offered for Undo.
+                const canRestore = left.some((i) => i.trash_path && !i.interrupted);
+                const issue = restoreIssue[a.id];
+                const warning = runWarning(a);
+                return (_jsxs("div", { className: "ck-history", children: [_jsxs("div", { className: "ck-history-main", children: [_jsx("strong", { children: new Date(a.at * 1000).toLocaleString() }), _jsxs("span", { className: "muted", children: [a.items.length === 0
+                                            ? "Nothing was moved"
+                                            : `${items(a.items.length)} moved to the ${TRASH} · ${bounds[a.id] === "lower" ? "≥ " : bounds[a.id] === "upper" ? "up to " : ""}${bytes(a.bytes)}`, left.length < a.items.length ? ` · ${a.items.length - left.length} restored` : ""] }), warning && (_jsx(Notice, { tone: "warn", children: _jsx("span", { className: "ck-lines", children: warning }) })), (a.free_space ?? []).length > 0 && (_jsxs("p", { className: "muted ck-path", children: [(a.free_space ?? []).map(freeSpaceLine).join(" "), " ", FREE_SPACE_CAVEAT] })), a.items.length > 0 && (_jsxs("details", { className: "ck-detail ck-paths", children: [_jsxs("summary", { children: [_jsx(ChevronRight, { size: 14, strokeWidth: 1.75, "aria-hidden": true }), _jsx("span", { children: "Paths" })] }), a.items.map((i) => (_jsxs("p", { className: "muted ck-path", children: [shortPath(i.path), " \u00B7 ", i.restored ? "Restored" : i.interrupted ? "State unknown" : i.trash_path ? `In the ${TRASH}` : "Not restorable"] }, i.path)))] })), a.items.filter((i) => !i.restored && i.interrupted).map((i) => (_jsxs("p", { className: "muted ck-path", children: [shortPath(i.path), ": ", i.interrupted] }, i.path))), issue && (_jsxs("p", { className: "ck-issue", role: "alert", children: ["Some items stayed in the ", TRASH, ".", _jsx("span", { className: "ck-lines", children: issue })] }))] }), a.items.length > 0 && (_jsx(Button, { size: "sm", variant: "secondary", onClick: () => restore(a.id), disabled: busy || !canRestore, children: issue ? "Retry restore" : left.length === 0 ? "Restored" : "Restore" }))] }, a.id));
+            })] }));
+    const heading = !report
+        ? "Looking for what can go…"
+        : eligible.length === 0
+            ? "Nothing to clean up"
+            : `${total(eligible)} can go`;
+    return (_jsxs("div", { className: "view ck-cleanup", children: [_jsxs("div", { className: "ck-head", children: [_jsxs("div", { children: [_jsx("h2", { children: heading }), report && (_jsxs("p", { className: "muted", children: [eligible.length > 0 ? `${items(eligible.length)} · ` : "", "Updated ", ago(report.scanned_at), refreshing ? " · Refreshing…" : ""] }))] }), _jsx(Button, { size: "sm", variant: "secondary", onClick: refresh, disabled: busy || refreshing, children: refreshing ? "Refreshing…" : "Rescan" })] }), _jsx(SegmentedControl, { label: "Cleanup workspace", value: pane, options: [
+                    { value: "findings", label: "Findings" },
+                    { value: "history", label: `History · ${history.length}` },
+                ], onChange: (v) => setPane(v) }), note && (_jsxs(Notice, { tone: note.tone === "error" ? "bad" : note.tone, action: pane === "findings" && history.length > 0 ? (_jsx(Button, { size: "sm", variant: "secondary", onClick: () => setPane("history"), children: "History and restore" })) : undefined, children: [note.text, note.detail && _jsx("span", { className: "ck-lines", children: note.detail })] })), error && (_jsx(Notice, { tone: "bad", children: _jsx("span", { className: "ck-lines", children: error }) })), historyError && (_jsx(Notice, { tone: "bad", children: _jsx("span", { className: "ck-lines", children: historyError }) })), _jsx("div", { className: "ck-scroll", tabIndex: 0, "aria-label": "Cleanup content", children: pane === "history" ? (historyPane) : (_jsxs(_Fragment, { children: [report && report.findings.some((f) => f.partial) && (_jsx(Notice, { tone: "warn", children: "Some sizes are partial; \u2265 marks a lower bound." })), _jsx(ChromeSnapshotsLine, { info: report?.chrome_snapshots }), byCategory.length > 0 && (_jsxs("div", { className: "ck-card", "aria-label": "Where the space is", children: [_jsx("strong", { children: "Where the space is" }), byCategory.map((g) => (_jsxs("div", { className: "ck-held-row", children: [_jsxs("span", { children: [_jsx("strong", { children: g.category }), _jsxs("span", { className: "muted ck-reason", children: [items(g.xs.length), g.safety ? ` · ${g.safety}` : ""] })] }), _jsx("span", { className: "ck-num ck-size", children: bytes(g.bytes) })] }, g.category)))] })), report && eligible.length === 0 && _jsx("p", { className: "muted ck-empty", children: "Nothing to clean up right now. Rescan after apps close." }), eligible.length > 0 && (_jsxs("p", { className: "muted", children: [_jsx(Button, { size: "sm", variant: "secondary", onClick: freeUp, disabled: busy || freeable.length === 0, children: "Free this up" }), " ", "Selects the safe items and Chrome's signing copies for review. Nothing moves until you confirm."] })), eligible.length > 0 && (_jsxs("div", { className: "ck-card", children: [group("Safe to regenerate", safe), group("Review", review)] })), held.length > 0 && (_jsxs("details", { className: "ck-held", children: [_jsxs("summary", { children: [_jsx(ChevronRight, { size: 14, strokeWidth: 1.75, "aria-hidden": true }), _jsxs("span", { children: [_jsxs("strong", { children: [held.length, " not offered"] }), _jsx("span", { className: "muted", children: " \u00B7 informational, running or unverified" })] })] }), held.map((f) => (_jsxs("div", { className: "ck-held-row", children: [_jsxs("span", { children: [_jsx("strong", { children: f.name }), _jsx("span", { className: "muted ck-reason", children: f.reason }), f.kind && _jsx("span", { className: "muted ck-reason", children: facts(f) })] }), _jsx("span", { className: "ck-num ck-size", children: bytes(f.bytes) })] }, f.id)))] })), _jsxs("details", { className: "ck-about", children: [_jsxs("summary", { children: [_jsx(ChevronRight, { size: 14, strokeWidth: 1.75, "aria-hidden": true }), _jsx("span", { children: "About these numbers" })] }), _jsxs("p", { className: "muted", children: ["Nothing is deleted. Items go to the ", TRASH, ", where you can put them back or empty it yourself. Sizes are what the scan measured; \u2265 marks a lower bound when part of a folder could not be read. Items whose owner could not be verified, or whose app is running, are never offered. RustRight build targets are judged by RustRight's own state: a target a build holds or pins is never offered, and the current target is offered only after 14 days unused. Virtual machines are listed but not moved here; remove them with tart delete."] })] })] })) }), pane === "findings" && eligible.length > 0 && (_jsxs("div", { className: "ck-selection", children: [_jsxs("div", { children: [_jsxs("strong", { className: "ck-num", children: [chosen.length, " selected \u00B7 ", total(chosen)] }), _jsxs("span", { className: "muted", children: [" to move to the ", TRASH] })] }), _jsxs(Button, { onClick: () => setPending(chosen), disabled: busy || chosen.length === 0, children: ["Move ", chosen.length, " to ", TRASH] })] })), pending && (_jsx(ConfirmDialog, { title: `Move ${items(pending.length)} to the ${TRASH}?`, description: `${items(pending.length)}, ${total(pending)}, will move to the ${TRASH}${pending.some((f) => f.upper_bound || f.partial) ? ` (size is an estimate from allocated size, an upper bound: hard links and clones can make the real gain smaller)` : ""}. Nothing is deleted, and nothing is freed until the ${TRASH} is emptied: you can put them back from History here or from the ${TRASH}.`, confirmLabel: `Move to ${TRASH}`, onConfirm: () => move(pending), onCancel: () => setPending(null) }))] }));
+}

package/dist/views/DriveHealth.d.ts

@@ -0,0 +1,14 @@
+import { type DriveCard, type HealthAlert, type HealthReading } from "../api.js";
+/** Warning as the notch counts it: failed self-assessment, a critical warning, or media errors. */
+export declare function isWarning(reading: HealthReading): boolean;
+/** One drive's health on its volume card. Never blocks the card's scan action. */
+export declare function DriveHealthLine({ card, toolAvailable }: {
+    card: DriveCard | undefined;
+    toolAvailable: boolean;
+}): import("react").JSX.Element | null;
+/** The detail panel that opens from a drive's card. */
+export declare function DriveHealthPanel({ card, alerts, toolAvailable, }: {
+    card: DriveCard | undefined;
+    alerts: HealthAlert[];
+    toolAvailable: boolean;
+}): import("react").JSX.Element | null;