import type {
StorageCleanupReport,
StorageCleanupSettings,
WorktreeCleanupRules,
} from "@t3tools/contracts";
import { resolvePastedPath } from "@t3tools/shared/path";
import { resolveWorktreeCleanup } from "@t3tools/shared/projectSettings";
import { useRef, useState } from "react";
import { useAtomValue } from "@effect/atom-react";
import {
isAtomCommandInterrupted,
squashAtomCommandFailure,
} from "@t3tools/client-runtime/state/runtime";
import { formatBytes } from "../../lib/formatBytes";
import { environmentAtomList, environmentIdsKey } from "../../state/environmentAtomList";
import { serverEnvironment } from "../../state/server";
import { useAtomCommand } from "../../state/use-atom-command";
import { formatRelativeTimeLabel } from "../../timestampFormat";
import { useNowMinute } from "../../hooks/useNowMinute";
import { useDebouncedValue } from "../../state/queries";
import { AnimatedHeight } from "../AnimatedHeight";
import { Button } from "../ui/button";
import { toastManager } from "../ui/toast";
import { Input } from "../ui/input";
import { Select, SelectItem, SelectPopup, SelectTrigger, SelectValue } from "../ui/select";
import { Switch } from "../ui/switch";
import {
NumberField,
NumberFieldDecrement,
NumberFieldGroup,
NumberFieldIncrement,
NumberFieldInput,
} from "../ui/number-field";
import { SettingResetButton, SettingsRow, SettingsSection } from "./settingsLayout";
import { DatabaseStorageNotice } from "./DatabaseStorageNotice";
import { AdvancedSettings } from "./AdvancedSettings";
import { FoldedSettingsSection } from "./FoldedSettingsSection";
import { SettingsScopeNotice } from "./SettingsScopeNotice";
import { SettingsGroup } from "./SettingsGroup";
import type { ScopedSettingsTarget } from "./scopedSettings";
import { useSettingsScope } from "./SettingsScopeContext";
import { searchableSetting } from "./settingsSearch";
import {
useClearScopedSettings,
useScopedSettings,
useScopedSettingsMixed,
useUpdateScopedSettings,
} from "./useScopedSettings";
import { settingsScopeEnvironmentLabel } from "./settingsScopeAxis";
export function WorktreesDirectoryRow() {
const { connectedEnvironments, targets } = useSettingsScope();
const settings = useScopedSettings();
const updateSettings = useUpdateScopedSettings();
const mixed = useScopedSettingsMixed(["worktreesDirectory"]);
const edited = useRef(false);
const draft = useRef("");
if (
connectedEnvironments.some(
(environment) =>
environment.serverConfig?.environment.capabilities.worktreesDirectory !== true,
)
)
return null;
const scopeKey = targets.map((target) => target.environmentId).join(",");
return (
<SettingsRow
{...searchableSetting("storage-worktrees-location")}
description={
"Folder where new worktrees are created, on any drive, such as D:\\worktrees or ~/worktrees. Existing worktrees stay where they are. Leave empty to use the T3 home folder."
}
serverScoped
settingKeys={["worktreesDirectory"]}
resetAction={
mixed || settings.worktreesDirectory !== "" ? (
<SettingResetButton
label="worktree location"
onClick={() => updateSettings({ worktreesDirectory: "" })}
/>
) : null
}
control={
<Input
key={`${scopeKey}:${mixed}:${settings.worktreesDirectory}`}
aria-label="Worktree location"
autoCapitalize="none"
spellCheck={false}
placeholder={mixed ? "Mixed" : "Default"}
defaultValue={mixed ? "" : settings.worktreesDirectory}
onFocus={(event) => {
draft.current = event.target.value;
}}
onChange={(event) => {
edited.current = true;
draft.current = resolvePastedPath(draft.current, event.target.value);
event.target.value = draft.current;
}}
onBlur={(event) => {
const value = event.target.value.trim();
if (edited.current && (mixed || value !== settings.worktreesDirectory))
updateSettings({ worktreesDirectory: value });
edited.current = false;
}}
/>
}
/>
);
}
function RetentionControl({
label,
value,
onChange,
minimum = 1,
}: {
label: string;
value: number | null;
onChange: (value: number | null) => void;
minimum?: number;
}) {
const [draft, setDraft] = useState(value);
const [savedValue, setSavedValue] = useState(value);
if (savedValue !== value) {
setSavedValue(value);
setDraft(value);
}
return (
<div className="flex items-center gap-3">
{value !== null ? (
<NumberField
value={draft}
min={minimum}
max={3650}
step={1}
size="sm"
className="w-auto"
onValueChange={setDraft}
onValueCommitted={(next) => {
if (next === null) setDraft(value);
else {
const days = Math.min(3650, Math.max(minimum, Math.round(next)));
setDraft(days);
onChange(days);
}
}}
>
<NumberFieldGroup>
<NumberFieldDecrement aria-label={`Decrease ${label}`} />
<NumberFieldInput
aria-label={`${label} in days`}
size={5}
className="w-auto grow-0 text-right"
/>
<span aria-hidden="true" className="self-center pr-2 text-xs">
days
</span>
<NumberFieldIncrement aria-label={`Increase ${label}`} />
</NumberFieldGroup>
</NumberField>
) : (
<span className="text-xs text-muted-foreground">Off</span>
)}
<Switch
aria-label={label}
checked={value !== null}
onCheckedChange={(enabled) => onChange(enabled ? 8 : null)}
/>
</div>
);
}
const KEEP_WHEN_LABELS = {
"any-local-files": "Any local files",
"uncommitted-changes": "Uncommitted changes",
"tracked-changes": "Edited tracked files",
} as const;
function lastRunSummary(
entries: readonly { readonly label: string; readonly counts: string }[],
machineCount: number,
) {
const first = entries[0];
if (!first) return "";
if (machineCount <= 1) return first.counts;
if (entries.length === machineCount && entries.every((entry) => entry.counts === first.counts)) {
return `${first.counts} on every machine`;
}
return entries.map((entry) => `${entry.label}: ${entry.counts}`).join(" · ");
}
function CleanupResults({
report,
environmentLabel,
}: {
report: StorageCleanupReport;
environmentLabel: string;
}) {
return (
<>
{report.entries.map((entry, index) => {
const name =
entry.kind === "worktree"
? ((entry.threadId === null
? entry.path
: entry.path?.split(/[\\/]/).findLast(Boolean)) ?? "Worktrees")
: entry.kind === "logs"
? "Rotated logs"
: "Browser artifacts";
return (
<SettingsRow
key={`${entry.path ?? entry.kind}:${entry.threadId ?? index}`}
title={<span className="wrap-anywhere select-text">{name}</span>}
description={
<span className="block space-y-2 wrap-anywhere select-text">
<span className={`block ${entry.outcome === "failed" ? "text-destructive" : ""}`}>
{entry.reason}
</span>
<span className="grid grid-cols-[auto_minmax(0,1fr)] gap-x-3 gap-y-1 border-l border-border/60 pl-3">
<span>Machine</span>
<span className="text-foreground/80">{environmentLabel}</span>
{entry.projectPath && (
<>
<span>Project</span>
<code className="text-foreground/80">{entry.projectPath}</code>
</>
)}
{entry.path && (
<>
<span>Folder</span>
<code className="text-foreground/80">{entry.path}</code>
</>
)}
{entry.threadTitle && (
<>
<span>Thread</span>
<span>{entry.threadTitle}</span>
</>
)}
</span>
</span>
}
control={
(entry.outcome === "removed" ||
(entry.outcome === "kept" && entry.bytes !== null)) && (
<span className="text-xs text-muted-foreground">
{[
entry.kind !== "worktree" && entry.files !== null
? `${entry.files.toLocaleString()} ${entry.files === 1 ? "file" : "files"}`
: null,
entry.bytes !== null ? formatBytes(entry.bytes) : null,
]
.filter(Boolean)
.join(" · ")}
</span>
)
}
/>
);
})}
{report.omittedCount > 0 && (
<p className="px-3 py-2.5 text-xs text-muted-foreground sm:px-4">
{environmentLabel}: {report.omittedCount.toLocaleString()} more results.
</p>
)}
{report.entries.length === 0 && report.omittedCount === 0 && (
<p className="px-3 py-2.5 text-xs text-muted-foreground sm:px-4">
{environmentLabel}: Nothing needed cleanup.
</p>
)}
</>
);
}
const storageCleanupReportsAtom = environmentAtomList(
"web-storage-cleanup-reports",
(environmentId) => serverEnvironment.storageCleanupReport({ environmentId, input: {} }),
);
const storageCleanupPermissionsAtom = environmentAtomList(
"web-storage-cleanup-permissions",
serverEnvironment.runStorageCleanup.permissionAtom,
);
function CleanupSection() {
const nowMinute = useNowMinute();
const nowMs = Date.parse(`${nowMinute}:00.000Z`);
const { connectedEnvironments } = useSettingsScope();
const [pending, setPending] = useState(false);
const run = useAtomCommand(serverEnvironment.runStorageCleanup);
const supported = connectedEnvironments.filter(
(environment) => environment.serverConfig?.environment.capabilities.storageCleanupRun === true,
);
const supportedIds = supported.map(({ environmentId }) => environmentId);
const reports = useAtomValue(storageCleanupReportsAtom(environmentIdsKey(supportedIds)));
const permissions = useAtomValue(storageCleanupPermissionsAtom(environmentIdsKey(supportedIds)));
const state = supportedIds.map((environmentId, index) => {
const query = reports[index]!;
return {
environmentId,
allowed: permissions[index]!,
report: query._tag === "Success" ? query.value : null,
loading: query.waiting,
failed: query._tag === "Failure",
};
});
const hasRules = supported.some((environment) => {
const settings = environment.serverConfig?.settings;
if (!settings) return false;
const enabled = (rules: WorktreeCleanupRules) =>
rules.worktreeAfterDays !== null ||
rules.worktreeSettledAfterDays !== null ||
rules.worktreeOnMerge ||
rules.worktreeOnDelete ||
rules.worktreeUnchanged;
return (
settings.storageCleanup.browserArtifactsAfterDays !== null ||
settings.storageCleanup.logsAfterDays !== null ||
enabled(resolveWorktreeCleanup(settings, null)) ||
Object.values(settings.projectSettingsOverrides).some(
(override) =>
override.worktreeCleanup?.mode === "custom" && enabled(override.worktreeCleanup.rules),
)
);
});
if (supported.length === 0) return null;
const summaries = supported.map((environment) => {
const query = state.find((entry) => entry.environmentId === environment.environmentId);
const report = query?.report ?? null;
return {
environment,
report,
label: settingsScopeEnvironmentLabel(environment, connectedEnvironments),
counts: report
? `${report.counts.removed} removed, ${report.counts.kept} kept${report.counts.failed > 0 ? `, ${report.counts.failed} failed` : ""}`
: "",
description: report
? `Last run ${formatRelativeTimeLabel(report.finishedAt, nowMs)}. ${formatBytes(report.bytesFreed)} recovered.${report.counts.failed > 0 ? ` ${report.counts.failed} ${report.counts.failed === 1 ? "item" : "items"} couldn't be removed.` : ""}`
: query?.failed
? "Could not load the last run."
: query?.loading
? "Loading last run…"
: "Cleanup hasn't run yet.",
};
});
const deleteNow = async () => {
if (pending) return;
setPending(true);
await Promise.all(
supported
.filter((environment) =>
state.some((entry) => entry.environmentId === environment.environmentId && entry.allowed),
)
.map(async (environment) => {
const result = await run({ environmentId: environment.environmentId, input: {} });
if (result._tag === "Success") {
const failures = result.value.entries.filter((entry) => entry.outcome === "failed");
if (failures.length > 0)
toastManager.add({
type: "error",
title: `Cleanup failed on ${environment.label}`,
description: failures[0]!.reason,
});
} else if (!isAtomCommandInterrupted(result)) {
toastManager.add({
type: "error",
title: `Could not run cleanup on ${environment.label}`,
description: String(squashAtomCommandFailure(result)),
});
}
}),
).finally(() => setPending(false));
};
return (
<SettingsSection id="storage-cleanup" title="Cleanup" variant="plain">
<SettingsGroup>
<SettingsRow
{...searchableSetting("storage-delete-now")}
description={
<span>
{!hasRules
? "Turn on a cleanup rule to use this."
: summaries.map(({ environment, label, description }) => (
<span key={environment.environmentId} className="block">
{supported.length > 1 ? `${label}: ` : ""}
{description}
</span>
))}
</span>
}
control={
<Button
variant="outline"
size="sm"
disabled={pending || !hasRules || !state.some((entry) => entry.allowed)}
onClick={() => void deleteNow()}
>
{pending ? "Deleting…" : "Delete now"}
</Button>
}
/>
</SettingsGroup>
{summaries.some(({ report }) => report !== null) && (
<FoldedSettingsSection
id="storage-cleanup-last-run"
title="Last run"
headerPlacement="inside"
summary={lastRunSummary(
summaries.filter(({ report }) => report !== null),
connectedEnvironments.length,
)}
>
{summaries.map(
({ environment, label, report }) =>
report && (
<CleanupResults
key={environment.environmentId}
report={report}
environmentLabel={label}
/>
),
)}
</FoldedSettingsSection>
)}
</SettingsSection>
);
}
function supportsStorageCleanup(
environments: ReadonlyArray<{
readonly serverConfig: {
readonly environment: { readonly capabilities: { readonly storageCleanup?: boolean } };
} | null;
}>,
) {
return environments.every(
(environment) => environment.serverConfig?.environment.capabilities.storageCleanup === true,
);
}
/** Narrows a mixed selection to the machines that support cleanup. */
function StorageCleanupScopeNotice() {
const { connectedEnvironments } = useSettingsScope();
return (
<SettingsScopeNotice
inline
target="environment"
eligibleEnvironmentIds={connectedEnvironments
.filter(
(environment) =>
environment.serverConfig?.environment.capabilities.storageCleanup === true,
)
.map((environment) => environment.environmentId)}
>
Update the selected environments to use storage cleanup, or choose a machine that supports it.
</SettingsScopeNotice>
);
}
export function WorktreeCleanupSection() {
const { scope, environments, connectedEnvironments, targets, target } = useSettingsScope();
const scopedSettings = useScopedSettings();
const isProjectScope = scope.kind === "project" || scope.kind === "checkout";
const settings = {
...scopedSettings.storageCleanup,
...resolveWorktreeCleanup(scopedSettings, null),
};
const projectMode = (entry: ScopedSettingsTarget | null) =>
entry?.sources.worktreeCleanup === "project"
? (entry.settings.worktreeCleanup?.mode ?? "inherit")
: "inherit";
const mode = projectMode(target);
const mixedModes = targets.some((entry) => projectMode(entry) !== mode);
const updateSettings = useUpdateScopedSettings();
const clearSettings = useClearScopedSettings();
const ruleStatus = (key: keyof StorageCleanupSettings) =>
targets.some(
(target) =>
({ ...target.settings.storageCleanup, ...resolveWorktreeCleanup(target.settings, null) })[
key
] !== settings[key],
)
? "Mixed across selected machines"
: undefined;
// A policy locks these through worktreeCleanup, which also reaches each project's own rules.
const lockablePath = (key: keyof WorktreeCleanupRules) =>
isProjectScope ? ["worktreeCleanup"] : ["worktreeCleanup", `storageCleanup.${key}`];
const update = (patch: Partial<StorageCleanupSettings>) =>
updateSettings({ storageCleanup: patch });
const updateWorktree = (patch: Partial<WorktreeCleanupRules>) =>
isProjectScope
? updateSettings({ worktreeCleanup: { mode: "custom", rules: patch } })
: update(patch);
if (
isProjectScope &&
connectedEnvironments.some(
(environment) =>
environment.serverConfig?.environment.capabilities.projectWorktreeCleanup !== true,
)
) {
return (
<SettingsSection id="storage-worktrees" title="Cleanup" variant="plain">
<SettingsScopeNotice inline target="all">
Update the selected machines to configure project worktree cleanup.
</SettingsScopeNotice>
</SettingsSection>
);
}
if (!supportsStorageCleanup(connectedEnvironments)) {
return (
<SettingsSection id="storage-worktrees" title="Cleanup" variant="plain">
<StorageCleanupScopeNotice />
</SettingsSection>
);
}
return (
<SettingsSection id="storage-worktrees" title="Cleanup">
<>
{isProjectScope && (
<SettingsRow
title="Automatic worktree cleanup"
description={
mode === "off"
? "Keep this project's worktrees until you delete them manually."
: mode === "custom"
? "Use these rules for this project."
: "Use each machine's worktree cleanup settings."
}
serverScoped
settingKeys={["worktreeCleanup"]}
mixed={mixedModes}
control={
<Select
value={mixedModes ? null : mode}
onValueChange={(next) => {
if (next === "inherit") clearSettings(["worktreeCleanup"]);
else if (next === "off") updateSettings({ worktreeCleanup: { mode: "off" } });
else if (next === "custom")
updateSettings({ worktreeCleanup: { mode: "custom", rules: {} } });
}}
>
<SelectTrigger size="sm" aria-label="Automatic worktree cleanup">
<SelectValue>
{mixedModes
? "Mixed"
: mode === "inherit"
? "Inherit"
: mode === "off"
? "Off"
: "Custom"}
</SelectValue>
</SelectTrigger>
<SelectPopup align="end" alignItemWithTrigger={false}>
<SelectItem value="inherit">Inherit</SelectItem>
<SelectItem value="off">Off</SelectItem>
<SelectItem value="custom">Custom</SelectItem>
</SelectPopup>
</Select>
}
/>
)}
{(!isProjectScope || (!mixedModes && mode === "custom")) && (
<>
<SettingsRow
title="Delete worktrees with deleted threads"
status={ruleStatus("worktreeOnDelete")}
managedPaths={lockablePath("worktreeOnDelete")}
description="Remove unused worktrees when active or archived threads are deleted. Worktrees with local changes are kept."
serverScoped={!isProjectScope}
control={
<Switch
aria-label="Delete worktrees with deleted threads"
checked={settings.worktreeOnDelete}
onCheckedChange={(worktreeOnDelete) => updateWorktree({ worktreeOnDelete })}
/>
}
/>
<SettingsRow
title="Delete merged worktrees"
status={ruleStatus("worktreeOnMerge")}
managedPaths={lockablePath("worktreeOnMerge")}
description="Remove worktrees whose pull request is merged and whose commits are included in the default branch."
serverScoped={!isProjectScope}
control={
<Switch
aria-label="Delete merged worktrees"
checked={settings.worktreeOnMerge}
onCheckedChange={(worktreeOnMerge) => updateWorktree({ worktreeOnMerge })}
/>
}
/>
<SettingsRow
title="Delete inactive worktrees"
status={ruleStatus("worktreeAfterDays")}
managedPaths={lockablePath("worktreeAfterDays")}
description="Remove worktrees after their threads have been inactive for this many days. Branches and thread history are kept."
serverScoped={!isProjectScope}
control={
<RetentionControl
label="Delete inactive worktrees"
value={settings.worktreeAfterDays}
onChange={(worktreeAfterDays) => updateWorktree({ worktreeAfterDays })}
/>
}
/>
<AdvancedSettings
// The keep-when search result lands on this section, not its row.
targetIds={["storage-worktrees", searchableSetting("storage-worktree-keep-when").id]}
>
{connectedEnvironments.length > 0 &&
connectedEnvironments.every(
(environment) =>
environment.serverConfig?.environment.capabilities.settledWorktreeCleanup ===
true,
) && (
<SettingsRow
title="Delete settled worktrees"
managedPaths={lockablePath("worktreeSettledAfterDays")}
status={[
ruleStatus("worktreeSettledAfterDays"),
environments.length > connectedEnvironments.length
? "Offline machines will not get this setting"
: undefined,
]
.filter(Boolean)
.join(". ")}
description="Remove worktrees this many days after their thread settles. Set 0 days to remove them at the next cleanup. Branches and thread history are kept."
serverScoped={!isProjectScope}
control={
<RetentionControl
label="Delete settled worktrees"
value={settings.worktreeSettledAfterDays}
minimum={0}
onChange={(worktreeSettledAfterDays) =>
updateWorktree({ worktreeSettledAfterDays })
}
/>
}
/>
)}
<SettingsRow
title="Delete unchanged worktrees"
status={ruleStatus("worktreeUnchanged")}
managedPaths={lockablePath("worktreeUnchanged")}
description="Remove worktrees with no commits beyond the default branch."
serverScoped={!isProjectScope}
control={
<Switch
aria-label="Delete unchanged worktrees"
checked={settings.worktreeUnchanged}
onCheckedChange={(worktreeUnchanged) => updateWorktree({ worktreeUnchanged })}
/>
}
/>
{connectedEnvironments.every(
(environment) =>
environment.serverConfig?.environment.capabilities.storageCleanupRun === true,
) && (
<SettingsRow
{...searchableSetting("storage-worktree-keep-when")}
status={ruleStatus("worktreeKeepWhen")}
managedPaths={lockablePath("worktreeKeepWhen")}
description={
settings.worktreeKeepWhen === "any-local-files"
? "Includes ignored files, except node_modules."
: settings.worktreeKeepWhen === "tracked-changes"
? "Deletes untracked and ignored files, including .env."
: "Keeps edits and untracked files. Deletes ignored files, including .env."
}
serverScoped={!isProjectScope}
control={
<Select
value={ruleStatus("worktreeKeepWhen") ? null : settings.worktreeKeepWhen}
onValueChange={(next) => {
if (
next === "any-local-files" ||
next === "uncommitted-changes" ||
next === "tracked-changes"
)
updateWorktree({ worktreeKeepWhen: next });
}}
>
<SelectTrigger size="sm" aria-label="Keep worktrees with local changes">
<SelectValue>
{ruleStatus("worktreeKeepWhen")
? "Mixed"
: KEEP_WHEN_LABELS[settings.worktreeKeepWhen]}
</SelectValue>
</SelectTrigger>
<SelectPopup align="end" alignItemWithTrigger={false}>
<SelectItem value="any-local-files">Any local files</SelectItem>
<SelectItem value="uncommitted-changes">Uncommitted changes</SelectItem>
<SelectItem value="tracked-changes">Edited tracked files</SelectItem>
</SelectPopup>
</Select>
}
/>
)}
</AdvancedSettings>
</>
)}
</>
</SettingsSection>
);
}
/** Retention for logs and captures, and the manual cleanup run, which covers worktrees too. */
export function StorageCleanupSections() {
const { scope, connectedEnvironments, targets } = useSettingsScope();
const scopedSettings = useScopedSettings();
const updateSettings = useUpdateScopedSettings();
const settings = scopedSettings.storageCleanup;
const targetIdsKey = environmentIdsKey(targets.map((target) => target.environmentId).sort());
const artifactsMixed =
targets.length > 1 &&
targets.some(
(target) =>
target.settings.storageCleanup.browserArtifactsAfterDays !==
settings.browserArtifactsAfterDays,
);
const logsMixed =
targets.length > 1 &&
targets.some(
(target) => target.settings.storageCleanup.logsAfterDays !== settings.logsAfterDays,
);
const settledArtifactsStatus = useDebouncedValue(`${targetIdsKey}:${artifactsMixed}`, 300);
const settledLogsStatus = useDebouncedValue(`${targetIdsKey}:${logsMixed}`, 300);
const artifactsStatus =
targets.length > 1 && settledArtifactsStatus === `${targetIdsKey}:true`
? "Mixed across selected machines"
: undefined;
const logsStatus =
targets.length > 1 && settledLogsStatus === `${targetIdsKey}:true`
? "Mixed across selected machines"
: undefined;
if (scope.kind === "project" || scope.kind === "checkout") return null;
const update = (patch: Partial<StorageCleanupSettings>) =>
updateSettings({ storageCleanup: patch });
const databaseStorageNotice = (
<DatabaseStorageNotice
environments={connectedEnvironments.filter(
(environment) =>
environment.serverConfig?.environment.capabilities.databaseStorage === true,
)}
/>
);
if (!supportsStorageCleanup(connectedEnvironments)) {
return (
<>
{databaseStorageNotice}
<SettingsSection id="storage-artifacts" title="Artifacts and logs" variant="plain">
<StorageCleanupScopeNotice />
</SettingsSection>
</>
);
}
return (
<>
{databaseStorageNotice}
<SettingsSection id="storage-artifacts" title="Artifacts and logs">
<AnimatedHeight>
<SettingsRow
title="Delete old browser artifacts"
status={artifactsStatus}
managedPaths={["storageCleanup.browserArtifactsAfterDays"]}
description="Delete saved browser captures after this many days. Older capture links will no longer open."
serverScoped
control={
<RetentionControl
label="Delete old browser artifacts"
value={settings.browserArtifactsAfterDays}
onChange={(browserArtifactsAfterDays) => update({ browserArtifactsAfterDays })}
/>
}
/>
</AnimatedHeight>
<AnimatedHeight>
<SettingsRow
title="Delete old rotated logs"
status={logsStatus}
managedPaths={["storageCleanup.logsAfterDays"]}
description="Delete inactive rotated log files after this many days. Current logs are kept."
serverScoped
control={
<RetentionControl
label="Delete old rotated logs"
value={settings.logsAfterDays}
onChange={(logsAfterDays) => update({ logsAfterDays })}
/>
}
/>
</AnimatedHeight>
</SettingsSection>
<CleanupSection />
</>
);
}